Solution of the Problem P = L

Abstract

The problems associated with the construction of polynomial complexity computer programs require new techniques and approaches from mathematicians. One of such approaches is representing some class of polynomial algorithms as a certain class of special logical programs. Goncharov and Sviridenko described a logical programming language $L_0$, where programs inductively are obtained from the set of ${\Delta }_0$-formulas using special terms. In their work, a new idea has been proposed to look at the term as a program. The computational complexity of such programs is polynomial. In the same years, a number of other logical languages with similar properties were created. However, the following question remained: can all polynomial algorithms be described in these languages? It is a long-standing problem, and the method of describing some polynomial algorithm in a not Turing complete logical programming language was not previously clear. In this paper, special types of terms and formulas have been found and added to solve this problem. One of the main contributions is the construction of p-iterative terms that simulate the work of the Turing machine. Using p-iterative terms, the work showed that class P is equal to class L, which extends the programming language $L_0$ with p-iterative terms. Thus, it is shown that L is quite expressive and has no halting problem, which occurs in high-level programming languages. For these reasons, the logical language L can be used to create fast and reliable programs. The main limitation of the language L is that the implementation of algorithms of complexity is not higher than polynomial.

1. Introduction

In the 1980s–1990s, Ershov, Goncharov, and Sviridenko presented the theory of semantic programming [1]. The concepts of $\Sigma$-programs and $\Sigma$-specifications were introduced in this work. The hereditary finite list superstructure was chosen as a base mathematical model. The universe of this model is the hereditary finite lists generated by elements of the universe of the base model [2], and some LISP-like functions were added. Special logical $\Sigma$-formulas with input and output variables were used as $\Sigma$-programs [3]. This gave rise to the study of programming language semantics from a mathematical point of view.

Cenzer and Remmel were among the first to study polynomial structures [4]. They investigated the existence of computable isomorphisms between computable and polynomial structures. Then, Lewis and Papadimitriou explored polynomial-time reductions [5]. Then, for a long time, the open problem was to create a logical programming language, which would have polynomial complexity. Mantsivoda developed a logical programming language based on document models. Documents are the main elements of the model universe. Special functions are defined for working with them. Mantsivoda and Ponomaryov formalized this approach in their work [6]. This language is simple and efficient. All operations and relations are polynomial. After that, another type of logical programming language, semantic domain-specific languages, was developed [7]. This language is based on the ideas of semantic programming where a truth-checking formula on the model replaced computability [1]. All programs also have polynomial complexity, but the question of how well it described the class of polynomial algorithms remained. In the work [8], some interesting results were presented. The authors found that the primitive recursive representation of the algorithm with boundaries of the variables often had a polynomial complexity. Then, Alaev investigated the questions of polynomial representability of various structures in his work [9]. This work gave the key to understanding what polynomiality is. In parallel, Goncharov and Sviridenko developed and presented a new logical programming language in which special terms were used as logical programs [10]. All programs in this language have polynomial computational complexity. However, the main question remains: can all polynomial algorithms be described by this language? The result that will be proved in this work answers this question.

After proving the polynomial analogue of Gandy’s fixed point theorem [11], it became clear that the language $L_0$ is wide enough. This language is used to construct quite complex constructions. In particular, this concerned the inductive construction of new types of data and computer programs in programming.

2. Preliminaries

Let $\mathfrak{B}$ be a p-computable model of the signature ${\sigma }_0$. A p-computable hereditary finite list superstructure $HW\left(\mathfrak{B}\right)$ [11] was chosen as a mathematical model of the signature $\sigma$. The universe of the model $HW\left(\mathfrak{B}\right)$ consists of elements of the model universe B and hereditarily finite lists $HW\left(B\right)$. Signature $\sigma$ extends ${\sigma }_0$ with the next LISP-like list relations ∈ (to be an element of a list), ⊆ (to be an initial segment of a list) and the list operations $head$, $tail$, $cons$, $conc$, and constant $nil$ [12]. Define new unary list operations $first$, $cons\_l$, $tail\_l$. The first operation $first$ gets the first list element, the second $cons\_l$ adds the element into the beginning of the list and the last operation $tail\_l$ removes the first element from the list correspondingly. Define new unary operations $strList$, $listStr$. The first operation $strList$ based on the input string of the form $l_1\dots l_k$ builds a list of the form $<l_1,\dots ,l_k>$, where $l_i\in \Sigma$, $i\in [1,\dots ,k]$, the second operation $listStr$ based on the input list of the form $<l_1,\dots ,l_k>$ builds a string $l_1\dots l_k$, where $l_i\in \Sigma$, $i\in [1,\dots ,]$. The signature $\sigma$ is an extension of ${\sigma }_0$ with these new operation symbols. The main operations $head$, $tail$, $cons$, $conc$, and relations ∈, ⊆ have polynomial complexity [12]. It is easy to see that other operations $first$, $cons\_l$, $tail\_l$, $strList$, and $listStr$ have polynomial complexity.

Define ${\Delta }_0$-formulas as first order formulas of the signature $\sigma$ in which quantification is of the following two types:

• a restriction onto the list elements $\forall x\in t$ and $\exists x\in t$.
• a restriction onto the initial segments of list $\forall x\subseteq t$ and $\exists x\subseteq t$.

The set of ${\Delta }_0$-formulas of the signature $\sigma$ has been extended by induction with several types of terms: conditional terms, b-while terms, bounded recursive terms, and etc. [10] These formulas are denoted as ${\Delta }_0\left(\mathfrak{I}\right)$-formulas and new terms are denoted as ${\Delta }_0\left(\mathfrak{I}\right)$-terms. Denote the resulting set of ${\Delta }_0\left(\mathfrak{I}\right)$-terms as a language $L_0$.

Definition 1.

Any${\Delta }_0\left(\mathfrak{I}\right)$-term from the language$L_0$will be referred to as$L_0$-program.

Definition 2.

Any${\Delta }_0\left(\mathfrak{I}\right)$-formula will be referred to as$L_0$-formula.

$L_0$-program property:

• any $L_0$-program has a polynomial computation complexity on any p-computable enrichment $HW{\left(\mathfrak{B}\right)}^{*}$ of the model $HW\left(\mathfrak{B}\right)$.

$L_0$-formula property:

• any $L_0$-formula has a polynomial truth-checking algorithm on any p-computable enrichment $HW{\left(\mathfrak{B}\right)}^{*}$ of the model $HW\left(\mathfrak{B}\right)$.

In this work, to construct a suitable logical program for a polynomial function, the concept of a conditional term from the work of Goncharov [13] is used. Let $t_0,t_1,\dots ,t_{n+1}$ is $L_0$-programs and ${\theta }_0,\dots ,{\theta }_n$ is $L_0$-formulae [10]. Define the concept of a conditional term $t\left(\overline{v}\right)$ in the next interpretation:

$$t\left(\overline{v}\right)=\left\{\begin{array}{c}{t}_0\left(\overline{v}\right),\mathrm{if}HW\left(\mathfrak{B}\right)\vDash {\theta }_0\left(\overline{v}\right)\hfill \\ t_1\left(\overline{v}\right),\mathrm{if}HW\left(\mathfrak{B}\right)\vDash {\theta }_1\left(\overline{v}\right)\&\neg {\theta }_0\left(\overline{v}\right)\hfill \\ \dots \hfill \\ t_n\left(\overline{v}\right),\mathrm{if}HW\left(\mathfrak{B}\right)\vDash {\theta }_n\left(\overline{v}\right)\&\neg {\theta }_0\left(\overline{v}\right)\&\dots \&\neg {\theta }_{n-1}\left(\overline{v}\right)\hfill \\ t_{n+1}\left(\overline{v}\right),\mathrm{otherwise}\hfill \end{array}\right.$$

(1)

where $\overline{v}$ have a form $(v_1,\dots ,v_k)$ for some $k\in N$.

Conditional terms use a construction similar to the operator “if then else” in high-level programming languages. Leave also the other types of terms from [10] for the expressiveness of a new language. However, in the future, to construct a term describing a polynomial function, only conditional terms from work [10] will be used.

3. Polynomial Functions and Turing Machines

Let $T_f$ be a deterministic Turing machine over the alphabet $\Sigma$ representing polynomial function f. Let S be the set of symbols $\{1,B\}$ and Q be the set of states of the Turing machine, where $q_1$ is the initial state and $q_0$ is the final state. Let $P_{T_f}$ be a Turing machine program that implements the function f. Since any program of the Turing machine is implemented through $\sigma :Q\times S\to Q\times S\times \{R,L\}$, then all elements of the program $P_{T_f}$ will be presented in the form of a list $<q_{i_1},s_{j_1},q_{i_2},s_{j_2},\beta >$. Sequence of the symbols

$$c_i:s_{-m_i}\dots s_{-2}{s}_{-1}{q}_{k_i}{s}_0{s}_1\dots s_{n_i}$$

(2)

is called the configuration of the Turing machine at the ith step.

Let $\beta$ be the symbol from the set $\{R,L\}$. Let $c_i$ be some configuration of $T_f$ and there is a element $<q_{i_1},s_{j_1},q_{i_2},s_{j_2},\beta >$ from the program $P_{T_f}$. Then, with the help of this element, the configuration $c_i$ will switch to another configuration $c_j$.

Since the Turing machine $T_f$ represents a polynomial function f over the alphabet $\Sigma$, the machine will work on any input $x\in {\Sigma }^{*}$ no more than

$$p(|x|)=C_p·{|x|}^{n_p}$$

(3)

steps for some fixed $C_p,n_p\in N$. Let $r\left(f\right(x\left)\right)$ be the computational complexity of the function $f\left(x\right)$. From (3), it follows:

$$r\left(f\right(x\left)\right)\le p(|x|)$$

(4)

If the Turing machine $T_f$ changes configuration $c_i$ on $c_{i+1}$, then:

$$|c_i|-1\le |c_{i+1}|\le |c_i|+1$$

(5)

and from (5) the inequality follows for the final configuration $c_{final}$:

$$|c_{final}|\le |c_0|+p(|x|)\le d(|x|),\mathrm{for}\mathrm{some}\mathrm{polynomial}d(|x|)$$

(6)

It should be noted that if $T_f$ reached the final configuration $c_{final}=c_j$ for some jth step and $j\le p(|x|)$; then, all the remaining configurations $c_{j+1},\dots ,c_{p(|x|)}$ would be equal to $c_{final}$.

Using the configuration $c_i$ of the form (2) define a machine word $w_{c_i}$ in the next form:

$$w_{c_i}:<<s_{-m_i},\dots ,s_{-1}>,\underline{q_{k_i}},<s_0,\dots ,s_{n_i}>>$$

(7)

where $\underline{q_{k_i}}$ is equal to a string $q\dots q$ of the length $k_i+1$ and $s_k\in \{B,1\}$, $k\in [-m_i,n_i]$.

Define $w_{c_i,k}$ as the k-th element of the machine word $w_{c_i}$, where $k\in \{1,2,3\}$.

If configuration $c_i$ has a form $q_{k_i}{s}_0\dots s_{n_i}$, then the machine word $w_{c_i}$ has a form:

$$w_{c_i}:<nil,\underline{q_{k_i}},<s_0,\dots ,s_{n_i}>>$$

(8)

Remark 1.

(1) 

the state $\underline{q_{k_i}}$ is obtained from $w_{c_i}$ and equal $head\left(tail\left(w_{c_i}\right)\right)$

(2) 

monitored symbol $s_0$ is obtained from $w_{c_i}$ and equal $first\left(head\left(w_{c_i}\right)\right)$.

Remark 2.

(1) 

Equality (5) implies that

$$|w_{c_i}|-C\le |w_{c_{i+1}}|\le |w_{c_i}|+C,forsomefixedC\in N$$

(9)

(2) 

Equalities (6) and (9) imply that

$$|w_{c_{final}}|\le |w_{c_0}|+p(|x|)·C\le r^{\prime }(|x|)forsomepolynomial{r}^{\prime }(|x|).$$

Define a new binary operation ⊗ using the machine word $w_{c_i}$ and the element $<\underline{q_1},s_1,\underline{q_2},s_2,\beta >$ from the program $P_{T_f}$:

Case 1: element equal $<\underline{q_1},s_1,\underline{q_2},s_2,R>$

$$w_{c_i}\otimes <\underline{q_1},s_1,\underline{q_2},s_2,R>=\left\{\begin{array}{c}{w}_{c_j},\mathrm{if}head\left(tail\left(w_{c_i}\right)\right)=\underline{q_1}\mathrm{and}first\left(head\left(w_{c_i}\right)\right)=s_1\hfill \\ nil,\mathrm{otherwise}\hfill \end{array}\right.$$

(10)

and $w_{c_j}=<w_{c_j,1},w_{c_j,2},w_{c_j,3}>$, where

$$\begin{gathered} w_{c_j,1}=cons(first\left(w_{c_i}\right),s_2);w_{c_j,2}=\underline{q_2}; \\ {w}_{c_j,3}=tail\_l\left(head\left(w_{c_i}\right)\right); \end{gathered}$$

Case 2: element equal $<\underline{q_1},s_1,\underline{q_2},s_2,L>$

$$w_{c_i}\otimes <\underline{q_1},s_1,\underline{q_2},s_2,L>=\left\{\begin{array}{c}{w}_{c_j},\mathrm{if}head\left(tail\left(w_{c_i}\right)\right)=\underline{q_1}\mathrm{and}first\left(head\left(w_{c_i}\right)\right)=s_1\hfill \\ nil,\mathrm{otherwise}\hfill \end{array}\right.$$

(11)

and $w_{c_j}=<w_{c_j,1},w_{c_j,2},w_{c_j,3}>$, where

$$\begin{gathered} w_{c_j,1}=tail\left(first\left(w_{c_i}\right)\right);w_{c_j,2}=\underline{q_2}; \\ {w}_{c_j,3}=cons\_l(cons\_l(tail\_l\left(head\left(w_{c_i}\right)\right),s_2),head\left(first\left(w_{c_i}\right)\right)); \end{gathered}$$

Remark 3.

Operation ⊗ is polynomial.

4. p-Iterative Terms

From the previous section, the length of the final machine word $w_{c_{final}}$ does not exceed the length of the initial machine word $w_{c_0}$ plus the length of some polynomial $r^{\prime }(|x|)$. The main goal of this section is to construct a p-iterative term so that the length of the final value should not exceed the length of the input value plus the value of some polynomial $v(|x|)$. Furthermore, it will be shown that such extension using p-iterative terms of the language $L_0$ does not take us beyond the polynomiality.

Let $HW\left(\mathfrak{B}\right)$ be a p-computable model of the signature $\sigma$, $g\left(\mathbf{x}\right)$ be a $L_0$-program, $\phi \left(\mathbf{x}\right)$ be a $L_0$-formula. Require $|g\left(\mathbf{x}\right)|\le |\mathbf{x}|+C_g$ for some $C_g\in N$. Let $u(|\mathbf{x}|)$ be a polynomial such that the complexity of checking the truth of the $L_0$-formula $\phi \left(\mathbf{x}\right)$ on model $HW\left(\mathfrak{B}\right)$ should not exceed $u(|\mathbf{x}|)$. Let computation complexity $r\left(g\right(\mathbf{x}\left)\right)$ of $L_0$-program $g\left(\mathbf{x}\right)$ be bounded by some polynomial $s(|\mathbf{x}|)=C_s·{|\mathbf{x}|}^{n_s}$. Define a p-iterative term $t(\mathbf{x},n)$ using the following iterative construction:

$$\begin{array}{c}{g}^0\left(\mathbf{x}\right)=g\left(\mathbf{x}\right)\hfill \\ \dots \hfill \\ g^{i+1}\left(\mathbf{x}\right)=g\left(g^i\left(\mathbf{x}\right)\right)\hfill \end{array}$$

(12)

The p-iterative term has the form:

$$t(\mathbf{x},n)=\left\{\begin{array}{c}{g}^i\left(\mathbf{x}\right),\mathrm{if}i\le nHW\left(\mathfrak{B}\right)\vDash \left(g^i\left(\mathbf{x}\right)\right)\mathrm{and}\forall j<iHW\left(\mathfrak{B}\right)⊭\phi \left(g^j\left(\mathbf{x}\right)\right))\hfill \\ nil,\mathrm{otherwise}\hfill \end{array}\right.$$

(13)

Remark 4.

$|g^{i+1}\left(\mathbf{x}\right)|\le |g^i\left(\mathbf{x}\right)|+C_g$.

Theorem 1.

Let$HW\left(\mathfrak{B}\right)$be a p-computable model,$\phi \left(\mathit{x}\right)$be a$L_0$-formula, and$g\left(\mathit{x}\right)$be a$L_0$-program with the condition$|g\left(\mathit{x}\right)|\le |\mathit{x}|+C_g$,$C_g\in N$. Then, p-iterative term from (13) is a p-computable function.

Proof. 

Let $t(\mathbf{x},n)$ be a p-iterative term. If the value of the term $t(\mathbf{a},n_0)$ equal $g^{i+1}\left(\mathbf{a}\right)$; then, $HW\left(\mathfrak{B}\right)\vDash \phi \left(g^{i+1}\left(\mathbf{a}\right)\right)$ for some $\mathbf{a}\in HW\left(B\right)$, $n_0\in N$, and $i+1\le n_0$. It can be inferred that the length of p-iterative term for $i+1$ iteration:

$$|g^{i+1}\left(\mathbf{a}\right)|\le |g^i\left(\mathbf{a}\right)|+C_g\le |g^0\left(\mathbf{a}\right)|+(i+1)·C_g\le |\mathbf{a}|+(i+2)·C_g$$

and for any $i\le n_0$:

$$|g^i\left(\mathbf{a}\right)|\le |g^0\left(\mathbf{a}\right)|+n_0·C_g\le |\mathbf{a}|+(n_0+1)·C_g\le (|\mathbf{a}|+n_0)·(C_g+1)+C_g\le z(|\mathbf{a}|+n_0)$$

where

$$z(|\mathbf{x}|)=(C_g+1)·|\mathbf{x}|+C_g.$$

(14)

The next step is to calculate the computational complexity $r\left(t\right(\mathbf{x},n\left)\right)$ of the p-iterative term. The algorithm is the following for some fixed $\mathbf{a}$ and $n_0$:

step 0:

Calculate $g^0\left(\mathbf{a}\right)$ (it is necessary to calculate $g\left(\mathbf{a}\right)$) and check the truth of the $L_0$-formula $\phi \left(g^0\left(\mathbf{a}\right)\right)$ on the model $HW\left(\mathfrak{B}\right)$. If $L_0$-formula is true, then leave the algorithm running and send value $g^0\left(\mathbf{a}\right)$; otherwise, go to the next step.

step 1:

Calculate $g^1\left(\mathbf{a}\right)$ (it is necessary to calculate $g\left(g^0\left(\mathbf{a}\right)\right)$), where $g^0\left(\mathbf{a}\right)$ is known on step 0 and check the truth of the $L_0$-formula $\phi \left(g^1\left(\mathbf{a}\right)\right)$ on the model $HW\left(\mathfrak{B}\right)$. If $L_0$-formula is true, then leave the algorithm running and send value $g^1\left(\mathbf{a}\right)$; otherwise, go to the next step.

…

step i:

Calculate $g^i\left(\mathbf{a}\right)$ (it is necessary to calculate $g\left(g^{i-1}\left(\mathbf{a}\right)\right)$), where $g^{i-1}\left(\mathbf{a}\right)$ is known on step $i-$ 1 and check the truth of the $L_0$-formula $\phi \left(g^i\left(\mathbf{a}\right)\right)$ on the model $HW\left(\mathfrak{B}\right)$. If $L_0$-formula is true, then leave the algorithm running and send value $g^i\left(\mathbf{a}\right)$, otherwise go to the next step.

…

step n:

Calculate $g^{n_0}\left(\mathbf{a}\right)$ (it is necessary to calculate $g\left(g^{n_0-1}\left(\mathbf{a}\right)\right)$), where $g^{n_0-1}\left(\mathbf{a}\right)$ is known on step $n-1$ and check the truth of the $L_0$-formula $\phi \left(g^{n_0}\left(\mathbf{a}\right)\right)$ on the model $HW\left(\mathfrak{B}\right)$. If $L_0$-formula is true, then leave the algorithm running and send value $g^{n_0}\left(\mathbf{a}\right)$, otherwise send $nil$.

Let $\mathbf{w}$ be $g^i\left(\mathbf{a}\right)$ and $|g^i\left(\mathbf{a}\right)|\le z(|\mathbf{a}|+n_0)$, as $r\left(g\right(\mathbf{w}\left)\right)\le s(|\mathbf{w}|)$ it can be inferred that:

$$r\left(t(\mathbf{a},n_0)\right)\le \sum _{i=0}^{n_0}\left(s\right(z(|\mathbf{a}|+n_0\left)\right)+u\left(z\right(|\mathbf{a}|+n_0\left)\right))$$

(15)

and get inequality:

$$r\left(t(\mathbf{a},n_0)\right)\le \left(s\right(z(|\mathbf{a}|+n_0\left)\right)+u\left(z\right(|\mathbf{a}|+n_0\left)\right))·(n_0+1)\le d(|\mathbf{a}|+n_0)$$

for some polynomial $d(|\mathbf{x}|)$ and polynomial $z(|x|)$ from (14). □

Corollary 1.

Let the conditions of Theorem 1 be satisfied and$f(|x|)$be some polynomial. Then, any p-iterative term of the form$t(x,f(|x|\left)\right)$is a p-computable function relative to variable x.

Proof. 

The condition of Theorem 1 implies that there exists a polynomial $z\left(\mathbf{x}\right)$ from (14)

$$r\left(t\right(\mathbf{x},f(|\mathbf{x}|)\left)\right)\le z(|\mathbf{x}|+f(|\mathbf{x}|\left)\right)\le z\left(w\right(|\mathbf{x}|\left)\right)\le v(|\mathbf{x}|)$$

where polynomial $w(|\mathbf{x}|)$ has a form $|\mathbf{x}|+f(|\mathbf{x}|)$ and polynomial $v(|\mathbf{x}|)$ has a form $z\left(w\right(|\mathbf{x}|\left)\right)$. □

Definition 3.

Define a new language L. Language L extends $L_0$ by p-iterative terms. Classes L-formulas and L-programs extend the classes of $L_0$-formulas and $L_0$-programs, respectively.

Theorem 2.

Let $HW{\left(\mathfrak{B}\right)}^{*}$ be a p-computable extension of the p-computable model $HW\left(\mathfrak{B}\right)$ of the signature ${\sigma }^{*}$. Then, any L-program has polynomial computational complexity on $HW{\left(\mathfrak{B}\right)}^{*}$.

Proof. 

To prove this statement, it is nessesary to use induction on the number of distinct p-iterative terms for some L-program $t\left(\mathbf{x}\right)$:

Base of induction n = 0:$t\left(\mathbf{x}\right)$ does not contain a p-iterative term. Then computation complexity of the $t\left(\mathbf{x}\right)$ is polynomial; this follows immediately from the work [10].

Induction step: Let the statement be true for $n=k$; show this for $n=k+1$. Let $t\left(\mathbf{x}\right)$ be a L-program with $k+1$ distinct p-iterative terms. Let $HW{\left(\mathfrak{B}\right)}^{**}$ be enrichment of the model $HW{\left(\mathfrak{B}\right)}^{*}$ of the signature ${\sigma }^{**}={\sigma }^{*}\cup \left\{t_1\right\}$, where p-iterative term $t_1$ is involved in construction $t\left(\mathbf{x}\right)$. In the new model $HW{\left(\mathfrak{B}\right)}^{**}$, L-program $t\left(\mathbf{x}\right)$ has only k distinct p-iterative terms and by induction step, the L-program $t\left(\mathbf{x}\right)$ has a polynomial complexity. □

5. Polynomiality via p-Iterative Terms

Let $f\left(\mathbf{x}\right)$ be a p-computable function, and let $h(|\mathbf{x}|)$ be a polynomial, such that $r\left(f\right(\mathbf{x}\left)\right)\le h(|\mathbf{x}|)$.

Let the universe of the model $HW\left(\mathfrak{B}\right)$ contain the natural numbers N in the main set. Signature $\sigma$ contains the constants 0 and 1, $\Sigma$ alphabet, and R and L, contain multiplication × and addition + operations on N, operation of string concatenation $concat$, and operation of string length ($||$).

Remark 5.

The new operations ×, +, concat, and $||$ are polynomial.

For any polynomial $h(|\mathbf{x}|)$, there is a suitable L-program. Let $\underline{q_{i_1}}$ be a L-program of the form $concat\left(concat\right(\dots concat(q,q)\dots ),q)$, where the function $concat$ is used $i_1+1$-times. Then, for each element of the form $<q_{i_1},s_{j_1},q_{i_2},s_{j_2},\beta >$ from the Turing machine program $P_{T_f}$, there is a suitable L-program $v(\underline{q_{i_1}},s_{j_1},\underline{q_{i_2}},s_{j_2},\beta )$ of the form:

$$v(\underline{q_{i_1}},s_{j_1},\underline{q_{i_2}},s_{j_2},\beta )=cons(cons(cons(cons(cons(nil,\underline{q_{i_1}}),s_{j_1}),\underline{q_{i_2}}),s_{j_2}),\beta )$$

(16)

Theorem 3.

For any p-computable function, there is an L-program defining this function.

Proof. 

Let f be some p-computable function, $h(|\mathbf{x}|)$ some polynomial such that:

$$r\left(f\right(\mathbf{x}\left)\right)\le h(|\mathbf{x}|)$$

(17)

Consider the Turing machine $T_f$ over alphabet $\Sigma$ with program $P_{T_f}$ that realizes the function f. Let us construct a list $l_f$ of terms of the form $v(q_{i_1},s_{j_1},q_{i_2},s_{j_2},\beta )$ use (16) from the program $P_{T_f}$, where $\beta \in \{R,L\}$. Then, L-formula $\phi \left(\mathbf{x}\right)$ has a form:

$$\phi \left(\mathbf{x}\right):Final\left(\mathbf{x}\right)$$

(18)

where predicate $Final\left(w\right)$ is true if w is a machine word of the form

$$<<s_{-m},\dots ,s_{-1}>,\underline{q_0},<s_1,\dots ,s_k>>$$

It is apparent that the predicate $Final\left(\mathbf{x}\right)$ has a polynomial complexity.

Define $tai{l}^k\left(\mathbf{x}\right)$ as applying $\mathit{tail}$ operation k times to $\mathbf{x}$. A conditional term $g\left(\mathbf{x}\right)$ [10] will be used for constructing a final L-program:

$$g\left(\mathbf{x}\right)=\left\{\begin{array}{c}\mathbf{x}\otimes l_1,\mathrm{where}(l_1=first\left(l_f\right))\&(\mathbf{x}\otimes l_1\ne nil)\hfill \\ \dots \hfill \\ \mathbf{x}\otimes l_i,\mathrm{where}(l_i=head\left(tai{l}^{k-i}\left(l_f\right)\right))\&(\mathbf{x}\otimes l_i\ne nil)\hfill \\ \dots \hfill \\ \mathbf{x}\otimes l_k,\mathrm{where}(l_k=head\left(l_f\right))\&(\mathbf{x}\otimes l_k\ne nil)\hfill \\ \mathbf{x},\mathrm{otherwise}\hfill \end{array}\right.$$

(19)

Define $mw\left(\mathbf{x}\right)$ as the L-program that transforms a word $\mathbf{w}$ to the machine word of the form $<nil,\underline{q_1},\mathbf{w}>$. This L-program has a form:

$$mw\left(\mathbf{x}\right)=cons(cons\_l(cons(nil,\underline{q_1}),nil),strList\left(\mathbf{x}\right))$$

(20)

L-program $mw\left(\mathbf{x}\right)$ transforms the word $\mathbf{x}$ to the machine word for the initial configuration $c_0$ of the Turing machine $T_f$.

Define $value\left(\mathbf{x}\right)$ as the L-program that transforms a machine word w into the word on the tape of the Turing machine $T_f$. This function is constructed as follows:

$$value\left(w\right)=listStr\left(conc\right(first\left(w\right),head\left(w\right)\left)\right)$$

(21)

Define p-iterative term $t\left(mw\right(\mathbf{x}),h(|\mathbf{x}|\left)\right)$ using construction (12) with the L-program $g\left(x\right)$ of the form (19), the formula $\phi$ from (18), the polynomial $h(|\mathbf{x}|)$ from (17), and L-programs from (20) and (21).

The final L-program representing the function $f\left(\mathbf{x}\right)$ has the form:

$$value\left(t\right(mw\left(\mathbf{x}\right),h(|\mathbf{x}|)\left)\right)$$

(22)

Note that the L-program $t\left(mw\right(\mathbf{x}),h(|\mathbf{x}|\left)\right)$ satisfies the conditions of Theorem 1 and, therefore, $value\left(t\right(mw\left(\mathbf{x}\right),h(|\mathbf{x}|)\left)\right)$ is a p-computable. □

6. Conclusions

The work shows the equality of classes P and L. The main motivation was to create a not Turing complete logical programming language describing the class of polynomial algorithms. Programs in this language are logical terms and have polynomial complexity. For any polynomial algorithm, there is a program describing it. One of the main contributions of this work is the construction of a new logical language L that is equal to the class P. Another contribution is the construction of a p-iterative term for this. The main limitation is that this language is not Turing complete. Therefore, it is impossible to realize algorithms on it with the complexity being higher than polynomial.

Thus, language L is rich enough to describe any algorithms of polynomial complexity. These results are one more step in the construction of high-level programming languages based on logical language L. Moreover, programs in such languages will remain polynomially computable. It means that programs stop running every time, work quickly, and produce results. It is especially important during the development of blockchain technologies and smart contracts. Since smart contracts are programs in a distributed environment, the correct functioning of the entire blockchain as a whole depends on the result of its execution. Such smart contracts should be executed quickly and should not consume a lot of computing resources.

The work has built a logical language that allows one to create fast and reliable programs. These programs will be used in computer science, robotics, the Internet of things, blockchain technologies, medicine, and artificial intelligence.

High-quality artificial intelligence requires not only just neural networks and machine learning, but also logical rules and their execution. An effective solution is the hybrid technologies of neural networks and logical rules that will make a breakthrough in the future. To construct such logical rules, the semantic programming theory suits perfectly well.