Functional Variant of Polynomial Analogue of Gandy’s Fixed Point Theorem

Abstract

In this work, a functional variant of the polynomial analogue of Gandy’s fixed point theorem is obtained. Sufficient conditions have been found to ensure that the complexity of recursive functions does not exceed polynomial bounds. This opens up opportunities to enhance the expressivity of p-complete languages by incorporating recursively defined constructs. This approach is particularly relevant in the following areas: AI-driven digital twins of smart cities and complex systems, trustworthy AI, blockchains and smart contracts, transportation, logistics, and aerospace. In these domains, ensuring the reliability of inductively definable processes is crucial for maintaining human safety and well-being.

1. Introduction

The volume of program code generated by programmers continues to increase exponentially each year [1,2]. With large language models now capable of writing code and developing applications, this growth will accelerate even further and is likely to surpass hundreds of trillions of lines of code in the near future [3,4]. As these programs significantly influence our daily lives, there is a potential for them to cause harm if they become stuck in infinite loops [5,6] or operate exponentially in time [7,8] relative to the input data size. Consequently, polynomial computational complexity [9,10,11,12] becomes a crucial criterion for developing programs that can be reliably executed in critical areas such as trustworthy AI [13], blockchains and smart contracts [14], digital twins in smart cities [15], autonomous driving [16,17,18], robotics [19,20], and other advanced technologies. It is essential to carefully select p-complete subsets of Turing-complete languages [21,22,23,24] with maximum expressive capabilities to ensure the reliability and efficiency of these systems. To achieve this, it is necessary to define recursive functions [25,26,27,28,29,30,31] in such a way that their computational complexity remains polynomial.

In previous works, we established a polynomial analogue of Gandy’s fixed point theorem [9,10]. This discovery served as a crucial impetus for the development of p-complete programming languages, one of which was pioneered by us in [12]. A key achievement of this work was the solution of the problem $P=L$ [12]. Subsequently, our efforts have been focused on advancing the creation of a novel high-level programming language and exploring the concept of a comprehensive programming methodology [32]. However, one aspect of our research remains unaddressed: the characterization of classes of recursive functions with polynomial complexity. We found sufficient conditions for such functions in this work. In many ways, the main ideas of this result are similar to the ideas that we used in the proof of the polynomial analogue of Gandy’s fixed point theorem [9,10]. However, there are also striking differences. Functions, as such, differ quite strongly from predicates precisely in the multitude of their values. If a predicate is either true or false, then a function can generally take on a variety of values.

Therefore, the challenge for us over the recent three years has been to identify these constraints on recursive functions, which would be sufficiently soft for the class of functions to remain large, while simultaneously tough enough to prevent them from exceeding polynomial complexity. This task became necessary following the proof of a polynomial analogue of Gandy’s fixed point theorem in the context of predicates extensions. Now we will inductively expand the function itself, not the truth set of the predicate, which is what fundamentally distinguishes these two approaches.

2. Preliminaries

In this section, we will delve into the preliminary findings that pave the way for the proof of the FPAG-theorem. We will formulate the classical version of Gandy’s fixed point theorem [33,34], along with its polynomial analogue. The construction of the p-complete language L can be traced back to ref. [12], where L is defined as a collection of formulas and programs, which are constructed inductively through the use of novel term constructions such as conditional terms and p-iterative terms [12]. Therefore, the very concept of a formula changes.

2.1. Classical Gandy’s Fixed Point Theorem

Classical Gandy’s fixed point theorem [9,33,34] is one of the most important not only in mathematical logic but also in programming and operator theory. One of the variants of the classical Gandy’s fixed point theorem states that if we have a fixed model $\Omega =<\omega ,0,s,+,·,\le >$ of the signature ${\sigma }_0=<0,s^1,{+}^2,{·}^2,{\le }^2>$. Denote the extension of the signature ${\sigma }_0$ by ${\sigma }^{\ast }$, which is obtained by adding symbols for all $\mathsf{\Sigma }$-functions on $\Omega$ and constant symbols for all elements of $\omega$, and let ${\Omega }^{\ast }$ denote the corresponding enrichment of $\Omega$.

Define the operator ${\Gamma }_{\mathsf{\Phi }\left[\overline{x}\right]}^{{\Omega }^{\ast }}$ as follows:

$${\Gamma }_{\mathsf{\Phi }\left[\overline{x}\right]}^{{\Omega }^{\ast }}\left(Q\right)=\left\{(a_1,\dots ,a_{k-1})\right|<{\Omega }^{\ast },Q>\vDash \mathsf{\Phi }(a_0,\dots ,a_{k-1})\}$$

where $Q\subseteq {\omega }^k$.

We associate the following sequence of predicates

$${\Gamma }_0,{\Gamma }_1,\dots ,{\Gamma }_{\alpha }\mathrm{where}\alpha \mathrm{is}\mathrm{an}\mathrm{ordinal}$$

with the monotone operator ${\Gamma }_{\mathsf{\Phi }\left[\overline{x}\right]}^{{\Omega }^{\ast }}$ as follows:

$${\Gamma }_0=\varnothing ,{\Gamma }_{\alpha +1}={\Gamma }_{\mathsf{\Phi }\left[\overline{x}\right]}^{{\Omega }^{\ast }}\left({\Gamma }_{\alpha }\right)\mathrm{for}\mathrm{none}\mathrm{limit}\mathrm{ordinal},\dots ,{\Gamma }_{\alpha }={\cup }_{\beta <\alpha }{\Gamma }_{\beta }\mathrm{for}\mathrm{limit}\mathrm{ordinal}$$

Let $\alpha$ be the smallest ordinal such that ${\Gamma }_{\alpha +1}={\Gamma }_{\alpha }$; thus, ${\Gamma }^{\ast }={\Gamma }_{\alpha }$ is a smallest fixed point.

Theorem 1 

(Gandy’s fixed point theorem). Let $\mathsf{\Phi }\left(P^{+}\right)$ be a Σ-formula of the signature ${\sigma }^{\ast }\cup \left\{P^{\left(k\right)}\right\}$ in which the predicate symbol P enters positively and $x_0,\dots ,x_{k-1}$ be a list of the different free variables of the formula Φ. Thus, the smallest fixed point ${\Gamma }^{\ast }$ of the operator ${\Gamma }_{\mathsf{\Phi }\left[\overline{x}\right]}^{{\Omega }^{\ast }}$ is a Σ-predicate on ${\Omega }^{\ast }$.

The concept of a $\mathsf{\Sigma }$-predicate inherently implies a level of semi-decidability. Our goal was to achieve decidability and, ideally, to verify whether an element belongs to a smallest fixed point ${\Gamma }^{\ast }$ within polynomial time.

2.2. PAG-Theorem

Now let ${\mathsf{\Sigma }}_0$ be some finite alphabet, and $\mathsf{\Sigma }$ = ${\mathsf{\Sigma }}_0\cup \{<,>\}\cup \{,\}$ is a new alphabet obtained by adding new symbols (brackets and comma) to ${\mathsf{\Sigma }}_0$. Word splitting is the following partial function $R:{\mathsf{\Sigma }}^{\ast }\to {(\mathsf{\Sigma }\cup \{\#\})}^{\ast }$, such that

$$R\left(w\right)=\left\{\begin{array}{c}{w}_1\#...\#w_n,\mathrm{where}w=<w_1,...,w_n>\mathrm{and}\mathrm{every}{w}_i\in {\mathsf{\Sigma }}^{\ast }\mathrm{satisfies}1)\mathrm{or}2)\hfill \\ \uparrow ,\mathrm{otherwise}\hfill \end{array}\right.$$

(1)

$w_i\in {\mathsf{\Sigma }}_0^{\ast }$

(2)

$w_i$ starts with a left bracket and the number of left brackets in the word is equal to the number of right brackets, while for any initial subword ${\alpha }_i$ such that $w_i={\alpha }_i{\beta }_i$ is not implemented, where the word $w_i$ can be represented as some concatenation of the words ${\alpha }_i,{\beta }_i\in {\mathsf{\Sigma }}^{\ast }$ and $\left|{\alpha }_i\right|\ge 1$.

Inductively define the notion rank of element $r\left(w\right)$ for $w\in {\mathsf{\Sigma }}^{\ast }$:

$$r\left(w\right)=\left\{\begin{array}{c}sup\{r\left(w_1\right),...,r\left(w_k\right)\}+1,\mathrm{if}R\left(w\right)=w_1\#...\#w_k\hfill \\ 0,\mathrm{otherwise}.\hfill \end{array}\right.$$

The polynomial analogue of Gandy’s fixed point theorem (PAG-theorem) [9,10] is based on the classical Gandy’s fixed point theorem. The PAG-theorem demonstrates that the smallest fixed point of a special operator is already computable in polynomial time (p-computable).

To prove this, a p-computable hereditary-finite list superstructure $HW\left(\mathfrak{M}\right)$ of signature $\sigma$ was chosen as the basic model. The base set $HW\left(M\right)\subseteq {\mathsf{\Sigma }}^{\ast }$ contains hereditary-finite lists, which are inductively constructed from the basic elements of the base set $M\subseteq {\mathsf{\Sigma }}_0^{\ast }$ of the model $\mathfrak{M}$ of the signature ${\sigma }_0\subset \sigma$. The basic list operations for $HW\left(\mathfrak{M}\right)$ are

• $head\left(x\right)$—operation of taking the last element from a list x.
• $tail\left(x\right)$—operation of removing the last element from a list x.
• $cons(x,y)$—operation of adding to the end of a list x of a list y.
• $conc(x,y)$—concatenation operation of two lists x and y, respectively.

There is a constant $nil$ for the empty list and there are also the following relations:

• $x\in y$—“x is an element of y”.
• $x\subseteq y$—“x is an initial segment of y”.

Formulas of the first-order logic are considered only with the bounded quantifiers $\forall x\in t$, $\exists x\in t$, $\forall x\subseteq t$, $\exists x\subseteq t$, where t is a standard term (in addition to standard terms, the language L also has conditional terms and p-iteration terms [12]).

In order to apply the PAG-theorem generally, it is necessary to construct a p-computable GNF-system [10] based on the following components:

• A finite alphabet $\mathsf{\Sigma }$.
• An extended alphabet $\Omega$.
• A special logical language L where L-formulas and L-programs are defined [12,32].
• p-computable hereditary-finite list superstructure HW(M) of the signature $\sigma$.
• Finite sets of extendable predicates $P_1,\dots ,P_n$.
• Generative families of formulas $F_{P_1},\dots ,F_{P_n}$.
• p-computable functions ${\gamma }_1,\dots ,{\gamma }_n$ that, given an element of HW(M), construct suitable generative formulas or return false.

Theorem 2 

(Polynomial analogue of Gandy’s fixed point theorem). Let G be a p-computable GNF-system; then, the smallest fixed point ${\Gamma }^{\ast }$ of the operator ${\Gamma }_{F_{P_1},\dots ,F_{P_n}}^{<HW\left(\mathfrak{M}\right),\sigma >}$ is a p-computable.

The results obtained in the PAG-theorem allow us to inductively define sets of objects of varying complexity using generative families of L-formulas and at the same time guarantee their recognizability in polynomial time. Inductivity upwards essentially defines recursivity downwards, i.e., the algorithm that checks whether an object belongs to a class of objects, working with various list encoded objects, each time splits the list into elements and recursively checks each element for consistency with one of the families of generative formulas.

3. Functional Variant of the PAG-Theorem

3.1. p-Computable FGNF-Systems

Let <HW($\mathfrak{M}$), $\sigma$> [9,10] be a p-computable hereditary-finite list superstructure.

Let $f_1,\dots ,f_n$–p-computable functions and all $f_i$ in the signature $\sigma$. Then, we can define a new finite or countable generative families $T_{f_i}$ of standard terms of the signature $\sigma$ for each function $f_i$:

$$T_{f_i}=\left\{t_j(x_1,\dots ,x_{k_j})\right|j\in N\},i\in [1,\dots ,n]$$

by default, we assume that any $f_j$ can be included in any term $t_k$ of any family $T_{f_i}$.

Assume also that for each generative family of terms $T_{f_i}$, there exists a p-computable function ${\gamma }_i$:

$${\gamma }_i:HW\left(M\right)\to T_{f_i}\cup \left\{false\right\}$$

By default, we assume that the $false$ element belongs to M. In the future, if the function $f:HW\left(M\right)\cup M\to HW\left(M\right)\cup M$ has the value $false$ on some element $w\in HW\left(M\right)\cup M$, then we denote this as $f\left(w\right)\uparrow$, otherwise $f\left(w\right)\downarrow$. The domain $dom\left(f\right)$ of a function f will be considered as the set of all elements w on which $f\left(w\right)\downarrow$.

Define the extension $f_i^{(n+1)}:HW\left(M\right)\cup M\to HW\left(M\right)\cup M$ for each $f_i^{\left(n\right)}$ (where $f_i^{\left(0\right)}=f_i$) and

$$f_i^{(n+1)}{|}_{dom\left(f_i^{\left(n\right)}\right)}=f_i^{\left(n\right)}$$

using a p-computable function ${\gamma }_i:HW\left(M\right)\to T_{f_i}\cup \left\{false\right\}$ such that on (n + 1)-iteration we have

$$f_i^{(n+1)}\left(w\right)=\left\{\begin{array}{c}{f}_i^{\left(n\right)}\left(w\right),\mathrm{if}{f}_i^{\left(n\right)}\left(w\right)\downarrow ,\mathrm{else}\hfill \\ {\gamma }_i{\left(w\right)}_{\overline{w}}^{\overline{x}},\mathrm{if}{\gamma }_i\left(w\right)\downarrow \mathrm{and}{\gamma }_i{\left(w\right)}_{\overline{w}}^{\overline{x}}\mathrm{is}\mathrm{defined},\mathrm{else}\hfill \\ false,\mathrm{otherwise}\hfill \end{array}\right.$$

(1)

Using generative families of the terms $T_{f_i}$, p-computable functions ${\gamma }_i$ and Equation (1), we can define the operator, as follows:

$${\Gamma }_{f_1,\dots ,f_n}^{<HW\left(\mathfrak{M}\right),\sigma >}:{\left\{g\right|g:HW\left(M\right)\to HW\left(M\right)\}}^n\to {\left\{g\right|g:HW\left(M\right)\to HW\left(M\right)\}}^n$$

satisfying the following rules:

$${\Gamma }_{f_1,\dots ,f_n}^{<HW\left(\mathfrak{M}\right),\sigma >}(g_1^{\left(k\right)},\dots ,g_n^{\left(k\right)})=(g_1^{(k+1)},\dots ,g_n^{(k+1)})$$

where $g_i^{\left(k\right)}\subseteq g_i^{(k+1)}$.

Let us define a partial order:

$$(f_1,\dots ,f_n)\subseteq (g_1,\dots ,g_n)\iff dom\left(f_i\right)\subseteq dom\left(g_i\right)\mathrm{and}{f}_i=g_i{|}_{dom\left(f_i\right)}$$

The operator ${\Gamma }_{f_1,\dots ,f_n}^{<HW\left(\mathfrak{M}\right),\sigma >}$ is monotonic [33] by the partial-order ⊆ and has the property of a fixed point $(g_1^{\ast },\dots ,g_n^{\ast })$; moreover, the fixed point is reached in $\omega$ steps [9]:

$${\Gamma }_{f_1,\dots ,f_n}^{<HW\left(\mathfrak{M}\right),\sigma >}(g_1^{\ast },\dots ,g_n^{\ast })=(g_1^{\ast },\dots ,g_n^{\ast })$$

where $g_i^{\ast }=g_i^{\left(\omega \right)}$, $i\in [1,\dots ,n]$

Define a set of free variables for terms and formulas as $V\left(t\left(\overline{x}\right)\right)$ and $V\left(\phi \left(\overline{x}\right)\right)$, respectively, where $\overline{x}=(x_1,\dots ,x_n)$ for some $n\in N$. Denote $t^{\overline{y}}(\overline{x},\overline{y})$ as a term where all occurrences $f_j\left(x_i\right)$ have been replaced on $y_i$ in the term $t(\overline{x},\overline{y})$. Denote $V_{\overline{x}}\left(t(\overline{x},\overline{y})\right)$ and $V_{\overline{y}}\left(t(\overline{x},\overline{y})\right)$ as the set of free variables $x_i$ from $\overline{x}$ and the set of free variables $y_i$ from $\overline{y}$, respectively.

We define the concept of the FGNF-system as a tuple, similarly to the way in which we defined this in the case of the polynomial analogue of Gandy’s fixed point theorem [10]:

$$FGNF=(\mathsf{\Sigma },\sigma ,\Omega ,L,HW(M),F,T,G)$$

We will say that a FGNF-system is p-computable if the model $HW\left(\mathfrak{M}\right)$ of the signature $\sigma$ is p-computable, and all ${\gamma }_i\in G$ are p-computable functions and if the following conditions are met:

• If $f_j$ is included in some $t_k$, then $f_j$ appears in the term $t_k$ as $f_j\left(x_i\right)$ for some particular variable $x_i$.
• $f_j\left(x_i\right)$ and $f_k\left(x_i\right)$ do not belong to any term simultaneously for any $x_i$ where $j\ne k$.
• It is not true that there is i such that $x_i\in V_{\overline{x}}\left(t_j^{\overline{y}}(\overline{x},\overline{y})\right)$ and $y_i\in V_{\overline{y}}\left(t_j^{\overline{y}}(\overline{x},\overline{y})\right)$ for some $t_j\left(\overline{x}\right)$
• For any $T_{f_k}$, there exist C and p such that for any $t_j\in T_{f_k}$ and for any evaluations $\overline{w},\overline{l}$:

  $$t\left(t_j^{\overline{y}}(\overline{w},\overline{l})\right)\le C·{\left(\right|conc(list\left(\overline{w}\right),list\left(\overline{l}\right))\left|\right)}^p,\mathrm{if}{t}_j^{\overline{y}}(\overline{w},\overline{l}))\downarrow$$

  (2)

  where $t\left(t_j^{\overline{y}}(\overline{w},\overline{l})\right)$ is a computational complexity of $t_j^{\overline{y}}(\overline{w},\overline{l}))$, and $list\left(\overline{w}\right)$ is a conversion function that converts a tuple into a list.
• If $V_{\overline{y}}\left(t_j^{\overline{y}}(\overline{x},\overline{y})\right)\ne ⌀$, then

  $$\left|t_j^{\overline{y}}(\overline{w},\overline{l})\right|{\le C·\left|list\right(\overline{w}\left)\right|}^p+\left|list\right(\overline{l}\left)\right|,\mathrm{if}{t}_j^{\overline{y}}(\overline{w},\overline{l}))\downarrow$$

  (3)

  for any $t_j\in T_{f_k}$, and for any evaluations $\overline{w},\overline{l}$ of the tuples $\overline{x}$ and $\overline{y}$, respectively.
• For any $T_{f_k}$, and for any $\overline{w_1},\overline{w_2}\in HW{\left(M\right)}^n$, there are no two terms $t_i$ and $t_j$ from $T_{f_k}$ where $t_i,t_j\in T_{f_k}$ such that $t_i^y(\overline{w_1},\overline{w_2})\downarrow$ and $t_j^y(\overline{w_1},\overline{w_2})\downarrow$.

3.2. Functional Variant of Polynomial Analogue of Gandy’s Fixed Point Theorem (FPAG-Theorem)

Theorem 3 

(FPAG-theorem). Let the p-computable FGNF-system with initial p-computable functions $f_1,\dots ,f_n$ be given. Thus, the smallest fixed point ${\Gamma }^{\ast }=(f_1^{\ast },\dots ,f_n^{\ast })$ of the operator ${\Gamma }_{f_1,\dots ,f_n}^{<HW\left(\mathfrak{M}\right),\sigma >}$ is p-computable.

Proof. 

By induction on the rank $r\left(w\right)$ of the list element w, we prove two statements simultaneously for some fixed constants C and p. First,

$$\forall i\forall w\in HW\left(M\right)\left|f_i\left(w\right)\right|\le C·{\left|w\right|}^p$$

and, second, we obtain that for any i, the computational complexity of the algorithm does not exceed the following:

$$\forall i\forall wt\left(f_i\left(w\right)\right)\le 36·C^{p+1}·(r\left(w\right)+1)·{\left|w\right|}^{2p^2+1}$$

Base of induction: $n=0$. Then, for any $a\in M$, we have $|f_i{\left(a\right)|\le C·|a|}^p$ and $t\left(f_i\left(a\right)\right)\le C·{\left|a\right|}^p$ because the initial function $f_i$ is a polynomial computable.

Step of induction: Let the statement be true for every $k<n$; then, show that for $k=n$, we have the following:

If the initial polynomial function is $f_i\left(w\right)\downarrow$, then the answer is obvious.

Else if $\gamma \left(w\right)=false$, then $f_i\left(w\right)\uparrow$.

Else if $\gamma \left(w\right)=t_j\left(\overline{x}\right)$, we have two cases for $I=\left\{i\right|y_i\in V\left(t_j^{\overline{y}}(\overline{x},\overline{y})\right)\}$:

(1) If $I=⌀$, then by conditions for p-computable FGNF-system,

$$|f_i^{\ast }\left(w\right)|\le |\left[\gamma \left(w\right)\right]\left(\overline{w}\right)|=|t_j(w_1,\dots ,w_n)|{\le C·\left|w\right|}^p$$

and it is true by definition of p-computable FGNF-system.

The complexity (see work [9]) is estimated as follows:

$$\begin{gathered} t\left(f_i^{\ast }\left(w\right)\right)\le t\left(f_i\left(w\right)\right)+t\left({\gamma }_i\left(w\right)\right)+t\left({\left[{\gamma }_i\left(w\right)\right]}_{\overline{w}}^{\overline{x}}\right)+t\left(\left[{\gamma }_i\left(w\right)\right]\left(\overline{w}\right)\right)\le \\ \le C·{\left|w\right|}^p+C·{\left|w\right|}^p+12·C·{\left|w\right|}^{p+1}+C·{\left|w\right|}^p\le \\ \le 36·C^{p+1}·(r\left(w\right)+1)·{\left|w\right|}^{2p^2+1} \end{gathered}$$

where $t\left({\left[{\gamma }_i\left(w\right)\right]}_{\overline{w}}^{\overline{x}}\right)$ is the complexity of replacing variables $x_i$ on values $w_i$.

(2) If $I\ne ⌀$, then

$$\left|f_i^{\ast }\left(w\right)\right|=\left|\left[{\gamma }_i\left(w\right)\right]\left(\overline{w}\right)\right|=\left|{\left[{\gamma }_i\left(w\right)\right]}^{\overline{y}}({\overline{w}}_x,{\overline{v}}_y)\right|\le C·|list\left(\overline{w_x}\right){|}^p+|list\left({\overline{v}}_y\right)|\le C·|\overline{w}{|}^p$$

where $v_i=f_{j_i}\left(w_i\right)$ for $v_i\in {\overline{v}}_y$ and $|v_i|=|f_{j_i}\left(w_i\right)|\le C·|w_i{|}^p$ by induction.

For complexity, we have the following:

$$\begin{gathered} t\left(f_i^{\ast }\left(w\right)\right)\le t\left(f_i\left(w\right)\right)+t\left({\gamma }_i\left(w\right)\right)+t\left({\left[{\gamma }_i\left(w\right)\right]}_{\overline{w}}^{\overline{x}}\right)+ \\ +\sum _{i\in I}t\left(f_j^{\ast }\left(w_i\right)\right)+t\left({\left({\left[{\gamma }_i\left(w\right)\right]}_{\overline{w}}^{\overline{x}}\right)}_{\left\{v_i\right|i\in I\}}^{\left\{f_{j_i}\left(w_i\right)\right|i\in I\}}\right)+t\left(\left[{\gamma }_i{\left(w\right)}^{\overline{y}}\right](\overline{w_x},\overline{v_y})\right)\le \\ \le C·{\left|w\right|}^p+C·{\left|w\right|}^p+12·C·{\left|w\right|}^p \\ +\sum _{i\in I}36·C^{p+1}·((r\left(w\right)-1)+1)·{\left|w\right|}^{2p^2+1}+12·C^2·{\left|w\right|}^{2p+1}{+C·(C·|w|}^p{)}^p\le \\ \le 36·C^{p+1}·(r\left(w\right)+1)·{\left|w\right|}^{2p^2+1} \end{gathered}$$

where $t\left({\left({\left[{\gamma }_i\left(w\right)\right]}_{\overline{w}}^{\overline{x}}\right)}_{\left\{v_i\right|i\in I\}}^{\left\{f_{j_i}\left(w_i\right)\right|i\in I\}}\right)$ is the complexity of replacing $f_{j_i}\left(w_i\right)$ on $v_i$ in ${\left[{\gamma }_i\left(w\right)\right]}_{\overline{w}}^{\overline{x}}$.

Since the rank $r\left(w\right)$ is less than the length of the list $\left|w\right|$, our theorem is proven. □

4. Applications

This section will delve into the main areas in which the FPAG-theorem may be employed, ensuring the preservation of polynomial computational complexity. The fundamental basis of our reality is a complex interaction of inductively defined concepts and recursively defined processes. Consequently, it becomes imperative to master the art of expressing these processes and concepts through mathematical frameworks and methodologies.

4.1. Recursion in p-Complete Languages

One of the principal domains of application for the FPAG-theorem can be identified as p-complete programming languages [12,32]. Previously, we were unable to employ full-fledged recursive calls, as recursion in the general case led us beyond the bounds of polynomiality. Yes, a polynomial analogue of Gandy’s fixed point theorem has been proven [9], but this theorem applies only to predicates where the truth value can be either true or false. In the case of the FPAG-theorem, the value of a function can be arbitrarily large, allowing us to extend our proposed p-complete languages L [12] and L* [32]. These extensions will be conservative. We can also consider the problem of impoverishing Turing-complete languages where the computational complexity of programs will be polynomial. To do this, we must limit ourselves to the simplest constructions emulating the work of the p-iterative terms and conditional terms proposed by us. In addition, we permit the definition of recursive functions, but only under the same conditions imposed on them for a p-computable FGNF-system. In order to develop programs of polynomial complexity, we must restrict ourselves of the following syntactical constructs:

• The conditional operator IF THEN ELSE (an analogue of the conditional term).
• The loop operator FOR where the output values of the variables changed in the loop body are limited by some polynomial.
• The loop operator FOR on lists [35].
• Recursive functions that must satisfy the conditions for a p-computable FGNF-system.

To illustrate, let us examine the process of implementing a factorial in Turing-complete languages through our methodology. Firstly, we shall provide a conventional definition of the factorial:

function Factorial(n) {
    if (n < 2) then return 1;
    return n*Factorial(n−1);
}

The function $Factorial$ defined above has exponential computational complexity. This leads to the program running in exponential time. We would like to limit ourselves to polynomial computational complexity. For this purpose, consider the following function $listMul$:

          function listMul(w) {
    if !list(w) then return w;
    s:= 1;
    for x in w {
    s := s * listMul(x)
    }
    return s;
} 

where the notation for x in w is a loop FOR on the list w.

It is worth noting that the $listMul$ function can also be employed to determine the factorial of an integer n. To accomplish this task, it suffices to enumerate all integers from 1 to n in a list w in any order. For instance, the enumeration may be as follows:

• $w_1\left(n\right)=<n,<n-1,<\dots <1,<2>>\dots >>>$
• ...
• $w_k\left(n\right)=<<1,n>,\dots ,<n-1>,2>$

Taking into account the implementation, the value of the function $Factorial\left(n\right)$ coincides with the value of the function $listMul\left(w_j\left(n\right)\right)$, where $j\in [1,\dots ,k]$.

Lemma 1. 

The computational complexity of the function $listMul\left(x\right)$ is polynomial.

Proof. 

The proof follows immediately from the FPAG-theorem where the initial p-computable function $listMul\left(x\right)$ is defined on natural numbers:

$$listMul\left(n\right)=n;$$

and where the generative family $T_{listMul}$ consists of a countable number of terms:

$$\{listMul\left(x_1\right)·\dots ·listMul\left(x_n\right)|n\in N\}$$

The p-computable function $\gamma$ has the following form:

$$\gamma (<w_1,\dots ,w_k>)=listMul\left(x_1\right)·\dots ·listMul\left(x_k\right)$$

It is necessary to check conditions (2) and (3) for generative families $T_{listMul}$.

There exist constants C and p for condition (2) such that

$$t\left(t_j^{\overline{y}}(l_1,\dots ,l_k)\right)=t(l_1·\dots ·l_k)\le C·{|<l_1,\dots ,l_k>|}^p$$

where $l_1,\dots ,l_k\in N$.

Condition (3) is also true:

$$\left|t_j^{\overline{y}}\right(l_1,\dots ,l_k\left)\right|=|l_1·\dots ·l_k|\le |<l_1,\dots ,l_k>|$$

where $l_1,\dots ,l_k\in N$.

Thus, we can construct the p-computable FGNF-system, and the FPAG-theorem can be applied. □

4.2. Blockchains and Smart Contracts

Blockchains and smart contracts represent significant areas of software development. For example, when we examine the smart contracts on the Ethereum blockchain [36], we find that the process of executing of a smart contract entails the necessity of assigning a specific gas value for its execution. If there is not enough gas, then the execution of the smart contract is interrupted. This can be critical for both developers and users themselves. This is because smart contracts are essentially programs written in a Turing-complete language, which presents a halting problem that cannot be circumvented. In this context, we envision further progress through the active design of programs with polynomial computational complexity that consistently terminate, and for which the required computing resources can be predetermined. This is accomplished using the methods outlined in the preceding section. However, it is worth noting that the complexity estimates themselves remain polynomial, although there are specific features of the execution of smart contracts on the blockchain.

It is worth noting the phenomenon of mutual recursion in the context of smart contracts, which is of particular interest. Such recursive processes are often challenging to analyze, and it is difficult to forecast their termination. By employing recursion on lists and exercising control over the values of functions, we ensure their eventual termination.

          function f(w) {
    if !list(w) return 1;
    s:= 1;
    for x in w {
     s:= s * g(x);
    }
    return s;
}

          function g(w){
    if !list(w) return len(w)^2;
    s:= g(first(w));
    for x in w[1:] {
     s:= s + [f(x)/2];
    }
    return s;
}

where $first\left(w\right)$ is a first element in the list w, and $len\left(x\right)$ denotes the length of the string x.

Lemma 2. 

Mutually recursive functions f and g defined above are p-computable.

Proof. 

The value of the initial function f defined on non-list elements is equal to 1. The value of the initial function g defined on non-list elements w is equal to ${\left|w\right|}^2$. It follows that the initial functions f and g are p-computable.

The generative term family $T_f$ for the function f has the following form:

$$\{g\left(x_1\right)·\dots ·g\left(x_n\right)|n\in N\}$$

The p-computable function ${\gamma }_f$ has the following form:

$${\gamma }_f(<w_1,\dots ,w_k>)=g\left(x_1\right)·\dots ·g\left(x_k\right)$$

The generative term family $T_g$ for the function g has the following form:

$$\{g\left(x_1\right)+[f\left(x_2\right)/2]\dots +[f\left(x_n\right)/2]|n\in N\}$$

The p-computable function ${\gamma }_g$ has the following form:

$${\gamma }_g(<w_1,\dots ,w_k>)=g\left(x_1\right)+[f\left(x_2\right)/2]\dots +[f\left(x_k\right)/2]$$

It is necessary to check conditions (2) and (3) for generative families $T_f$ and $T_g$, respectively.

There exist constants C and p for condition (2) such that

$$t\left(t_j^{\overline{y}}(l_1,\dots ,l_k)\right)=t(l_1·\dots ·l_k)\le C·{|<l_1,\dots ,l_k>|}^p$$

where $t_j\left(\overline{x}\right)\in T_f$ and $l_1,\dots ,l_k\in N$.

$$t\left(t_m^{\overline{y}}(l_1,\dots ,l_h)\right)=t(l_1+[l_2/2]\dots +[l_h/2])\le C·{|<l_1,\dots ,l_h>|}^p$$

where $t_m\left(\overline{x}\right)\in T_g$ and $l_1,\dots ,l_k\in N$.

Condition (3) is also true:

$$\left|t_j^{\overline{y}}(l_1,\dots ,l_k)\right|=|l_1·\dots ·l_k|\le |<l_1,\dots ,l_k>|$$

where $t_j\left(\overline{x}\right)\in T_f$ and $l_1,\dots ,l_k\in N$.

$$\left|t_m^{\overline{y}}\right(l_1,\dots ,l_h\left)\right|=t(l_1+[l_2/2]\dots +[l_h/2\left]\right)\le |<l_1,\dots ,l_h>|$$

where $t_m\left(\overline{x}\right)\in T_g$ and $l_1,\dots ,l_k\in N$.

Thus, we can construct a p-computable FGNF-system, and the FPAG-theorem can be applied. It follows that the functions f and g are p-computable. □

4.3. Large Language Models

In the recent three years, neural networks [37,38], large language models and generative models [39,40,41] have elevated the standard of AI solutions to previously unimaginable heights. They have the capability to compose texts, translate languages, create artwork and music, as well as mimic human voice and behavior, which undoubtedly fascinates us as humans. Many claim that ChatGPT [39,42] has already passed the Turing test. However, seemingly simple questions like “How many sisters does Alice’s brother have?” [43] shatter this illusion, revealing a range of underlying issues that are not immediately apparent. Numerous experiments have shown that these systems struggle with mathematical problem solving and the explainability of their outputs. One significant challenge lies in the inductively specified properties and objects that are input to these models. Furthermore, the structure of neural networks and transformer models remains poorly understood concerning explainability and logical reasoning. To date, no major mathematical theorems have emerged that clarify logical inference and the formalization of algorithmic processes in this context. Therefore, to address a broad class of problems involving inductive descriptions, we propose a combined approach where a large language model transforms the inductive descriptions of a class of objects or functions into a mathematical formulation. Subsequently, a program is executed that implements the recursive algorithm derived from the FPAG-theorem. Essentially, this creates hybrid artificial intelligence, where large language models and their derivatives serve as intermediaries between natural and mathematical languages, while the algorithms themselves being executed through dedicated programs. The FPAG-theorem can serve as an effective benchmark for evaluating the quality of outputs generated by large language models.

To illustrate, one can provide ChatGPT with a set of initial polynomial functions, denoted as $f_1,\dots ,f_n$, along with their corresponding generative term families, $T_{f_1},\dots ,T_{f_n}$. Then, one can pose the following question to the model: what is the value of the function at a given element w? It is worth noting that even in relatively simple scenarios, large language models have been known to produce erroneous results.

4.4. Trustworthy Artificial Intelligence

Trustworthy artificial intelligence [13,44,45] stands out as one of the most pertinent areas within digital technologies today. First of all, programs in trusted artificial intelligence systems should always stop and have polynomial computational complexity. We close this question by constructing p-complete languages with recursive constructions based on the FPAG-theorem. There are still many other open questions, including questions about logical inferences and explanations, but these questions can be considered partially closed since we have developed a theory of learning for intelligent systems based on logical-probabilistic methods of obtaining and generating knowledge. This learning theory is based on the task approach [13], where a task is defined only when there is a criterion for its solution. The correct formalization of tasks using logical formulas and finding solutions using recursive functions that satisfy the conditions of a p-computable FGNF-system gives a powerful incentive in the direction of explainable AI.

4.5. Smart Cities and Intelligent Digital Twins

We want to consider the processes occurring in a smart city [15,46] through the prism of inductively determined constructs. For example, the number of residents in a city is defined as the sum of the number of residents in each of the city’s districts. The number of residents in a district is the sum of the number of residents in each of its quarters and so on, being reduced to houses and then apartments. This process can be described recursively. Therefore, the FPAG-theorem can be applied to count the number of residents in a city, state, country, world.

Let us inductively codify and define the following notions: resident, house, quarter, district, and city:

$$\underline{resident}:resident\_info$$

where $resident\_info$ is a JSON file with information about the resident.

$$\begin{gathered} \underline{house}:<house,house\_info,\underline{residen{t}_1},\dots ,\underline{residen{t}_n}> \\ \underline{quarter}:<quarter,quarter\_info,\underline{hous{e}_1},\dots ,\underline{hous{e}_k}> \\ \underline{district}:<district,district\_info,\underline{quarte{r}_1},\dots ,\underline{quarte{r}_m}> \\ \underline{city}:<city,city\_info,\underline{distric{t}_1},\dots ,\underline{distic{t}_p}> \end{gathered}$$

Then, the following recursive function $numResidents$ will count the number of residents in a house, block, district, and city, respectively:

         function numResidents(w) {
    if !list(w) then return 1;
    s:= 0;
    for x in (w[2:]) {
    s := s + numResidents(x)
    }
    return s;
}

where $w[2:]$ is a list that is obtained from a list w by removing the first two elements.

Lemma 3. 

The computational complexity of the function $numResidents\left(x\right)$ is polynomial.

Proof. 

The proof follows immediately from the FPAG-theorem where the initial p-computable function $numResidents$ is defined on non-list elements:

$$numResidents\left(\underline{residen{t}_i}\right)=1,$$

and where the generative family $T_{numResidents}$ consists of a countable number of terms:

$$\{numResidents\left(x_3\right)+\dots +numResidents\left(x_n\right)|n\in N\}$$

The p-computable function $\gamma$ has the following form:

$$\gamma (<w_1,\dots ,w_k>)=numResidents\left(x_3\right)+\dots +numResidents\left(x_k\right)$$

It is necessary to check conditions (2) and (3) for generative families $T_{numResidents}$.

There exist constants C and p for condition (2) such that

$$t\left(t_j^{\overline{y}}(l_3,\dots ,l_k)\right)=t(l_3+\dots +l_k)\le C·{|<l_3,\dots ,l_k>|}^p$$

where $l_3,\dots ,l_k\in N$.

Condition (3) is also true:

$$\left|t_j^{\overline{y}}\right(l_3,\dots ,l_k\left)\right|=|l_3+\dots ·l_k|\le |<l_3,\dots ,l_k>|$$

where $l_3,\dots ,l_k\in N$.

Thus, we can construct the p-computable FGNF-system, and the FPAG-theorem can be applied. □

The method can also be used to calculate people’s well-being, passenger flows, road congestion; count daily contacts of one person with others; and assess the spread of various diseases such as COVID-19 [47]. It can be used to build various indices [48]: the index of the quality of education, the index of the quality of medicine, and the index of the quality of life. Moreover, it can be utilized for constructing the level of wealth distribution among different segments of the population and for building a digital model of a city and analyzing it to determine the satisfaction of various criteria put forward by society for smart cities, including using urban templates.

As for intelligent digital twins, it is also very important to use inductive concepts and recursive functions. It is necessary to obtain new knowledge based on a set of facts and precedents, which most often generalizes previous experience. The facts and processes themselves can fall under the inductive description, which allows using the PAG-theorem and FPAG-theorem. It is noteworthy to emphasize the rapid evolution of virtual cities, in which digital twins of administrative entities engage in interactions with the digital twins of physical objects. As has been previously demonstrated, it is not feasible to rely solely on language models in this context. In order to tackle logical and recursive problems, it is imperative to integrate logical-probabilistic approaches and develop algorithms based on the FPAG-theorem.

As for p-complete programming languages, we conclude this series of papers with the FPAG-theorem and the construction of a programming methodology in Turing-complete languages.

5. Discussion

This paper left some questions unanswered regarding the reduction in constraints under certain conditions on the p-compatibility of the FGNF-system. Specifically, this concerns the requirements for the complexity $t\left(t_j^{\overline{y}}(\overline{w},\overline{l})\right)$ (2) and the length $|t_j^{\overline{y}}(\overline{w},\overline{l})|$ (3) of terms in generative families. Is it possible to relax these conditions and still maintain polynomial complexity for fixed point functions?

6. Conclusions

Recursion is one of the most powerful and expressive concepts in the realm of human thought. Through recursion, we can express a wide range of inductively generated entities and ideas. However, recursion is very dangerous in terms of computational complexity. To mitigate this issue, it becomes imperative to devise strategies that effectively curtail the exponential growth in complexity that is inherent in recursively constructed structures. In this work, we have identified such constraints. Through the use of the FPAG-theorem, we have provided precise conditions for defining recursive functions in such a way that they remain within the bounds of polynomial computational complexity, thereby ensuring the feasibility of their implementation.

The application of the FPAG-theorem is a topic that can gain significant attention in various fields, including trustworthy AI, digital twin technology, smart city development, blockchain systems, and smart contract implementation. Several lemmas were presented in this paper to illustrate the possible applications of the FPAG-theorem. However, there are still numerous areas where the full potential of this theorem remains largely untapped. What are fractal systems worth? Which systems have not yet been studied and which can also be analyzed using the FPAG-theorem?

As for p-complete programming languages, we conclude this series of papers with the FPAG-theorem and the construction of a programming methodology in Turing-complete languages. The FPAG-theorem provides a powerful expressive toolkit while maintaining polynomial computational complexity. Thus, it eliminates the halting problem that arises in Turing-complete languages and allows one to build reliable and trusted solutions. The Applications section contains a series of lemmas that demonstrate methods for implementing the FPAG-theorem in domains such as smart cities, Turing-complete programming languages, and smart contracts.