On Signifiable Computability: Part II: An Axiomatization of Signifiable Computation and Debugger Theorems

Abstract

Signifiable computability aims to separate what is theoretically computable from what is computable through performable processes on computers with finite amounts of memory. Mathematical objects are signifiable in a formalism $\mathcal{L}$ on an alphabet $\mathcal{A}$ if they can be written as spatiotemporally finite texts in $\mathcal{L}$ on $\mathcal{A}$. In a previous article, we formalized the signification and reference of real numbers and showed that data structures representable as multidimensional matrices of discretely finite real numbers are signifiable. In this investigation, we continue to formulate our theory of signifiable computability by offering an axiomatization of signifiable computation on discretely finite real numbers. The axiomatization implies an ontology of functions on discretely finite real numbers that classifies them as signifiable, signifiably computable, and signifiably partially computable. Relative to $\mathcal{L}$ and $\mathcal{A}$, signification is performed with two formal systems: the Former ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ that forms texts in $\mathcal{L}$ on $\mathcal{A}$ and the Transformer ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ that transforms texts formed by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ into other texts in $\mathcal{L}$ on $\mathcal{A}$. Singifiable computation is defined relative to $\mathcal{L}$ on $\mathcal{A}$ as a finite sequence of signifiable program states, the first of which is generated by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ and each subsequent state is deterministically obtained from the previous one by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$. We define a debugger function to investigate signifiable computation on finite-memory devices and to prove two theorems, which we call the Debugger Theorems. The first theorem shows that, for a singifiably partially computable function signified by a program on a finite-memory device $\mathcal{D}$, the memory capacity of $\mathcal{D}$ is exceeded when running the program on signifiable discretely finite real numbers outside of the function’s domain. The second theorem shows that there are functions signifiably computable in general that become partially signifiably computable when signified by programs on $\mathcal{D}$ insomuch as the memory capacity of $\mathcal{D}$ can be exceeded even when the programs are executed on some signifiable discretely finite real numbers in the domains of these functions.

1. Introduction

While general computability describes functions computable on devices without any memory limitations [1], or, equivalently, computable in principle [2], actual computability aims to characterize functions computable on devices with finite amounts of memory available for computation. We call such devices finite-memory devices (FMD) [3]. In a previous article [4], we began to formulate a theory of signifiable computability (or, equivalently, a signifiable computability theory (SCT)). The SCT separates general computability investigated in the classical computability theory (CCT) from actual computability when computation occurs within a finite amount of memory, as is the the case in many areas of applied computer science. In signifiable computability, names of intuitive objects, such as numbers, functions, data types and structures (i.e., instances of data types), programs, and program states are treated as spatiotemporally finite texts constructed with formal languages (or, equivalently, formalisms) on specific alphabets. Thus, these texts signify (or, equivalently, designate or name) intuitive objects, such as numbers, functions, data types and structures, programs, and program states in a given universe of discourse described by a formalism $\mathcal{L}$ on an alphabet $\mathcal{A}$ (e.g., Lisp on Unicode). When the texts are stored within the available memory units on an FMD $\mathcal{D}$, they signify the corresponding objects in the finite memory of $\mathcal{D}$, thereby making the universe of discourse conditional not only on $\mathcal{L}$ and $\mathcal{A}$, but also on $\mathcal{D}$. E.g., a human programmer using Lisp on Unicode on a computer with 5 terabytes (TB) of combined RAM and hard disk space cannot signify an intuitive object on this FMD if the storage size of the signifying text (i.e., the name of the object in Lisp on Unicode) exceeds 5 TB.

In a previous investigation [4], we defined the concepts of signification and reference of real numbers and extended signification to number tuples and data types and structures. We showed that data structures representable as tuples of discretely finite real numbers are signifiable. The signification of multidimensional matrices was introduced to show that data structures representable as multidimensional matrices of discretely finite real numbers are also signifiable. We argued that, in order to be sufficiently expressive, $\mathcal{L}$ on $\mathcal{A}$ must be not only decimal-sufficient (i.e., should contain finitely many rules to signify discretely finite real numbers in the standard decimal notation or an equivalent thereof) but also tuple-sufficient (i.e., should have finitely many rules to signify sequences of such numbers).

In this investigation, we continue to formulate the SCT by offering an axiomatization of signifiable computation on discretely finite real numbers. We show how a sufficiently expressive $\mathcal{L}$ on $\mathcal{A}$ can be extended with instruction types and how these types can be signified with texts and arranged into sequences. Signified instructions in a text sequence can be executed (or, equivalently, performed) one-by-one in order to carry out the prescribed numerical computation. If the computation exists (i.e., the execution finishes), its result (or, equivalently, output) is signified with a text in $\mathcal{L}$ on $\mathcal{A}$. An independent party can verify the computation from (1) the input text; (2) the text of the instruction sequence; and (3) the text with the sequences of the numerals of the individual instructions used in the computation.

This investigation is motivated by the following limitations of the CCT reflected in its axioms: (1) what is computable in principle (general computability) is indistinguishable from what is actually computable on computers with finite amounts of memory (actual computability); (2) the investigation of computability properties is confined to functions on natural numbers; (3) the formation of programs is insufficiently axiomatized insomuch as it is unclear how programs are formed (or, equivalently, generated or produced); (4) the transformation of programs to obtain a computation in the form of a finite sequence of program states is insufficiently axiomatized in that there is no concept of error or cost; (5) interpretation of input and output texts is unresolved to the extent that no position is taken on whether interpretation (e.g., a denotational or operational semantics) is part of computation or not. While the SCT is grounded in the CCT, it extends the CCT, because it (1) separates general computability from actual; (2) extends the investigation of computability properties to functions on discretely finite real numbers; (3) makes actual computability properties of functions explicitly dependent on formalisms, alphabets, and FMDs on which those functions are signified and computed; (4) introduces error and cost into computation; (5) takes a position that interpretation is not part of computation and as such belongs to metacomputability. As we formulate the SCT in this article, we reference, when appropriate, the CCT axioms summarized for the reader’s convenience in the Appendix A.

The remainder of this article is organized as follows. In Section 2, we review the basic ontology of the CCT presented in [1,2] and the formalism in [4] that we continue to use in this article. In Section 3, we axiomatize the formation and transformation of texts. Signification is actualized with two formal systems: the Former ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ that generates texts in $\mathcal{L}$ on $\mathcal{A}$, and the Transformer ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ that transforms texts formed by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ into other texts in $\mathcal{L}$ on $\mathcal{A}$. In Section 4, we define formable and transformable instructions and axiomatize the formation and transformation of program instructions and formation of programs. In Section 5, we axiomatize program states and computations. Computation is defined relative to $\mathcal{L}$ on $\mathcal{A}$ as a finite sequence of signifiable program states, the first of which is generated by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ and each subsequent state is deterministically obtained from the previous one by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$. In Section 6, we axiomatize the transformation of programs and discuss whether it is possible for ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ to transform program states that are not generated by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$. In Section 7, we offer an ontology of functions on discretely finite real numbers that classifies functions as signifiable, signifiably computable, and signifiably partially computable. In Section 8, we introduce memory limitations on signifiable computation to characterize functions as signifiably computable and partially computable on FMDs. Section 2, Section 3, Section 4, Section 5, Section 6, Section 7 and Section 8 can be viewed as the preliminary, auxiliary steps to Section 9, where we present our main results. In particular, we define a debugger function to actualize signifiable computation on FMDs and use it to prove two theorems, which we call the Debugger Theorems, to investigate some of the effects of finite memory on signifiable computation. In Section 10, we discuss our results. In Section 11, we summarize our findings and outline the scope of the next part of our investigation of signifiable computability.

2. Prolegomena

The reader may skip this section on first reading and return to it as necessary. Here, we review the basic concepts of the CCT and the basic formal apparatus in [4] that we continue to use in this article.

The CCT ontology used in this article is based on [1,2] and includes the following concepts:

• function—a mathematical object, i.e., a mapping from a given domain to a given range;
• alphabet—a finite set of symbols (or, equivalently, signs) (e.g., $\mathcal{A}=\{"\mathtt{0}","\mathtt{1}"\}$);
• formalism—a formal language $\mathcal{L}$ on a specific alphabet $\mathcal{A}$ defined with a finite set of syntactic rules used to name (or, equivalently, signify or designate) intuitive mathematical objects (e.g., numbers, functions, sequences, etc.);
• model—a formal model to compute functions, such as a Turing machine (TM) (cf., e.g., Ch. 6 in [1]);
• program—a signified finite sequence of instructions in $\mathcal{L}$ on $\mathcal{A}$ that specifies how a function named by the program can be computed, i.e., how a signified sequence of inputs in $\mathcal{L}$ on $\mathcal{A}$ can be mapped (or, equivalently, transformed) to a signified sequence of outputs by a computer capable of performing instructions in $\mathcal{L}$ on $\mathcal{A}$;
• computer—a device or an agent, physical or abstract, that executes programs in $\mathcal{L}$ on $\mathcal{A}$ on given inputs according to a specific model;
• program state—a state of a program in $\mathcal{L}$ on $\mathcal{A}$ signified by a spatiotemporally finite text in $\mathcal{L}$ on $\mathcal{A}$ that, at a minimum, signifies the value of every variable used by the program and the next instruction in the program for a computer to perform;
• computation—a finite sequence of program states signified by a spatiotemporally finite text in $\mathcal{L}$ on $\mathcal{A}$ that a computer goes through in order to compute the signified values of a function designated by a program in $\mathcal{L}$ on $\mathcal{A}$ on a signified input (or, equivalently, to transform a signified input to a signified output);
• class of functions—a set of functions; in the CCT, the three most prominent classes are: primitive recursive; computable; and partially computable.

Finite automata (cf., e.g., [5]) such as finite state machines (FSA), stack machines (also known as push-down automata (PDA)), and TMs are formal models signifiable with different formalisms on different alphabets to compute different classes of functions. A formalism $\mathcal{L}$ is necessarily paired with an alphabet $\mathcal{A}$. E.g., a programming language, such as Lisp, Perl, C/C++, etc., can be defined on Unicode or ASCII. Computability is a property of functions. E.g., a primitive recursive function (e.g., $f\left(x\right)=x+1$) is signifiable in different formalisms on different alphabets and is computable by an FSA, a PDA, or a TM. There are functions signifiable with context-free formalisms and computable by PDAs that are not computable by FSAs (e.g., $f\left(n\right)$ = ëⁿ${?}^n$, $n>0$, where ëⁿ and ${?}^n$ denote n consecutive occurences of ë and ?, respectively). There are functions signifiable with context-sensitive formalisms that are computable by TMs but not by PDAs (e.g., $f\left(n\right)$ = ëⁿ${?}^n{!}^n$, $n>0$) (cf., e.g., [6]). In formal logic, some texts in $\mathcal{L}$ on $\mathcal{A}$ are referred to as names and the named classes of those objects are called extensions (cf. p. 94 and pp. 268–269 in [7]). If a text signifies a unique object, it signifies a singleton.

The statements $S_1\subset S_2$ and $S_1\subseteq S_2$ mean that $S_1$ is a proper subset and a subset of the set $S_2$, respectively; ∅ denotes the empty set. $\mathbb{N}$, $\mathbb{Z}$, ${\mathbb{Z}}^{-}$, ${\mathbb{Z}}^{+}$, $\mathbb{Q}$, $\mathbb{R}$ respectively denote the infinite sets of natural numbers ($\mathbb{N}=\{0,1,2,\dots \}$), of whole numbers ($\mathbb{Z}=\{\dots ,-2,-1,0,1,2,\dots \}$), of negative whole numbers (${\mathbb{Z}}^{-}=\{\dots ,-2,-1\}$), of positive whole numbers (${\mathbb{Z}}^{+}=\{1,2,3,\dots \}$), of rational numbers ($\mathbb{Q}=\left\{{\displaystyle \frac{m}{n}}\right|m\in \mathbb{Z},$ $n\in {\mathbb{Z}}^{-}\cup {\mathbb{Z}}^{+}\}$), and of real numbers that include the whole numbers, the rational numbers, and the irrational numbers. If $T_{i_1},T_{i_2},\dots ,T_{i_k}$, $k\in {\mathbb{Z}}^{+}$ are sets, then

$$T_{i_1}\times T_{i_2}\times \cdots \times T_{i_k}=\left\{(t_{i_1},t_{i_2},\dots ,t_{i_k})\right|t_{i_1}\in T_{i_1},t_{i_2}\in T_{i_2},\dots ,t_{i_k}\in T_{i_k}\},$$

where $(t_{i_1},t_{i_2},\dots t_{i_k})$ is called a k-tuple, i.e., a finite sequence of k elements.

A finite-memory device (FMD) $\mathcal{D}$ is a computational device with a finite number of memory units (or, equivalently, memory cells) available for computation. An FMD is not a model of computation insomuch as it can perform computations according to different models so long as each computation can be signified within its memory capacity. If $\mathfrak{D}$ is the set of all FMDs, then the function $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}:\mathfrak{D}\mapsto {\mathbb{Z}}^{+}$ maps each FMD to the number of its memory cells. Thus, each FMD has a strictly positive memory capacity. It should be noted that if a device $\mathcal{D}\in \mathfrak{D}$ is an FSA, a PDA, or a TM, then

$$\neg (\exists k)\{k\in {\mathbb{Z}}^{+}\wedge \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)=k\}.$$

On the other hand, if D is an FMD, then

$$(\exists k)\{k\in {\mathbb{Z}}^{+}\wedge \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)=k\}.$$

Thus, if ${\mathcal{D}}_1$ and ${\mathcal{D}}_2$ are two TMs, the predicates $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left({\mathcal{D}}_1\right)=\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left({\mathcal{D}}_2\right)$, $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left({\mathcal{D}}_1\right)<\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left({\mathcal{D}}_2\right)$, $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left({\mathcal{D}}_1\right)>\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left({\mathcal{D}}_2\right)$ are, respectively, equivalent to $\infty =\infty$, $\infty <\infty$, $\infty >\infty$, of which the first statement is vacuously true, whereas the second and third statements have no immediate logical satisfaction without a reinterpretation of < and > (e.g., along the lines of Cantor’s set theory, where ${\aleph }_0$ < $2^{{\aleph }_0}$). On the other hand, if ${\mathcal{D}}_1$ and ${\mathcal{D}}_2$ are FMDs, then the three CCAP statements above can be assigned the Boolean values of True and False under the standard interpretation of the three comparison operators on natural numbers.

If $\mathcal{D}$ is an FSA, a PDA, or a TM, then $\mathcal{D}$ can be turned into an FMD if, and only if, one of the two conditions holds. First, $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)=k,k\in {\mathbb{Z}}^{+}$, i.e., an explicit upper bound in the form of a concrete positive integer is placed on the combined size of the the text that signifies the finite control of $\mathcal{D}$ and the size of the input tape. Second, $\mathcal{D}$ is signified in a specific formalism on a specific alphabet (e.g., Lisp, Perl, C/C++ on Unicode) on a specific FMD (e.g., a computer with 5 TB of RAM and hard disk space). In the latter case, $\mathcal{D}$ is an FMD, because its memory capacity is bounded by the memory capacity of the device on which it runs, i.e., $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)\le 5$ TB.

An elementary sign is that which can be written in exactly one memory cell. We enclose all elementary signs in pairs of matching " (e.g., "0", "1", "+"). The elementary sign "" is the empty sign. An alphabet is an enumerably finite, non-empty set of non-empty elementary signs. A text is a spatiotemporally finite sequences of elementary signs of $\mathcal{A}$. We intentionally use the term text instead of the term string to avoid allusions to the modern string theory in physics or to the classical finite automata theory of theoretical computer science. All texts are also enclosed in matching pairs of ". An alphabet $\mathcal{A}$ is decimal-sufficient if, and only if, $\mathcal{A}$ contains the signs of the standard decimal notation or their isomorphic equivalents. $\mathcal{L}$ on $\mathcal{A}$ is decimal-sufficient if, and only if, it allows, via a finite set of rules, for the mechanical formation of texts on $\mathcal{A}$ in the characteristic-mantissa form of the standard decimal notation.

A basic text formation operation in $\mathcal{L}$ on $\mathcal{A}$ is concatenation, denoted as ${⨁}_{\mathcal{A},\mathcal{L}}$. The order of the sign concatenation in the formation of a text is arbitrarily assumed to be left to right, i.e., for $n\in {\mathbb{Z}}^{+}$,

$$\begin{array}{ccc}{s}_{i_1}{s}_{i_2}\dots s_{i_n}\hfill & =\hfill & \left(\dots \left(\dots \left(\left(s_{i_1}{⨁}_{\mathcal{A},\mathcal{L}}{s}_{i_2}\right){⨁}_{\mathcal{A},\mathcal{L}}{s}_{i_3}\right)\dots {⨁}_{\mathcal{A},\mathcal{L}}{s}_{i_{n-1}}\right){⨁}_{\mathcal{A},\mathcal{L}}{s}_{i_n}\right).\hfill \end{array}$$

Two enumerably infinite sets, denoted as

$${\mathcal{A}}_{\mathcal{L}}^{+};{\mathcal{A}}_{\mathcal{L}}^{\ast },$$

are associated with $\mathcal{L}$ on $\mathcal{A}$. The first set includes all signs of $\mathcal{A}$ and all non-empty texts in $\mathcal{L}$ on $\mathcal{A}$ formed according to the finite set of rules of $\mathcal{L}$. The second set is defined as

$${\mathcal{A}}_{\mathcal{L}}^{\ast }=\left\{""\right\}\cup {\mathcal{A}}_{\mathcal{L}}^{+}.$$

For $t_i\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $1\le i\le l\in {\mathbb{Z}}^{+}$, $l>1$, we let

$$\begin{array}{ccc}{⨁}_{\mathcal{A},\mathcal{L}}\left(t_1,t_2,\dots ,t_l\right)={⨁}_{\mathcal{A},\mathcal{L}}{|}_{i=1}^l{t}_i=\hfill & \hfill & \\ \\ {⨁}_{\mathcal{A},\mathcal{L}}{t}_1{⨁}_{\mathcal{A},\mathcal{L}}{t}_2{⨁}_{\mathcal{A},\mathcal{L}}\dots {⨁}_{\mathcal{A},\mathcal{L}}{t}_l.\hfill & \hfill & \end{array}$$

(1)

If $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$, then $\left|t\right|$ is the number of the elementary signs from $\mathcal{A}$ in t. If $s\in \mathcal{A}$, then $\left|s\right|=1$ and $\left|""\right|=0$. If $\left|t\right|=n\in {\mathbb{Z}}^{+}$, then $s_1$, $s_2$, $\dots ,$ $s_n$ designate the consecutive elementary signs of $t=s_1{s}_2\dots s_n$ from the leftmost to the rightmost, where $s_i\in \mathcal{A},1\le i\le n$.

If f is a function, $dom\left(f\right)$ and $ran\left(f\right)$ denote the domain and the range of f, respectively; $f:S\mapsto R$ abbreviates $dom\left(f\right)=S\wedge ran\left(f\right)=R$, where ∧ denotes the logical and. E.g., if $f\left(n\right)$ = ëⁿ${?}^n{!}^n$, $n>0$, then $dom\left(f\right)={\mathbb{Z}}^{+}$ and $ran\left(f\right) = \{$ ë$?!$, ëë$??!!$, ëëë$???!!!$, $\dots \}$ or, equivalently, $f:\mathbb{N}\mapsto \{$ ë$?!$, ëë$??!!$, ëëë$???!!!$, $\dots \}$. If $f:T_{i_1}\times T_{i_2}\times \cdots \times T_{i_k}\mapsto T_j$ and $(t_{i_1},t_{i_2},\dots ,t_{i_k})\in dom\left(f\right)$, then f is defined on$(t_{i_1},t_{i_2},\dots ,t_{i_k})$ or, in symbols, $f(t_{i_1},t_{i_2},\dots ,t_{i_k})\downarrow$ if, and only if, there exists $t_j\in T_j$ such that $f(t_{i_1},t_{i_2},\dots ,t_{i_k})=t_j$ or, equivalently, $(\exists t_j\in T_j)\{f(t_{i_1},t_{i_2},\dots ,t_{i_k})=t_j\}$, where ∃ designates the logical existential quantifier. If $\neg (\exists t_j\in T_j)$ $\{f(t_{i_1},t_{i_2},\dots ,t_{i_k})=t_j\}$, where ¬ designates the logical not, then f is undefined on$(t_{i_1},t_{i_2},\dots ,t_{i_k})$ or, in symbols, $f(t_{i_1},t_{i_2},\dots ,t_{i_k})\uparrow$. If $f:T_{i_1}\times T_{i_2}\times \cdots \times T_{i_k}\mapsto T_j$ and

$$(\forall (t_{i_1},t_{i_2},\dots ,t_{i_k})\in T_{i_1}\times T_{i_2}\times \cdots \times T_{i_k})(\exists t_j\in T_j)\{f(t_{i_1},t_{i_2},\dots ,t_{i_k})=t_j\},$$

where ∀ designates the logical universal quantifier, f is total on $T_{i_1}\times T_{i_2}\times \dots \times T_{i_k}$. If

$$(\exists (t_{i_1},t_{i_2},\dots ,t_{i_k})\in T_{i_1}\times T_{i_2}\times \cdots \times T_{i_k})\{f(t_{i_1},t_{i_2},\dots ,t_{i_k})\uparrow \},$$

then f is partial on $T_{i_1}\times T_{i_2}\times \dots \times T_{i_k}$. It should be noted that while the notation $f:T_{i_1}\times T_{i_2}\times \cdots \times T_{i_k}\mapsto T_j$ is used for partial and total functions, total functions on $T_{i_1}\times T_{i_2}\times \dots \times T_{i_k}$ are defined for all $(t_{i_1},t_{i_2},\dots ,t_{i_k})\in T_{i_1}\times T_{i_2}\times \dots \times T_{i_k}$, whereas partial functions on $T_{i_1}\times T_{i_2}\times \dots \times T_{i_k}$ may not be defined for some $(t_{i_1},t_{i_2},\dots ,t_{i_k})\in T_{i_1}\times T_{i_2}\times \dots \times T_{i_k}$. Thus, every total function on $T_{i_1}\times T_{i_2}\times \dots \times T_{i_k}$ is partial on $T_{i_1}\times T_{i_2}\times \dots \times T_{i_k}$, but not vice versa.

Let $r\in \mathbb{R}$. Then, r is discretely finite in $\mathcal{L}$ on $\mathcal{A}$ if, and only if, there exists

$$S_r=\left\{t|t\in {\mathcal{A}}_{\mathcal{L}}^{+}\right\}\ne \varnothing ,$$

where each t signifies (or, equivalently, designates or names) r and no other number, or, in symbols,

$$r\leftarrow {\{=\}}_{\mathcal{A},\mathcal{L}}\to S_r.$$

(2)

If $t\in S_r$, then t signifies r in $\mathcal{L}$ on $\mathcal{A}$, or, in symbols,

$$t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r.$$

(3)

$\leftarrow {\{=\}}_{\mathcal{A},\mathcal{L}}\to$ and $\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to$ are symmetric.

Let $r\in \mathbb{R}$ such that $r\leftarrow {\{=\}}_{\mathcal{A},\mathcal{L}}\to S_r\ne \varnothing$. Then, r is finite-memory signifiable (FM-signifiable) or, equivalently, FM-designatable in $\mathcal{L}$ on $\mathcal{A}$ on an FMD $\mathcal{D}$ if, and only if, there exists $S_r^{\prime }\subseteq S_r$ such that $S_r^{\prime }=\left\{t\right|\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)\ge \left|t\right|\}\ne \varnothing$, in which case,

$$r\leftarrow {\{=\}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\to S_r^{\prime }$$

(4)

holds. If $t\in S_r^{\prime }$, then t FM-signifies or, equivalently, FM-designates r in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$, or, in symbols,

$$t\leftarrow {(=)}_{\mathcal{A},\mathcal{L},\mathcal{D}}\to r.$$

(5)

$\leftarrow {\{=\}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\to$ and $\leftarrow {(=)}_{\mathcal{A},\mathcal{L},\mathcal{D}}\to$ are symmetric. In general, the subscript $\mathcal{D}$ when added to the right of the subscripts $\mathcal{L}$ and $\mathcal{A}$ means that a relationship is defined not only relative to $\mathcal{L}$ and $\mathcal{A}$ but also to $\mathcal{D}$, and, in particular, relative to $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$.

A numeral is $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ that designates a real number. A decimal-sufficient alphabet $\mathcal{A}$ can be extended with the unique signs ⊴, ⊵, ∓ that designate the beginning of a tuple, the end of a tuple, and a number separator inside a tuple, respectively. E.g., let

$$\mathcal{A}=\{"\mathtt{0}","\mathtt{1}","\mathtt{2}","\mathtt{3}","\mathtt{4}","\mathtt{5}","\mathtt{6}","\mathtt{7}","\mathtt{8}","\mathtt{9}","+","-","."\},$$

(6)

be a decimal-sufficient alphabet and let

$$\begin{array}{ccc}\mathcal{B}\hfill & =\hfill & \mathcal{A}\cup {\mathcal{A}}_{\mathsf{\Delta }};\hfill \\ \\ {\mathcal{A}}_{\mathsf{\Delta }}\hfill & =\hfill & \{"♢","{|}_a",{"}_a|",";","▿","\square ","◂","⊛"\}.\hfill \end{array}$$

(7)

$\mathcal{B}$ consists of the standard decimal notation signs in $\mathcal{A}$ and the signs in ${\mathcal{A}}_{\mathsf{\Delta }}$ that can be used to signify number tuples, data types, and data instances. Specifically, in $\mathcal{B}$ in (7), we let ⊴ = "${|}_a$", ⊵ = "_a$|$", and ∓ = ";". Alphabets that contain these unique signs are tuple-sufficient. Thus, $\mathcal{B}$ is tuple-sufficient. $\mathcal{L}$ on a tuple-sufficient $\mathcal{A}$ is tuple-sufficient if, and only if, $\mathcal{L}$ contains finitely many rules that allow for the signification of k-tuples of discretely finite real numbers on $\mathcal{A}$. For brevity, we will say that $\mathcal{L}$ on $\mathcal{A}$ is tuple-sufficient to mean that both $\mathcal{L}$ and $\mathcal{A}$ are tuple-sufficient. E.g., Lisp, Perl, C/C++ on Unicode are tuple-sufficient.

Let $t_i\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $1\le i\le l\in {\mathbb{Z}}^{+}$, $l>1$, $t_i\ne ⊴$, $t_i\ne ⊵$, $t_i\ne \mp$. Then,

$${⨁}_{\mathcal{A},\mathcal{L}}\left(t_1,\mp ,t_2,\mp ,\dots ,\mp ,t_l\right)$$

is the unmarked concatenation of $t_1,\dots ,t_l$ in $\mathcal{L}$ on $\mathcal{A}$ and

$${⨁}_{\mathcal{A},\mathcal{L}}\left(⊴,{⨁}_{\mathcal{A},\mathcal{L}}\left(t_1,\mp ,t_2,\mp ,\dots ,\mp ,t_l\right),⊵\right)$$

is the marked concatenation of $t_1,\dots ,t_l$ in $\mathcal{L}$ on $\mathcal{A}$. E.g., in a tuple-sufficient $\mathcal{L}$ on $\mathcal{B}$, "1;2;3" is the unmarked concatenation of "1", "2", and "3", whereas "${|}_a$1;2;3_a$|$" is the marked concatenation of "1", "2", and "3".

A k-tuple $\mathfrak{r}=(r_1,\dots ,r_k)\in {\mathbb{R}}^k$, $1<k\in {\mathbb{Z}}^{+}$, is signifiable or, equivalently, designatable in $\mathcal{L}$ on $\mathcal{A}$ if, and only if, (a) $\mathfrak{r}$ is of type $\mathbb{T}$ and $\mathbb{T}$ is signifiable in $\mathcal{L}$ on $\mathcal{A}$, or, in symbols, $\mathbb{T}\Leftarrow {\between }_{\mathcal{A},\mathcal{L}}\Rightarrow t_{\mathbb{T}}\in {\mathcal{A}}_{\mathcal{L}}^{+}$; and (b) $r_i\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t_i$, $t_i\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $1\le i\le k$. If (a) and (b) hold, then $\mathfrak{r}$ is signifiable in $\mathcal{L}$ on $\mathcal{A}$ by

$$t_{\mathfrak{r}}={⨁}_{\mathcal{A},\mathcal{L}}\left(⊴,{⨁}_{\mathcal{A},\mathcal{L}}\left(t_1,\mp ,t_2,\mp ,\dots ,\mp ,t_k\right),⊵\right)$$

or, in symbols,

$$\mathfrak{r}\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L}}\to t_{\mathfrak{r}}.$$

If $\mathfrak{r}$ is not signifiable in $\mathcal{L}$ on $\mathcal{A}$, then $\mathfrak{r}$ $\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L}}\to$ ""; $\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L}}\to$ is symmetric.

A k-tuple $\mathfrak{r}=(r_1,\dots ,r_k)\in {\mathbb{R}}^k$, $1<k\in {\mathbb{Z}}^{+}$, is finite-memory signifiable (FM-signifiable) or, equivalently, FM-designatable in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$ if, and only if, (a) $\mathfrak{r}$ $\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L}}\to t_{\mathfrak{r}}\in {\mathcal{A}}_{\mathcal{L}}^{+}$ and (b) $|t_{\mathfrak{r}}|\le \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$. If (a) and (b) hold, then $\mathfrak{r}$ $\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L},\mathcal{D}}\to t_{\mathfrak{r}}$. If $\mathfrak{r}$ is not FM-signifiable in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$, then $\mathfrak{r}$ $\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L},\mathcal{D}}\to$ ""; $\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L},\mathcal{D}}\to$ is symmetric.

Let $p_i$ be the i-th prime so that $p_1=2$, $p_2=3$, $p_3=5$, etc., and let

$$\pi \left(i\right)=p_i.$$

(8)

Let $(n_1,\dots ,n_k)$ be a k-tuple such that $n_i\in \mathbb{N},1\le i\le k$. The Gödel number (G-number) of $(n_1,\dots ,n_k)$ is

$$[n_1,\dots ,n_k]=\prod _{i=1}^k\pi {\left(i\right)}^{n_i}.$$

(9)

Let $(z_1,\dots ,z_k)$ be such that $z_i\in {\mathbb{Z}}^{+},1\le i\le k$. The j-shifted Gödel number (denoted as ${\mathrm{G}}_{\mathsf{\Delta }=j}$, $j\in \mathbb{N}$) of this k-tuple is

$${[z_1,\dots ,z_k]}_{\mathsf{\Delta }=j}=\prod _{i=1}^k\pi {(i+j)}^{z_i}.$$

(10)

The G-number and ${\mathrm{G}}_{\mathsf{\Delta }=j}$-number of $\left(\right)$ are defined to be 1.

Let ${\gamma }_{\mathcal{A}}:\mathcal{A}\mapsto {\mathbb{Z}}^{+}$ be a 1–1 function that maps each sign of $\mathcal{A}$ to a unique odd prime, i.e.,

$$\begin{array}{ccc}{\gamma }_{\mathcal{A}}\left(s_i\right)\hfill & =\hfill & \pi (i+1),1\le i\le l,l>0.\hfill \end{array}$$

(11)

E.g., for $\mathcal{B}$ in (7), we have

$$\begin{array}{cccccccccccc}{\gamma }_{\mathcal{B}}\left("\mathtt{0}"\right)\hfill & =\hfill & 3;\hfill & {\gamma }_{\mathcal{B}}\left("\mathtt{1}"\right)\hfill & =\hfill & 5;\hfill & {\gamma }_{\mathcal{B}}\left("\mathtt{2}"\right)\hfill & =\hfill & 7;\hfill & {\gamma }_{\mathcal{B}}\left("\mathtt{3}"\right)\hfill & =\hfill & 11;\hfill \\ {\gamma }_{\mathcal{B}}\left("\mathtt{4}"\right)\hfill & =\hfill & 13;\hfill & {\gamma }_{\mathcal{B}}\left("\mathtt{5}"\right)\hfill & =\hfill & 17;\hfill & {\gamma }_{\mathcal{B}}\left("\mathtt{6}"\right)\hfill & =\hfill & 19;\hfill & {\gamma }_{\mathcal{B}}\left("\mathtt{7}"\right)\hfill & =\hfill & 23;\hfill \\ {\gamma }_{\mathcal{B}}\left("\mathtt{8}"\right)\hfill & =\hfill & 29;\hfill & {\gamma }_{\mathcal{B}}\left("\mathtt{9}"\right)\hfill & =\hfill & 31;\hfill & {\gamma }_{\mathcal{B}}\left("+"\right)\hfill & =\hfill & 37;\hfill & {\gamma }_{\mathcal{B}}\left("-"\right)\hfill & =\hfill & 41;\hfill \\ {\gamma }_{\mathcal{B}}\left("."\right)\hfill & =\hfill & 43;\hfill & {\gamma }_{\mathcal{B}}("♢")\hfill & =\hfill & 47;\hfill & {\gamma }_{\mathcal{B}}("{|}_a")\hfill & =\hfill & 53;\hfill & {\gamma }_{\mathcal{B}}\left({"}_a\right|")\hfill & =\hfill & 59;\hfill \\ {\gamma }_{\mathcal{B}}(";")\hfill & =\hfill & 61;\hfill & {\gamma }_{\mathcal{B}}("▿")\hfill & =\hfill & 67;\hfill & {\gamma }_{\mathcal{B}}("\square ")\hfill & =\hfill & 71;\hfill & {\gamma }_{\mathcal{B}}("◂")\hfill & =\hfill & 73;\hfill \\ {\gamma }_{\mathcal{B}}("⊛")\hfill & =\hfill & 79.\hfill & \hfill & & \hfill & & \hfill & & \hfill & & \end{array}$$

The 1–1 function in (12) maps $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ (i.e., $t=s_1\dots s_n$, $n\in {\mathbb{Z}}^{+}$, $s_j\in \mathcal{A}$, $1\le j\le n$) to a unique positive integer and maps "" to 0 (cf. Theorem 4 in [4]).

$${\mathfrak{g}}_{\mathcal{A},\mathcal{L}}\left(t\right)=\left\{\begin{array}{cc}{[{\gamma }_{\mathcal{A}}\left(s_1\right),\dots ,{\gamma }_{\mathcal{A}}\left(s_n\right)]}_{\mathsf{\Delta }=1}\hfill & \mathrm{if}\left|t\right|>0,\hfill \\ 0\hfill & \mathrm{if}\left|t\right|=0.\hfill \end{array}\right.$$

(12)

3. Formation, Transformation, Metacomputability

A programming formalism $\mathcal{L}$ on $\mathcal{A}$ is a formalism by which one formal system generates texts in $\mathcal{L}$ on $\mathcal{A}$ that signify sequences of numerical instructions that another formal system can perform. Hence,

Definition 1 (Programming Formalism).

Let $\mathcal{L}$ be tuple-sufficient on $\mathcal{A}$. Then, $\mathcal{L}$ on $\mathcal{A}$ is a programming formalism if it is used by two formal systems: the Former ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ and the Transformer ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$.

A formal system in (1) is specified by a finite set of formal rules and a rule application mechanism to form texts or to transform texts into other texts. The rules and rule application mechanisms have no meaning inside the systems and, in that sense, are purely syntactic (cf. Ch. IV in [8]).

Definition 2 (The Former).

The formal text formation system, denoted as ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$, is a finite set of rules

$${\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}=\left\{f{r}_1,\dots ,f{r}_k|f{r}_j:{{\mathcal{A}}_{\mathcal{L}}^{\ast }}^m\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\right\},0<j\le k,k,m\in {\mathbb{Z}}^{+},$$

and a rule application mechanism $M_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ to form texts in ${\mathcal{A}}_{\mathcal{L}}^{+}$.

Each formation rule $f{r}_j\in {\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ is assigned a unique name $t_{f{r}_j}\in {\mathcal{A}}_{\mathcal{L}}^{+}$ (i.e., signified with a unique $t_{f{r}_j}$). Since ${\mathfrak{g}}_{\mathcal{A},\mathcal{L}}\left(t_{f{r}_j}\right)$ is a unique natural number, we have

$$(\exists t^{\prime })\left\{t^{\prime }\in {\mathcal{A}}_{\mathcal{L}}^{+}\wedge t^{\prime }\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to {\mathfrak{g}}_{\mathcal{A},\mathcal{L}}\left(t_{f{r}_j}\right)\right\},$$

(13)

so that each formation rule is mapped to a unique natural number signifiable in $\mathcal{L}$ on $\mathcal{A}$, which we abbreviate as

$$f{r}_j\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t_{f{r}_j}.$$

(14)

If ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ uses the rule sequence $f{r}_{i_1},f{r}_{i_2},\dots ,f{r}_{i_l}$, $l\in {\mathbb{Z}}^{+}$, to form $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ from "", then, by convention, the first argument of each rule takes the output of the previous rule and the first argument of $f{r}_{i_1}$ is "", whence

$$t=f{r}_{i_l}\left(f{r}_{i_{l-1}}\left(\dots f{r}_{i_2}\left(f{r}_{i_1}\left(t_{i_{1_1}},\dots ,t_{i_{1_m}}\right),\dots ,t_{i_{2_m}}\right)\dots ,t_{i_{{l-1}_m}}\right)\dots ,t_{i_{l_m}}\right),$$

where $t_{i_{j_1}}=$ "" and $t_{i_{j_k}}\in {\mathcal{A}}_{\mathcal{L}}^{\ast }$, $1<j\le l$, $1<k\le m\in {\mathbb{Z}}^{+}$. E.g., if $\mathcal{L}$ is tuple-sufficient on

$$\begin{array}{ccc}\mathcal{A}\hfill & =\hfill & \{"\mathtt{0}","\mathtt{1}","\mathtt{2}","\mathtt{3}","\mathtt{4}","\mathtt{5}","\mathtt{6}","\mathtt{7}","\mathtt{8}","\mathtt{9}","+","-",".",\hfill \\ \hfill & \hfill & {"♢","|}_a",{"}_a|",";","▿","\square ","◂","⊛","♣"\}\hfill \end{array}$$

(15)

and ${\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ contains the rule for ${⨁}_{\mathcal{A},\mathcal{L}}$, then

$$"\mathtt{3.14}"={⨁}_{\mathcal{A},\mathcal{L}}\left({⨁}_{\mathcal{A},\mathcal{L}}\left({⨁}_{\mathcal{A},\mathcal{L}}\left({⨁}_{\mathcal{A},\mathcal{L}}\left("","\mathtt{3}"\right),"."\right),"\mathtt{1}"\right),"\mathtt{4}"\right).$$

${\mathcal{A}}_{⨁}$ designates the concatenation of the signs in $\mathcal{A}$ separated with $\mp \notin \mathcal{A}$. E.g., if $\mp =$"♡", then, for $\mathcal{A}$ in (15), we have

$${\mathcal{A}}_{⨁}="\mathtt{0}♡\mathtt{1}♡\mathtt{2}♡\mathtt{3}♡\mathtt{4}♡\mathtt{5}♡\mathtt{6}♡\mathtt{7}♡\mathtt{8}♡\mathtt{9}♡+♡-♡.♡♢♡{|}_a{♡}_a|♡;♡▿♡\square ♡◂♡⊛♡♣♡".$$

Definition 3 (Text Formation).

A mechanical formation or, simply, formation of $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ is a finite sequence of formation rules $f{r}_{i_1},f{r}_{i_2},\dots ,f{r}_{i_l}$, $f{r}_{i_l}\in {\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ such that

$$t=f{r}_{i_l}\left(f{r}_{i_{l-1}}\left(\dots f{r}_{i_2}\left(f{r}_{i_1}\left(t_{i_{1_1}},\dots ,t_{i_{1_m}}\right),\dots ,t_{i_{2_m}}\right)\dots ,t_{i_{{l-1}_m}}\right)\dots ,t_{i_{l_m}}\right),$$

where

$$\begin{array}{c}f{r}_{i_j}\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t_{f{r}_{i_j}}\in {\mathcal{A}}_{\mathcal{L}}^{+};\hfill \\ t_{i_{j_1}}="";t_{i_{j_k}}\in {\mathcal{A}}_{\mathcal{L}}^{\ast };\hfill \\ 1\le j\le l\in {\mathbb{Z}}^{+};1<k\le m\in {\mathbb{Z}}^{+}.\hfill \end{array}$$

Each rule $f{r}_j\in {\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ has access to ${\mathcal{A}}_{⨁}$.

Definition 4 (Formation Signature).

Let $f{r}_{i_1},f{r}_{i_2},\dots ,f{r}_{i_l}$, $f{r}_{i_l}\in {\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$, $l\in {\mathbb{Z}}^{+}$, be a formation of $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$, where, for $m\in {\mathbb{Z}}^{+}$,

$$t=f{r}_{i_l}\left(f{r}_{i_{l-1}}\left(\dots f{r}_{i_2}\left(f{r}_{i_1}\left(t_{i_{1_1}},\dots ,t_{i_{1_m}}\right),\dots ,t_{i_{2_m}}\right)\dots ,t_{i_{{l-1}_m}}\right)\dots ,t_{i_{l_m}}\right).$$

Then,

$$\begin{array}{c}s={⨁}_{\mathcal{A},\mathcal{L}}\left(⊴,t_{f{r}_{i_l}},⊴,t_{f{r}_{i_{l-1}}},⊴,\dots ,t_{f{r}_{i_2}},⊴,t_{f{r}_{i_1}},⊴,{\mathfrak{a}}_{f{r}_{i_1}},⊵,{\mathfrak{a}}_{f{r}_{i_2}},⊵,\dots ,{\mathfrak{a}}_{f{r}_{i_{l-1}}},⊵,{\mathfrak{a}}_{f{r}_{i_l}},⊵,⊵\right),\end{array}$$

where $f{r}_{i_j}\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t_{f{r}_{i_j}}$, $1\le j\le l$, ${\mathfrak{a}}_{f{r}_{i_1}}={⨁}_{\mathcal{A},\mathcal{L}}\left(t_{i_{1_1}},\mp ,\dots ,\mp ,t_{i_{1_m}}\right)$, ${\mathfrak{a}}_{f{r}_{i_2}}={⨁}_{\mathcal{A},\mathcal{L}}\left(t_{i_{2_1}},\mp ,\dots ,\mp ,t_{i_{2_m}}\right)$, …, ${\mathfrak{a}}_{f{r}_{i_l}}={⨁}_{\mathcal{A},\mathcal{L}}\left(t_{i_{l_1}},\mp ,\dots ,\mp ,t_{i_{l_m}}\right)$, for $t_{i_{j_k}}$, $1\le j\le l$, $1\le k\le m$, is a formation signature of $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$, whence

$$(f{r}_{i_1},f{r}_{i_2},\dots ,f{r}_{i_l})\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L}}\to s,$$

and $(f{r}_{i_1},f{r}_{i_2},\dots ,f{r}_{i_l})$ is a signed formation of $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ designated by s.

E.g., let $\mathcal{L}$ be tuple-sufficient on $\mathcal{B}$ in (7), where ⊴ = "${|}_a$", ⊵ = "${|}_a$", ∓ = ";", and

$${⨁}_{\mathcal{A},\mathcal{L}}\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to "♣".$$

Then, if we keep the matching pairs of " only in "" and "." for clarity and omit them elsewhere for brevity, then

$${s="♣|}_a{♣|}_a{♣|}_a{♣|}_a"";3_a|;{"."}_a|;1_a|;4_a|"$$

designates the formation signature of "3.14" by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$.

Thus, any $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ formed by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ exists as a spatiotemporally finite entity constructed from a finite number of signs of $\mathcal{A}$ by finitely many rules signified in the formation signature of t. Hence, our first two axioms.

SCT Axiom 1. 

A signed formation of $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ takes a finite amount of physical time, and t occupies a finite amount of physical space.

SCT Axiom 2. 

If s designates a formation signature of t by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$, then, given $\mathcal{A}$, s, and ${\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$, another formal system can deterministically verify the formation of t by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ within a finite amount of physical time and space.

No a priori knowledge is assumed on how time and space are physically measured (e.g., sun cycles, turns of a sand clock, nanoseconds, meters, centimeters, cubic meters, bits, bytes, megabytes, etc.). SCT Axioms 1 and 2 concretize CCT Axiom A1 (cf. Appendix A) by taking a definite position on the origin of texts that designate programs: (1) these texts are produced by one formal system for another formal system; (2) their production can be deterministically verified; and (3) the produced texts are spatiotemporally finite objects.

For $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$, the predicate

$${\Vvdash }_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\left(t\right)$$

(16)

holds if, and only if, t is formed by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ through a signed formation. We let ${\Vvdash }_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\left(""\right)$ vacuously hold and define

$${\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}=\left\{t\in {\mathcal{A}}_{\mathcal{L}}^{+}|{\Vvdash }_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\left(t\right)\right\}$$

(17)

to be the enumerably infinite set of texts formed by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$. E.g., if $\mathcal{A}$ is Unicode and $\mathcal{L}$ is Lisp and ${\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ includes the finitely many Common Lisp program formation rules in [9], then

$$\begin{array}{ccc}{\Vvdash }_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\left("\left(\mathtt{d}\mathtt{e}\mathtt{f}\mathtt{u}\mathtt{n}\mathtt{f}\right(\mathtt{n}\left)\right(+\mathtt{n}\mathtt{1}\left)\right)"\right)\hfill & \equiv \hfill & "\left(\mathtt{d}\mathtt{e}\mathtt{f}\mathtt{u}\mathtt{n}\mathtt{f}\right(\mathtt{n}\left)\right(+\mathtt{n}\mathtt{1}\left)\right)"\in {\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}.\hfill \end{array}$$

Definition 5 (The Transformer).

The formal text transformation system, denoted as ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$, is a finite set of rules

$${\mathfrak{R}}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}=\left\{t{r}_1,\dots t{r}_k|t{r}_j:{\mathcal{A}}_{\mathcal{L}}^{\ast }\mapsto {\mathcal{A}}_{\mathcal{A}}^{\ast }\right\},1\le j\le k,k\in {\mathbb{Z}}^{+},$$

and a deterministic rule application mechanism $M_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}$ to transform texts in ${\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ into texts in ${\mathcal{A}}_{\mathcal{L}}^{\ast }$.

Each transformation rule $t{r}_j\in {\mathfrak{R}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ is assigned a unique name $w_{t{r}_j}\in {\mathcal{A}}_{\mathcal{L}}^{+}$ (i.e., signified with a unique $w_{t{r}_j}$). Since ${\mathfrak{g}}_{\mathcal{A},\mathcal{L}}\left(w_{f{r}_j}\right)$ is a unique natural number,

$$(\exists t^{\prime })\left\{t^{\prime }\in {\mathcal{A}}_{\mathcal{L}}^{+}\wedge t^{\prime }\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to {\mathfrak{g}}_{\mathcal{A},\mathcal{L}}\left(w_{f{r}_j}\right)\right\}$$

(18)

so that each transformation rule is mapped to a unique natural number signifiable in $\mathcal{L}$ on $\mathcal{A}$, which we abbreviate as

$$t{r}_j\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to w_{f{r}_j}.$$

(19)

Associated with every tuple $(\mathcal{A},\mathcal{L})$ is a finite, non-empty set of error messages

$${\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}=\left\{t|t\in {\mathcal{A}}_{\mathcal{L}}^{+}\right\},{\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}\cap {\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}=\varnothing ,$$

(20)

that the transformation rules of ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ can output to signal that specific transformations are impossible. E.g., if ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ cannot verify the formation of $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$, then ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ issues an error message.

Suppose that ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ uses the rule sequence $t{r}_{i_1},t{r}_{i_2},\dots ,t{r}_{i_l}$, $l\in {\mathbb{Z}}^{+}$, to transform $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ to $t^{\prime }\in {\mathcal{A}}_{\mathcal{L}}^{\ast }$. By convention, the first argument of each subsequent rule takes the output of the previous rule and the first argument of $t{r}_{i_1}$ is t, whence we have the following definition:

Definition 6 (Text Transformation).

A mechanical transformation, or simply transformation, of $t\in {\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ into $t^{\prime }\in {\mathcal{A}}_{\mathcal{L}}^{\ast }$, $t^{\prime }\notin {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}$, is a finite sequence of transformation rules $t{r}_{i_1},t{r}_{i_2},\dots ,t{r}_{i_l}$, $t{r}_{i_l}\in {\mathfrak{R}}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}$, $t{r}_{i_l}\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to w_{t{r}_{i_j}}\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $1\le j\le l\in {\mathbb{Z}}^{+}$, where

$$t^{\prime }=t{r}_{i_l}\left(t{r}_{i_{l-1}}\left(\dots t{r}_{i_2}\left(t{r}_{i_1}\left(t\right)\right)\dots \right)\right).$$

An example of a transformation rule is substitution which ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ can use to substitute $t_1\in {\mathcal{A}}_{\mathcal{L}}^{+}$ for all occurrences of $t_2\in {\mathcal{A}}_{\mathcal{L}}^{+}$ in $t_3\in {\mathcal{A}}_{\mathcal{L}}^{+}$ so long as the texts satisfy a finite set of syntactic requirements (cf., e.g., Ch. 18, p. 558 in [1]; Ch. IX, § 44 in [8]; Ch. 14, pp. 402–403 in [9]); Ch. 4, p. 66 in [10], for various definitions of substitution in different formal systems).

Definition 7 (Transformation Signature).

Let $t{r}_{i_1},t{r}_{i_2},\dots ,t{r}_{i_l}$, $t{r}_{i_l}\in {\mathfrak{R}}_{\widehat{\ddot{T}},\mathcal{A},\mathcal{L}}$, $l\in {\mathbb{Z}}^{+}$, be a transformation of $t\in {\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$, where

$$t^{\prime }=t{r}_{i_l}\left(t{r}_{i_{l-1}}\left(\dots t{r}_{i_2}\left(t{r}_{i_1}\left(t\right)\right)\dots \right)\right).$$

Then,

$$s={⨁}_{\mathcal{A},\mathcal{L}}\left(⊴,w_{t{r}_{i_l}},⊴,w_{t{r}_{i_{l-1}}},⊴,\dots ,w_{t{r}_{i_2}},⊴,w_{t{r}_{i_1}},⊴,t,⊵,⊵,\dots ,⊵,⊵,⊵\right),$$

where $t{r}_{i_j}\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to w_{t{r}_{i_j}}$, $1\le j\le l$, is a transformation signature of the transformation of t into $t^{\prime }$ by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$, in which case

$$(t{r}_{i_1},t{r}_{i_2},\dots ,t{r}_{i_l})\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L}}\to s$$

holds, and $(t{r}_{i_1},t{r}_{i_2},\dots ,t{r}_{i_l})$ is a signed transformation, designated by s, of t into $t^{\prime }$ by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$.

Let $t\in {\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$, $t^{\prime }\in {\mathcal{A}}_{\mathcal{L}}^{\ast }$, $t^{\prime }\notin {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}$. The predicate

$${⊢}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}(t,t^{\prime })$$

(21)

holds if, and only if, there exists a signed transformation of t into $t^{\prime }$ by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$. The relation ${⊢}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}\left(t,t^{\prime }\right)$ is clearly transitive, i.e., if

$${⊢}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}\left(t,t^{\prime }\right)\wedge {⊢}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}\left(t^{\prime },t^{″}\right),$$

then

$${⊢}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}\left(t,t^{″}\right).$$

E.g., if $\mathcal{A}$ is Unicode, $\mathcal{L}$ is Lisp, and ${\mathfrak{R}}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}$ is the standard transformation rules of Common Lisp applied deterministically by the rule application mechanism known as the read-eval-print loop (cf., e.g., Ch. 20 in [9]), then

$${⊢}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}("\left(\mathtt{p}\mathtt{r}\mathtt{o}\mathtt{g}\mathtt{n}\right(\mathtt{d}\mathtt{e}\mathtt{f}\mathtt{u}\mathtt{n}\mathtt{g}\left(\mathtt{n}\right)(+\mathtt{n}\mathtt{1})\left)\right(\mathtt{g}\mathtt{2.14}\left)\right)","\mathtt{3.14}")$$

holds, because ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ uses the Lisp progn construct that defines a sequence of Lisp operations to transform "(defun g (n) (+ n 1)) (g 2.14))" into a text of a procedure associated with the symbol named "g", substitutes "2.14" for the variable named "n" in "(+ n 1)" to obtain "(+ 2.14 1)", and then uses the transformation rules associated with the function named "+" to transform "(+ 2.14 1)" to "3.14". One can easily verify this transformation in any Lisp system that implements the Common Lisp formation and transformation rules in [9]. E.g., if ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ is GNU CLISP 2.49.60+ on Linux 18.04 LTS, and ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ is used to form

"(progn (defun g (n) (+ n 1)) (g 2.14))"

• on Unicode, then the following transformation is produced in the GNU CLISP 2.49.60+ Linux terminal, where ">" is the CLISP prompt.
• "> (progn (defun g (n) (+ n 1)) (g 2.14))
• 3.14"

Suppose ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ generates and signs

"(loop while (= 3.14 3.14) do (+ 13.7 13.7))"

for ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ to transform. ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ cannot transform the above text into another text designating a result, because the program, while formally flawless, contains an infinite loop. Consequently, although the choice and the application of a transformation rule by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ are mechanical and deterministic, and both actions take a finite amount of physical time, the transformation of a program into a text designating a result may not take a finite amount of physical time.

The next axiom states that spatiotemporally finite transformations are verifiable. If a transformation and its signature are available, another formal system can independently and deterministically verify the transformation from its signature and the set of transformation rules.

SCT Axiom 3. 

If ${⊢}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}(t,t^{\prime })$, where $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $t^{\prime }\in {\mathcal{A}}_{\mathcal{L}}^{\ast }$, and $t^{\prime }\notin {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}$, holds and s designates the transformation signature of the transformation of t into $t^{\prime }$ by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$, then, given t, $t^{\prime }$, s, and ${\mathfrak{R}}_{\widehat{\ddot{T}},\mathcal{A},\mathcal{L}}$, another formal system can deterministically verify the transformation of t into $t^{\prime }$ by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$within finite amounts of physical time and space.

SCT Axiom 3 extends the CCT axioms by introducing the concept of deterministic verifiability of transformation. We should note here that SCT Axioms 1, 2, and 3 take no position with respect to computing agents that use ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ and ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ or computing devices on which these systems are signified. Thus, neither ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ nor ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ are identical to the computing agent L in CCT Axioms A2, A4, A5, A9, and A10.

By interpretation of a program P in $\mathcal{L}$ on $\mathcal{A}$, we will mean the application of a denotational or operational semantics of $\mathcal{L}$ on $\mathcal{A}$ to P with respect to the input text t and, when applicable, to the output text $t^{\prime }$ (cf., e.g., Chapters 17, 18 in [1]; Ch. 2 in [10])). We will use the term metacomputability to refer to a denotational and operational semantics of $\mathcal{L}$ on $\mathcal{A}$ and the interpretation of programs with respect to given input and output texts and assume that metacomputability is captured by neither the formation nor the transformation rules. We will not tackle the question of whether metacomputability is algorithmic in nature and leave it outside of the scope of this article. Hence,

SCT Axiom 4. 

Metacomputability occurs outside of ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ and ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$.

4. Formation and Transformation of Instructions and Formation of Programs

Some texts formed by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ and transformed by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ designate instructions from a finite set of instruction types

$${\mathfrak{I}}_{\mathcal{A},\mathcal{L}}=\{{\tilde{\mathfrak{I}}}_1,{\tilde{\mathfrak{J}}}_2,\dots ,{\tilde{\mathfrak{I}}}_n\},n\in {\mathbb{Z}}^{+}.$$

(22)

The elements of ${\mathfrak{I}}_{\mathcal{A},\mathcal{L}}$ denote operations of a specific type, e.g., addition or subtraction of finitely many discretely finite real numbers. E.g., $\mathcal{L}$ is Lisp on Unicode, then

$$"(+\mathtt{x}\mathtt{1}\mathtt{y}\mathtt{1})","(+\mathtt{x}\mathtt{2}\mathtt{y}\mathtt{2})","(+\mathtt{x}\mathtt{3}\mathtt{y}\mathtt{3})",\dots$$

designate the same numerical operation type of addition applied to numerals designated by specific variable names. If we switch $\mathcal{L}$ to Perl on Unicode, then we obtain

$$"\$\mathtt{x}\mathtt{1}+\$\mathtt{y}\mathtt{1}","\$\mathtt{x}\mathtt{2}+\$\mathtt{y}\mathtt{2}","\$\mathtt{x}\mathtt{3}+\$\mathtt{y}\mathtt{3}",\dots$$

designating the same numerical operation type.

Definition 8 (Signifiable Instruction).

If $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ and ${\mathfrak{i}}_k\in {\tilde{\mathfrak{I}}}_{\mathfrak{j}}\in {\mathfrak{I}}_{\mathcal{A},\mathcal{L}}$, then the predicate ${\bowtie }_{\mathcal{A},\mathcal{L}}(t,{\mathfrak{i}}_k)$ holds if, and only if, t signifies ${\mathfrak{i}}_k$ in $\mathcal{L}$ on $\mathcal{A}$, in which case ${\mathfrak{i}}_k$ is a signifiable or, equivalently, designatable instruction in $\mathcal{L}$ on $\mathcal{A}$. ${\bowtie }_{\mathcal{A},\mathcal{L}}$ is symmetric.

E.g., let $x,y\in \mathbb{R}$ and L stand for Lisp, P for Perl, and U for Unicode. We have the following relations hold.

$$\begin{array}{ccc}{\bowtie }_{\mathtt{U},\mathtt{L}}(x+y,"(+\mathtt{x}\mathtt{y})")\hfill & \equiv \hfill & {\bowtie }_{\mathtt{U},\mathtt{L}}("(+\mathtt{x}\mathtt{y})",x+y)\hfill \\ {\bowtie }_{\mathtt{U},\mathtt{P}}(x+y,"\$\mathtt{x}+\$\mathtt{y};")\hfill & \equiv \hfill & {\bowtie }_{\mathtt{U},\mathtt{P}}("\$\mathtt{x}+\$\mathtt{y};",x+y)\hfill \\ {\bowtie }_{\mathtt{U},\mathtt{L}}(x-y,"(-\mathtt{x}\mathtt{y})")\hfill & \equiv \hfill & {\bowtie }_{\mathtt{U},\mathtt{L}}("(-\mathtt{x}\mathtt{y})",x-y)\hfill \\ {\bowtie }_{\mathtt{U},\mathtt{P}}("\$\mathtt{x}-\$\mathtt{y};",x-y)\hfill & \equiv \hfill & {\bowtie }_{\mathtt{U},\mathtt{P}}(x-y,"\$\mathtt{x}-\$\mathtt{y};")\hfill \\ {\bowtie }_{\mathtt{U},\mathtt{L}}(xy,"(\ast \mathtt{x}\mathtt{y})")\hfill & \equiv \hfill & {\bowtie }_{\mathtt{U},\mathtt{L}}("(\ast \mathtt{x}\mathtt{y})",xy)\hfill \\ {\bowtie }_{\mathtt{U},\mathtt{P}}("\$\mathtt{x}\ast \$\mathtt{y};",xy)\hfill & \equiv \hfill & {\bowtie }_{\mathtt{U},\mathtt{P}}("\$\mathtt{x}\ast \$\mathtt{y};",xy)\hfill \\ {\bowtie }_{\mathtt{U},\mathtt{L}}\left(x/y,"\right(/\mathtt{x}\mathtt{y})")\hfill & \equiv \hfill & {\bowtie }_{\mathtt{U},\mathtt{L}}("/\mathtt{x}\mathtt{y})",x/y)\hfill \\ {\bowtie }_{\mathtt{U},\mathtt{P}}("\$\mathtt{x}/\$\mathtt{y};",x/y)\hfill & \equiv \hfill & {\bowtie }_{\mathtt{U},\mathtt{P}}\left(x/y,"\$\mathtt{x}/\$\mathtt{y};"\right)\hfill \end{array}$$

The elements of ${\mathfrak{I}}_{\mathcal{A},\mathcal{L}}$ vary from alphabet to alphabet and from programming formalism to programming formalism due to the software-hardware duality principle of computer science: specific instructions are written to run on devices designed to perform those and only those instructions. E.g., while one formalism may restrict its set of instructions to addition and subtraction of natural numbers, another formalism may be designed for a device that adds, subtracts, multiplies, and divides discretely finite real numbers.

Definition 9 (Formable Instruction).

If ${\mathfrak{i}}_k\in {\tilde{\mathfrak{I}}}_{\mathfrak{j}}\in {\mathfrak{I}}_{\mathcal{A},\mathcal{L}}$, then

$$\begin{array}{cccccc}{Ⅎ}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}({\mathfrak{i}}_k,t)\hfill & \equiv \hfill & t\in {\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\hfill & \wedge \hfill & {\bowtie }_{\mathcal{A},\mathcal{L}}(t,{\mathfrak{i}}_k),\hfill & \end{array}$$

in which case ${\mathfrak{i}}_k$ is an instruction in $\mathcal{L}$ on $\mathcal{A}$ formable or, equivalently, generatable by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$. ${Ⅎ}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ is symmetric.

Definition 10 (Transformable Instruction).

If ${\mathfrak{i}}_k\in {\tilde{\mathfrak{I}}}_{\mathfrak{j}}\in {\mathfrak{I}}_{\mathcal{A},\mathcal{L}}$, then

$$\begin{array}{ccccc}{⟲}_{\mathcal{A},\mathcal{L}}({\mathfrak{i}}_k,t,t^{\prime })\hfill & \equiv \hfill & {Ⅎ}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}({\mathfrak{i}}_k,t)\hfill & \wedge \hfill & {⊢}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}\left(t,t^{\prime }\right),t\in {\mathcal{A}}_{\mathcal{L}}^{+},t^{\prime }\notin {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}},\hfill \end{array}$$

in which case, ${\mathfrak{i}}_k$ is an instruction in $\mathcal{L}$ on $\mathcal{A}$ transformable by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$.

The next axiom is rooted in the existence of general programming languages such as Lisp and Perl.

SCT Axiom 5. 

There exists $\mathcal{L}$ on $\mathcal{A}$ in which the instruction types in

Table A1. Instruction types in ${\mathfrak{I}}_{\mathcal{A},\mathcal{L}}$ spatiotemporally finitely formable and transformable in programming formalisms that satisfy SCT Axiom 5. The subscripts $\mathcal{A}$ and $\mathcal{L}$ in the right column are omitted for brevity.

Instruction Type	Semantics
$\mathtt{S}\mathtt{E}\mathtt{T}(v,t)$, $v\in {\mathcal{A}}^{+}$, $t\in {\mathcal{A}}^{\ast }$	set the value of the variable named v to t
$\mathtt{A}\mathtt{D}\mathtt{D}(t_1,\dots ,t_k)$, $t_i\in {\mathcal{A}}^{+}$, $1\le i\le k$, $k>1$	$t_i\leftarrow (\approx )\to r_i\in \mathbb{R}$∧ $Ⅎ({\sum }_{i=1}^k{r}_i$, t) ∧$⟲({\sum }_{i=1}^k{r}_i,t,t^{\prime })$∧ $t^{\prime }\leftarrow (\approx )\to {\sum }_{i=1}^k{r}_i$
$\mathtt{S}\mathtt{U}\mathtt{B}(t_1,\dots ,t_k)$, $t_i\in {\mathcal{A}}^{+}$,$1\le i\le k$, $k>1$	$t_i\leftarrow (\approx )\to r_i\in \mathbb{R}$∧ $Ⅎ(r_1-r_2-\dots -r_k,t)$∧ $⟲(r_1-r_2\dots -r_k,t,t^{\prime })$∧ $t^{\prime }\leftarrow (\approx )\to r_1-\dots -r_k$
$\mathtt{M}\mathtt{U}\mathtt{L}(t_1,\dots ,t_k)$, $t_i\in {\mathcal{A}}^{+}$, $1\le i\le k$, $k>1$	$t_i\leftarrow (\approx )\to r_i\in \mathbb{R}$∧ $Ⅎ({\prod }_{i=1}^k{r}_i,t)$∧ $⟲({\prod }_{i=1}^k{r}_i,t,t^{\prime })$∧ $t^{\prime }\leftarrow (\approx )\to {\prod }_{i=1}^k{r}_i$
$\mathtt{D}\mathtt{I}\mathtt{V}(t_1,t_2)$, $t_i\in {\mathcal{A}}^{+}$,$1\le i\le 2$	$t_1\leftarrow (\approx )\to r_1\in \mathbb{R}$∧ $t_2\leftarrow (\approx )\to r_2\in \mathbb{R}$∧$r_2\ne 0$∧ $Ⅎ\left({\displaystyle \frac{r_1}{r_2}},t\right)$∧$⟲\left({\displaystyle \frac{r_1}{r_2}},t,t^{\prime }\right)$∧ $t^{\prime }\leftarrow (\approx )\to {\displaystyle \frac{r_1}{r_2}}$
$\mathtt{C}\mathtt{O}\mathtt{N}\mathtt{C}(t_1,\dots ,t_k)$, $t_i\in {\mathcal{A}}^{+}$,$1\le i\le k$, $k>1$	$Ⅎ\left(⨁{|}_{i=1}^k{t}_i,t\right)$∧ $⟲\left(⨁{|}_{i=1}^k{t}_i,t,t^{\prime }\right)$∧ $t^{\prime }={⨁}_{\mathcal{A}}{|}_{i=1}^k{t}_i$
$\mathtt{S}\mathtt{U}\mathtt{B}\mathtt{S}\mathtt{T}(t,v_1,t_1,\dots ,v_k,t_k)$, $t,t_i,v_i\in {\mathcal{A}}^{+}$, $1\le i\le k$, $k>1$	return the text obtained by substituting in t $t_1$ for $v_1$, …, $t_k$ for $v_k$.

in the Appendix A are spatiotemporally finitely formable and transformable.

SCT Axiom 5 agrees with CCT Axiom A9 in that the computational capacity of the computing agent is always finite, i.e., any agent, physical or abstract, can execute only a finite number of instruction types. However, SCT Axiom 5 differs from CCT Axiom A9, because it makes it explicit that the computational capacity of a computing agent is a characteristic of not just the computing agent, but also of $\mathcal{L}$ on $\mathcal{A}$. In this sense, SCT Axiom 5 offers yet another take on the software-hardware duality principle: programming formalisms are designed for computational devices and computational devices are constructed to perform computations prescribed by programs signified with specific formalisms. We will hereafter refer to a tuple-sufficient $\mathcal{L}$ on $\mathcal{A}$ that satisfies SCT Axiom 5 as minimally adequate. E.g., Lisp, Perl, and C/C++ Unicode are minimally adequate.

Definition 11 (Formable Program).

Let $\mathcal{L}$ on $\mathcal{A}$ be minimally adequate. Let $m,n,q\in {\mathbb{Z}}^{+}$, $1\le j\le n$. If ${\mathfrak{z}}_1\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to 1$, …, ${\mathfrak{z}}_n\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to n$ and $(\forall j)(\exists m)\left\{{⟲}_{\mathcal{A},\mathcal{L}}({\mathfrak{i}}_m,t_{i_j},t_{i_j}^{\prime })\wedge {\mathfrak{i}}_m\in {\tilde{\mathfrak{I}}}_{\mathfrak{q}}\wedge {\tilde{\mathfrak{I}}}_{\mathfrak{q}}\in {\mathfrak{I}}_{\mathcal{A},\mathcal{L}}\right\}$, then

$$P_k={⨁}_{\mathcal{A},\mathcal{L}}\left(⊴,{\mathfrak{z}}_1,\mp ,t_{i_1},⊵,\mp ,\dots ,\mp ⊴,{\mathfrak{z}}_n,\mp ,t_{i_n}⊵\right),$$

where $t_{i_j}\in {\mathfrak{S}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$, is a program formable by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$. The function $\mathtt{n}\mathtt{i}\left(P_k\right)=n$ denotes the number of the instructions in $P_k$. The predicate

$${⋋}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\left(P_k\right)$$

holds if, and only if, $P_k$ is formable by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$. The set

$${\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}=\left\{P_k\in {\mathcal{A}}_{\mathcal{L}}^{+}|{⋋}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\left(P_k\right)\right\}$$

is the enumerably infinite set of programs in $\mathcal{L}$ on $\mathcal{A}$ formable by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$.

Thus, $P_k$ is formable by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ or, in symbols, $P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ if, and only if, it is a finite concatenation of the enumerated formable and transformable instruction texts in $\mathcal{L}$ on $\mathcal{A}$. E.g., $P_j$ in Figure 1 is a Lisp program on Unicode formable by the GNU CLISP 2.49.60+ disassembler.

Definition 11 allows us to give a programmatic illustration of SCT Axiom 3 in Figure 2, where the bottom box contains a Lisp program on Unicode formed by the GNU CLISP 2.49.60+ disassembler that no Lisp transformer ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ whose ${\mathfrak{R}}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}$ consists of the standard transformation rules of the Lisp read-eval-print loop can transform into a text on Unicode within a finite amount of physical time. However, each individual enumerated instruction text of $P_k$ in Figure 2, is transformable by ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ within a finite amount of physical time.

5. Program States and Computations

To transform $P_j\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$ deterministically into an output text designating the result of the computation formalized in $P_j$ on a singified input, ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ goes through a sequence of states of $P_j$. Hence,

Definition 12 (Program State).

Let $P_j\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$. Then, $\sigma \in {\mathcal{A}}_{\mathcal{L}}^{+}$ is a valid state of $P_j$ if, and only if, ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ can determine from σ: (a) the numeral designating the number $1\le i\le \mathtt{n}\mathtt{i}\left(P_j\right)+1$ of the instruction in $P_j$ to perform; (b) the numeral designating the total number of the instructions of $P_j$ already performed; (c) the texts designating the type and value of every variable name in $P_j$, including the type and value of the unique output variable denoted by ${\square }_j$; (d) the text $P_j$; and (e) for every variable name in σ, ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ can assign exactly one type and exactly one value. If σ is a valid state, then $P_j$ contained in σ is referred to as $P_j$ of σ, while σ is referred to as σ of $P_j$.

E.g., a valid state ${\sigma }_{i_1}$ of $P_j$ in Figure 1, constructed according to the Common Lisp syntactic conventions, is given in (23), where the symbol "…" in the right-hand side of the equality designates the text of the lines 2–18 and ${\square }_j="\mathtt{2}"$, i.e., "2" is the numeral designating the number of the output register in this case.

$$\begin{array}{ccc}{\sigma }_{i_1}\hfill & =\hfill & "\left(\mathtt{1}\mathtt{0}\right(\mathtt{n}\mathtt{a}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{a}\mathtt{l}\text{-}\mathtt{n}\mathtt{u}\mathtt{m}\mathtt{b}\mathtt{e}\mathtt{r}\text{-}\mathtt{p}\mathtt{n}\left)\right(\mathtt{n}\mathtt{12})"{⨁}_{\mathcal{A},\mathcal{L}}\hfill \\ \hfill & \hfill & "\left(\mathtt{n}\mathtt{a}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{a}\mathtt{l}\text{-}\mathtt{n}\mathtt{u}\mathtt{m}\mathtt{b}\mathtt{e}\mathtt{r}\text{-}\mathtt{p}\mathtt{2}\right)\left(\mathtt{2}\mathtt{0}\right)"{⨁}_{\mathcal{A},\mathcal{L}}\hfill \\ \hfill & \hfill & "("{⨁}_{\mathcal{A},\mathcal{L}}{P}_j{⨁}_{\mathcal{A},\mathcal{L}}")"{⨁}_{\mathcal{A},\mathcal{L}}")"\hfill \\ \hfill & =\hfill & "\left(\mathtt{1}\mathtt{0}\right(\mathtt{n}\mathtt{a}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{a}\mathtt{l}\text{-}\mathtt{n}\mathtt{u}\mathtt{m}\mathtt{b}\mathtt{e}\mathtt{r}\text{-}\mathtt{p}\mathtt{n}\left)\right(\mathtt{n}\mathtt{12})"{⨁}_{\mathcal{A},\mathcal{L}}\hfill \\ \hfill & \hfill & "\left(\mathtt{n}\mathtt{a}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{a}\mathtt{l}\text{-}\mathtt{n}\mathtt{u}\mathtt{m}\mathtt{b}\mathtt{e}\mathtt{r}\text{-}\mathtt{p}\mathtt{2}\right)\left(\mathtt{2}\mathtt{0}\right)"{⨁}_{\mathcal{A},\mathcal{L}}\hfill \\ \hfill & \hfill & "\left(\mathtt{1}\right(\mathtt{J}\mathtt{M}\mathtt{P}\mathtt{L}\mathtt{7})\dots \mathtt{19}(\mathtt{S}\mathtt{K}\mathtt{I}\mathtt{P}\&\mathtt{R}\mathtt{E}\mathtt{T}\mathtt{2}\left)\right))"\hfill \\ \hfill & =\hfill & "\left(\mathtt{1}\mathtt{0}\right(\mathtt{n}\mathtt{a}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{a}\mathtt{l}\text{-}\mathtt{n}\mathtt{u}\mathtt{m}\mathtt{b}\mathtt{e}\mathtt{r}\text{-}\mathtt{p}\mathtt{n}\left)\right(\mathtt{n}\mathtt{12})\hfill \\ \hfill & \hfill & \left(\mathtt{n}\mathtt{a}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{a}\mathtt{l}\text{-}\mathtt{n}\mathtt{u}\mathtt{m}\mathtt{b}\mathtt{e}\mathtt{r}\text{-}\mathtt{p}\mathtt{2}\right)\left(\mathtt{2}\mathtt{0}\right)\hfill \\ \hfill & \hfill & \left(\mathtt{1}\right(\mathtt{J}\mathtt{M}\mathtt{P}\mathtt{L}\mathtt{7})\dots \mathtt{19}(\mathtt{S}\mathtt{K}\mathtt{I}\mathtt{P}\&\mathtt{R}\mathtt{E}\mathtt{T}\mathtt{2}\left)\right))"\hfill \end{array}$$

(23)

${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ mechanically obtains from ${\sigma }_{i_1}$ in (23) the following elements:

• "1" — designates the instruction number to perform;
• "0" — designates the total number of instructions already performed;
• "(natural-number-p n)" — designates the type of the input variable "n";
• "(n 12)" — designates that the current value of "n" is "12" that, according to the standard decimal notation in Lisp on Unicode, designates the natural number 12;
• "(natural-number-p 2)"—designates the type specification of the output variable;
• "(2 0)" — designates that the current value of the output variable named "2" is "0";
• "(1 (JMP L7) ... 19 (SKIP&RET 2))"— designates that the nineteen instructions of $P_j$ are enumerated with "1", "2", …, "19" that designate the natural numbers 1, 2, …, 19 in Lisp on Unicode.

Thus, by Definition 12, $P_j$ in Figure 1 is the program of ${\sigma }_{i_i}$ in (23) and ${\sigma }_{i_1}$ is a valid state of $P_j$.

Definition 12 and valid program states like the state in (23) imply the existence of several predicates and functions that we now proceed to define to subsequently formalize the concept of transformation of programs in ${\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$.

The function in (24) (VLDS abbreviates Valid State) returns "1", if $\sigma$ is a valid program state, and "0" otherwise.

$$\begin{array}{ccc}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}^{+}\mapsto \{"\mathtt{0}","\mathtt{1}"\};\hfill & \hfill & \\ \\ {\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}"\mathtt{1}"\hfill & \mathrm{if}\sigma \mathrm{is}\mathrm{a}\mathrm{valid}\mathrm{program}\mathrm{state};\hfill \\ "\mathtt{0}"\hfill & \mathrm{otherwise},\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(24)

where "1" is arbitrarily interpreted as True and "0" as False. E.g., if ${\sigma }_1$ is a valid program state and ${\sigma }_2$ is not, then

$$\begin{array}{ccc}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_1\right)\hfill & \leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to \hfill & 1;\hfill \\ \\ {\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_2\right)\hfill & \leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to \hfill & 0,\hfill \end{array}$$

(25)

which can be, respectively, abbreviated as

$$\begin{array}{ccc}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_1\right)\hfill & =\hfill & 1;\hfill \\ \\ {\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_2\right)\hfill & =\hfill & 0.\hfill \end{array}$$

(26)

The function in (27) (PROG abbreviates Program) returns the text of the program of $\sigma$, if the latter is valid, and $t_{err}$ otherwise.

$$\begin{array}{ccc}{\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}t\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(27)

where t is the program of $\sigma$, $t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}$. For example, if ${\sigma }_{i_1}$ is given in (23) and $P_j$ is given in Figure 1, then ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)$ = $P_j$.

The function in (28) (NPIS abbreviates Number of Program Instructions) returns the numeral designating the number of the instructions in ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ if $\sigma$ is valid and $t_{err}$ otherwise.

$$\begin{array}{ccc}{\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}t\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathtt{w}\mathtt{h}\mathtt{e}\mathtt{r}\mathtt{e}t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to n\in {\mathbb{Z}}^{+},t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}.\hfill & \hfill & \end{array}$$

(28)

E.g., for ${\sigma }_{i_1}$ in (23), ${\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)$ = $"\mathtt{19}"\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to 19$. If, for some valid $\sigma$, ${\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)=t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ and $t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to z\in {\mathbb{Z}}^{+}$, we abbreviate ${\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to z$ to ${\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=z=\mathtt{n}\mathtt{i}\left({\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\right)$ (cf. (11)).

The function in (29) (CINS abbreviates Current Instruction) returns the numeral designating the number of the instruction to execute in ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is valid, and $t_{err}$ otherwise.

$$\begin{array}{ccc}{\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}t\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathtt{w}\mathtt{h}\mathtt{e}\mathtt{r}\mathtt{e}t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to n\in {\mathbb{Z}}^{+},t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}.\hfill & \hfill & \end{array}$$

(29)

E.g., for ${\sigma }_{i_1}$ in (23), ${\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)$ = $"\mathtt{1}"\leftarrow (=)\to 1\in {\mathbb{Z}}^{+}$ or, more succinctly, ${\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1$.

The function in (30) is a side-effect function that sets the value returned by ${\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}$ to the numeral t.

$$\begin{array}{ccc}{\mathtt{S}\mathtt{E}\mathtt{T}\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}(\sigma ,t):{\mathcal{A}}_{\mathcal{L}}^{+}\times {\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{S}\mathtt{E}\mathtt{T}\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}(\sigma ,t)=\left\{\begin{array}{cc}{\sigma }^{\prime }\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1\wedge \hfill \\ \hfill & t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to z\wedge \hfill \\ \hfill & 1\le z\le \mathtt{n}\mathtt{i}\left({\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\right)+1;\hfill \\ t_{err}\hfill & \mathrm{otherwise}.\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathtt{w}\mathtt{h}\mathtt{e}\mathtt{r}\mathtt{e}{\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }^{\prime }\right)=t,t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}.\hfill \end{array}$$

(30)

The function in (31) (TOTI abbreviates Total Instructions) returns the numeral designating the total number of the transformed (or, equivalently, performed or executed) instruction texts in ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ if $\sigma$ is valid and $t_{err}$ otherwise.

$$\begin{array}{ccc}{\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}t\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathtt{w}\mathtt{h}\mathtt{e}\mathtt{r}\mathtt{e}t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to n\in {\mathbb{Z}}^{+},t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}.\hfill & \hfill & \end{array}$$

(31)

E.g., for ${\sigma }_{i_1}$ in (23), ${\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)$ = $"\mathtt{0}"\leftarrow (=)\to 0$. If, for some valid $\sigma$, ${\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ and $t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to z\in {\mathbb{Z}}^{+}$, we abbreviate ${\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=t$ $\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to z$ to ${\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=z$.

The next function in (32) (VVRS abbreviates Values of Variables) returns a marked concatenation designating a tuple of 2-tuples, each of which designates a variable and its numerical value. Toward that end, we let $\sigma$ be valid and let ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ contain $l>0$ variables, including the unique output variable designated by ${\square }_j$. We let ${\mathbf{x}}_i\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $1\le i\le l$, designate the i-th variable and ${\mathbf{z}}_i\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $1\le i\le l$, designate the variable’s numerical value, i.e., ${\mathbf{z}}_i\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r\in \mathbb{R}$, $1\le i\le l$. We let ⊴, ⊵, $\mp \in {\mathcal{A}}_{\mathcal{L}}^{+}$ designate the beginning of a tuple, the end of a tuple, and the separator sign, respectively. With these conventions in place, the function in (32) returns the text designating the tuple of 2-tuples, each of which designates a variable and its numerical value in ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, when $\sigma$ is valid, and $t_{err}$ otherwise.

$$\begin{array}{ccc}{\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}t\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathtt{w}\mathtt{h}\mathtt{e}\mathtt{r}\mathtt{e}t={⨁}_{\mathcal{A},\mathcal{L}}\left(⊴,t_1,\mp ,t_2,\mp ,\dots ,\mp ,t_l,⊵\right),t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}},\hfill & \hfill & \\ t_i={⨁}_{\mathcal{A},\mathcal{L}}\left(⊴,{\mathbf{x}}_i,\mp ,{\mathbf{z}}_i⊵\right),1\le i\le l,l>0.\hfill & \hfill & \end{array}$$

(32)

E.g., if we recall that in Lisp $⊴="("$, $⊵=")"$, and ∓ is any non-empty sequence of white space Unicode characters, then ${\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)$ = $"\left(\left(n2\right)\left({\square }_{j}0\right)\right)"$.

The function in (33) (OUTV abbreviates Output Value) returns the numeral designating the value of the output variable of ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is valid, and $t_{err}$ otherwise.

$$\begin{array}{ccc}{\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}t\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathtt{w}\mathtt{h}\mathtt{e}\mathtt{r}\mathtt{e}t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r\in \mathbb{R},t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}.\hfill & \hfill & \end{array}$$

(33)

E.g., ${\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)$ = $"\mathtt{0}"$ $\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to 0$. If, for some valid $\sigma$, ${\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ and $t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r\in \mathbb{R}$, we abbreviate ${\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=t$ $\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r$ to ${\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=r$. ${\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}$ takes the output of ${\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ (i.e., ${\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left({\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\right)$) and returns the numeral designating the value of the output variable in the tuple so long as $\sigma$ is valid.

The function in (34) (VV abbreviates Variable Value) returns the text designating the value of the i-th variable in ${\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ and $t_{err}$ otherwise.

$$\begin{array}{ccc}{\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}(\sigma ,t):{\mathcal{A}}_{\mathcal{L}}^{+}\times {\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}(\sigma ,t)=\left\{\begin{array}{cc}{t}^{\prime }\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathtt{w}\mathtt{h}\mathtt{e}\mathtt{r}\mathtt{e}t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to i,1\le i\le l,t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}},t^{\prime }\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r\in \mathbb{R}.\hfill & \hfill & \end{array}$$

(34)

We now define a useful variant of ${\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}$ to obtain the numerals designating the values of the input variables for any program that takes $k\in {\mathbb{Z}}^{+}$ input texts. If ${\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ contain $l>0$ variable-value tuples, of which the first $0<k<l$ tuples, by convention, designate the names and values of the input variables. The function in (35) (IVV abbreviates Input Variable Value) returns the numeral designating the value of the i-th input variable in ${\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is valid, and $t_{err}$ otherwise.

$$\begin{array}{ccc}{\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}(\sigma ,t):{\mathcal{A}}_{\mathcal{L}}^{+}\times {\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}(\sigma ,t)=\left\{\begin{array}{cc}{t}^{\prime }\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathtt{w}\mathtt{h}\mathtt{e}\mathtt{r}\mathtt{e}t\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to i,1\le i\le l,t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}},t^{\prime }\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r\in \mathbb{R}.\hfill & \hfill & \end{array}$$

(35)

The function in (36) (NXTS abbreviates Next State) returns the next valid program state of $\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}{\left(\sigma \right)}_{\mathcal{A},\mathcal{L}}$ if $\sigma$ is valid and an error message otherwise.

$$\begin{array}{ccc}{\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \left\{t_{err}\right\};\hfill & \hfill & \\ \\ {\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}t{r}_j\left(\sigma \right)\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1;\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0,\hfill \end{array}\right.\hfill & \hfill & \\ \\ t_{err}\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}},t{r}_j\in {\mathfrak{R}}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}.\hfill & \hfill & \end{array}$$

(36)

This function looks at the current instruction and deterministically constructs the next valid state ${\sigma }^{\prime }$ from the type of the instruction and the variables used in the instruction in the current program state $\sigma$ so long as that latter is valid, or, equivalently, it transforms $\sigma$ into ${\sigma }^{\prime }$. The choice of the transformation rule $t{r}_j$ is determined by $\sigma$. Since the next valid state $t{r}_j\left(\sigma \right)={\sigma }^{\prime }$ (the notation $t{r}_j\left(\sigma \right)={\sigma }^{\prime }$ denotes the application of $t{r}_j$ to $\sigma$ to compute ${\sigma }^{\prime }$) necessarily depends on the specifics of $\mathcal{L}$ on $\mathcal{A}$, we offer an intuitive and abstract outline of how ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ uses ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}$ to transform $\sigma$ to ${\sigma }^{\prime }$.

${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ transforms the text of the instruction whose number is designated by ${\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ according to its type (cf. Table A1) and then (1) updates, if necessary, the value numerals of the variable names involved in this instruction, i.e., updates the text returned by ${\mathtt{V}\mathtt{V}\mathtt{R}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$; (2) updates the numeral designating the number of the instruction to execute in ${\sigma }^{\prime }$; and (3) updates the numeral designating the total number of the instructions (or, to be more exact, instruction texts) of ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ transformed thus far to the numeral designating the value of the total number incremented by 1. Per Definition 6, if $\sigma$ is valid, then we define ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}^0\left(\sigma \right)=\sigma$ and, for $l\in {\mathbb{Z}}^{+}$, define

$${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}^l\left(\sigma \right)=t{r}_{i_l}\left(t{r}_{i_{l-1}}\left(\dots t{r}_{i_2}\left(t{r}_{i_1}\left(\sigma \right)\right)\dots \right)\right)={\sigma }^{\prime },t{r}_{i_j}\in {\mathfrak{R}}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}},1\le j\le l.$$

(37)

Thus, we have

Lemma 1. 

Let $\mathcal{L}$ on $\mathcal{A}$ be minimally adequate and let $\mathcal{A}$ contain the signs of the standard decimal notation. If ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)={\sigma }^{\prime }\ne t_{err}$, then ${\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ $\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to$ n and ${\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left({\sigma }^{\prime }\right)$ $\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to$ $n+1$, $n\in \mathbb{N}$.

Let us assume that a minimally adequate $\mathcal{L}$ on $\mathcal{A}$, like many modern programming languages, has at least four types of numerical instructions on the numerals in the standard decimal notation: addition, multiplication, subtraction, and division applicable to finitely many discretely finite real numbers. Then, if the current instruction is addition, the numerals designating the values of two or more variable names are added and the numeral of the sum is assigned to a variable name, the numeral value of which is accordingly updated in ${\sigma }^{\prime }$. The numerals designating the values of the variable names that are not affected by the instruction text, remain in ${\sigma }^{\prime }$ exactly as they are in $\sigma$. The transformation of the multiplication and subtraction instruction types is performed analogously. The transformation of the division instructions is performed with the convention that the division by zero (or, to be more exact, by the numeral designating 0 in $\mathcal{L}$ on $\mathcal{A}$) results in an error message.

If $\mathcal{L}$ on $\mathcal{A}$ has the assignment instruction type whereby the value of a variable is set to a value, then the numeral value of that variable’s name is accordingly updated in ${\sigma }^{\prime }$. If $\mathcal{L}$ has a GOTO/JUMP instruction type and the current instruction prescribes a jump to a label (e.g., "(JMP L7)" in $P_j$ in Figure 1 prescribes a jump to the label "L7"), then no updates of the variable numeral values are performed, and the numeral of the next instruction to execute in ${\sigma }^{\prime }$ is set to the numeral of the program line with that label. If multiple instruction texts of ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ have the same label, the numeral of the instruction to execute in ${\sigma }^{\prime }$ is set to the numeral designating the smallest such number. If the current instruction calls for a jump to a label that does not exist in ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, then the numeral designating the number of the instruction to execute in ${\sigma }^{\prime }$ is set to the numeral designating ${\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)+1$. The transformation of a dispatch to a numeral designating an instruction number is performed analogously to the transformation of a dispatch to a label. Thus,

Lemma 2. 

If ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ = ${\sigma }^{\prime }\ne t_{err}$, then ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)={\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left({\sigma }^{\prime }\right)$.

Associated with the execution of $P\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ are two states: a program start state and a program end state. The predicate in (38) (STARTS abbreviates Start State) returns "1" if $\sigma$ is a valid program start state and "0" otherwise.

$$\begin{array}{ccc}{\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}^{+}\mapsto \{"\mathtt{0}","\mathtt{1}"\};\hfill & \hfill & \\ \\ {\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}"\mathtt{1}"\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1\wedge {\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=1\wedge \hfill \\ \hfill & {\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=0;\hfill \\ "\mathtt{0}"\hfill & \mathrm{otherwise}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(38)

The predicate in (39) (ENDS abbreviates End State) returns "1" if $\sigma$ is a valid end state and "0" otherwise.

$$\begin{array}{ccc}{\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto \{"\mathtt{0}","\mathtt{1}"\};\hfill & \hfill & \\ \\ {\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)=\left\{\begin{array}{cc}"\mathtt{1}"\hfill & \mathrm{if}{\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)={\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)+1;\hfill \\ "\mathtt{0}"\hfill & \mathrm{otherwise}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(39)

Suppose that ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ starts in a valid start state ${\sigma }_{i_1}\in {\mathfrak{S}}_{{\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}}$ such that $P_k={\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)$, and then uses a sequence of its transformation rules through ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}$ (cf. Equation (37)) to transform ${\sigma }_{i_1}$ into ${\sigma }_{i_2}$, and so on, thus generating a finite sequence of states ${\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}$, $1<l\in {\mathbb{Z}}^{+}$, where ${\sigma }_{i_l}$ and ${\sigma }_{i_l}$ are valid start and end states of $P_k$, respectively, then ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}^{l-1}\left({\sigma }_{i_1}\right)={\sigma }_{i_l}$. Hence,

Definition 13 (Signifiable Computation).

A signifiable computation of $P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$ is a finite sequence of valid program states ${\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}$, $1\le j<l$, $1<l\in {\mathbb{Z}}^{+}$, ${\sigma }_{i_1}\in {\mathfrak{S}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$, such that

$$\begin{array}{cccc}{\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_1}\right)=1\hfill & \wedge \hfill & {\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_l}\right)=1\hfill & \wedge \hfill \\ {\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_j}\right)={\sigma }_{i_{j+1}}\hfill & \wedge \hfill & {\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_l}\right)=P_k.\hfill \end{array}$$

The predicate

$${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}))$$

holds if, and only if, ${\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}$ is a signifiable computation of $P_k$ in $\mathcal{L}$ on $\mathcal{A}$.

Hence,

Lemma 3. 

Let ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}))$. Then, ${⊢}_{{\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}}({\sigma }_{i_j},{\sigma }_{i_{j+1}}),1\le j<l\in {\mathbb{Z}}^{+}$, and ${⊢}_{{\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}}({\sigma }_{i_1},{\sigma }_{i_l})$.

6. Transformation of Programs

Definition 14 (Transformation of Programs). 

Let $l\in {\mathbb{Z}}^{+}$, $1\le j\le n\in {\mathbb{Z}}^{+}$, $t_j\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$, and ${\sigma }_{i_1}\in {\mathfrak{S}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$. Then, $P_k$ is transformable by ${\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}$ from ${\sigma }_{i_1}$, which is denoted as ${⋌}_{{\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}}(P_k,{\sigma }_{i_1})$, if, and only if, $(\exists {\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n}){\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n}))$.

The next lemma follows from Definition 14 and Lemmas 2 and 3.

Lemma 4. 

$P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$ and ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}))$, $1<l\in {\mathbb{Z}}^{+}$. Then, the following statements are equivalent, for $1\le j<l$:

• ${⋌}_{{\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}}(P_k,{\sigma }_{i_1})$;
• ${⊢}_{{\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}}({\sigma }_{i_j},{\sigma }_{i_j+1})$;
• ${⊢}_{{\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}}({\sigma }_{i_1},{\sigma }_{i_l})$;
• ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}^{l-1}\left({\sigma }_{i_1}\right)={\sigma }_{i_l}\ne t_{err}$.

A question naturally arises whether it is possible for ${\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}$ to transform, in finitely many steps, a valid start state ${\sigma }_{i_1}$ of a program $P_k$ into another valid state of $P_k$ when $P_k$ is not formed by ${\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}$. In other words, can ${⋌}_{{\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}}(P_k,{\sigma }_{i_j})$ hold if $\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}\left({\sigma }_{i_j}\right)=P_k$ but $P_k\notin {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$? Definition 11 implies a negative answer, because for the program to be transformable by ${\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}$ from a valid start state ${\sigma }_{i_1}$, every enumerated instruction text in $P_k$ must be transformable. ${\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}$ and ${\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}$ are co-dependent in that ${\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}$ cannot place in a program an instruction text that ${\widehat{\dot{T}}}_{\mathcal{A},\mathcal{L}}$ cannot transform.

E.g., consider a Lisp program by Steele in Figure 3. This text is formally impeccable insomuch as it is formed according to the Lisp syntactic conventions. However, the program is not transformable unless one supplies the definitions of the functions stroke, stuck, make-oar, winded, and dream, all of which, in turn, can be converted by the Lisp disassembler into finite sequences of instruction texts that ${\widehat{\ddot{T}}}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}$ can transform with the rules of the read-eval-print loop from a valid start state for this program. For example, if ${\widehat{\ddot{T}}}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}$ is GNU CLISP 2.49.60+, then the attempted transformation of "(life)" results in

$$t_{err}="\ast \ast \ast \text{-}\mathtt{E}\mathtt{V}\mathtt{A}\mathtt{L}:\mathtt{u}\mathtt{n}\mathtt{d}\mathtt{e}\mathtt{f}\mathtt{i}\mathtt{n}\mathtt{e}\mathtt{d}\mathtt{f}\mathtt{u}\mathtt{n}\mathtt{c}\mathtt{t}\mathtt{i}\mathtt{o}\mathtt{n}\mathtt{R}\mathtt{O}\mathtt{W}"\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}},$$

whence

$$\neg {⋌}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}("\left(\mathtt{l}\mathtt{i}\mathtt{f}\mathtt{e}\right)",{\sigma }_{i_1}).$$

The above observations lead to the next axiom.

SCT Axiom 6. 

There exists a minimally adequate $\mathcal{L}$ on $\mathcal{A}$, where any $P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ is reducible to an enumerated sequence of instruction texts from a finite set of transformable instruction types that are irreducible to any other instruction types.

SCT Axiom 6 does not appear to have a direct equivalent among the CCT axioms. It is related to CCT Axiom A9 insomuch as it reflects the fact that the computational capacity of any computing agent is finite. This axiom reflects a common fact of modern compiler theory: all higher level constructs (e.g., function definitions and macros) of programming languages are reduced to a finite set of irreducible (also known as primitive) instructions (cf., e.g., Ch. 3 in [1]). Therefore, for any $\mathcal{L}$ on $\mathcal{A}$ compliant with SCT Axiom 6, we can assume that a $P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ is a concatenation of enumerated instruction texts, each of which designates an irreducible instruction type. We will hereafter assume that $\mathcal{L}$ on $\mathcal{A}$ is minimally adequate and satisfies SCT Axiom 6.

7. Signifiable Computability of Functions

To characterize functions that are signifiably computable in principle, we remove memory limitations imposed on computation by an FMD $\mathcal{D}$, which is formalized in our next definition.

Definition 15 (Signifiably Computable Function).

A total function $f:{\mathbb{R}}^m\mapsto \mathbb{R}$ is signifiably computable in $\mathcal{L}$ on $\mathcal{A}$ if, and only if, there exists $P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$ and, for $1<n\in {\mathbb{Z}}^{+}$, $1\le j\le m\in {\mathbb{Z}}^{+}$, $(r_1,\dots ,r_m)\in {\mathbb{R}}^m$,

$$(\forall (r_1,\dots ,r_m)\in dom\left(f\right))f(r_1,\dots ,r_m)=r$$

if, and only if,

$$\begin{array}{cc}(\exists ({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n})){\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n}))\hfill & \wedge \hfill \\ {\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}({\sigma }_{i_1},t_{i_j})\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r_j\hfill & \wedge \hfill \\ j\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t_{i_j}\hfill & \wedge \hfill \\ {\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_n}\right)\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r.\hfill & \end{array}$$

The predicate ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L}}(f,P_k)$ holds if, and only if, f is signifiably computable in $\mathcal{L}$ on $\mathcal{A}$ and $P_k$ is a program that signifies f in $\mathcal{L}$ on $\mathcal{A}$.

We proceed to characterize functions that are signifiably partially computable in principle.

Definition 16 (Signifiably Partially Computable Function).

A partial function $f:{\mathbb{R}}^m\mapsto \mathbb{R}$ is signifiably partially computable in $\mathcal{L}$ on $\mathcal{A}$ if, and only if, there exists $P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$ and, for $1<n\in {\mathbb{Z}}^{+}$, $1\le j\le m\in {\mathbb{Z}}^{+}$, $(r_1,\dots ,r_m)\in {\mathbb{R}}^m$,

$$\begin{array}{ccc}(r_1,\dots ,r_m)\in dom\left(f\right)\hfill & \wedge \hfill & f(r_1,\dots ,r_m)=r\hfill \end{array}$$

if, and only if,

$$\begin{array}{cc}(\exists ({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n})){\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n}))\hfill & \wedge \hfill \\ {\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}({\sigma }_{i_1},t_{i_j})\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r_j\hfill & \wedge \hfill \\ j\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t_{i_j}\hfill & \wedge \hfill \\ {\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_n}\right)\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r.\hfill & \end{array}$$

The predicate ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{P}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L}}(f,P_k)$ holds if, and only if, f is signifiably partially computable in $\mathcal{L}$ on $\mathcal{A}$ and $P_k$ is a program that signifies f in $\mathcal{L}$ on $\mathcal{A}$.

Definitions 15 and 16 imply

Lemma 5. 

If ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L}}(f,P_k)$, then ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{P}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L}}(f,P_k)$.

Definitions 15 and 16 and Lemma 5 broaden the scope of CCT Axiom A0 by making the properties computable and partially computable apply to functions on discretely finite real numbers. The next definition states that signifiable functions are those functions that can be signified with texts in $\mathcal{L}$ on $\mathcal{A}$.

Definition 17 (Signifiable Function).

A function f is signifiable in $\mathcal{L}$ on $\mathcal{A}$, which is denoted as ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{F}}_{\mathcal{A},\mathcal{L}}\left(f\right)$, if, and only if, there exists $t\in {\mathcal{A}}_{\mathcal{L}}^{+}$ such that

$$f\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t.$$

If $t\le \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$, for some FMD $\mathcal{D}$, then f is signifiable in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$, which is denoted as ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{F}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(f\right)$.

E.g., $f:\mathbb{N}\mapsto \mathbb{N}$, $f\left(x\right)=x+1$, then

${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{F}}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}\left(f\right)$ where $t\in {\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e}}_{\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}^{+}$ that signifies f is given in Figure 1.

Lemma 6. 

There exist $\mathcal{L}$ on $\mathcal{A}$ and a function f such that

$${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{F}}_{\mathcal{A},\mathcal{L}}\left(f\right)\wedge \left(\forall P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\right)\neg {\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L}}(f,P_k).$$

Proof. 

Let $x\in {\mathcal{A}}_{\mathcal{L}}^{+}$ such that $x\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r\in \mathbb{R}$. Let $s\in {\mathcal{A}}_{\mathcal{L}}^{+}$ such that $s\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to 1$. Let

$$\begin{array}{ccc}f(x,P):{\mathcal{A}}_{\mathcal{L}}^{+}\times {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\mapsto \{"\mathtt{0}","\mathtt{1}"\};\hfill & \hfill & \\ \\ f(x,P)=\left\{\begin{array}{cc}"\mathtt{1}"\hfill & \mathrm{if}{\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L}}(P,({\sigma }_{i_1},\dots ,{\sigma }_{i_n}));\hfill \\ \\ "\mathtt{0}"\hfill & \mathrm{otherwise},\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(40)

where ${\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}({\sigma }_{i_1},s)=x$ and $x\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r$, $r\in \mathbb{R}$. Take $\mathcal{A}=\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e}$, $\mathcal{L}=\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}$, and consider the following $t\in {\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e}}_{\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}^{+}$

"(defun f (x p) (if (halts-p p x) 1 0))",

where "(halts-p p x)" returns the text in ${\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e}}_{\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}^{+}$ designating the Boolean value True if a Lisp funcallable object designated by $\mathtt{p}\in {\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e}}_{\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}^{+}$ halts on the real number designated by $x\in {\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e}}_{\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}^{+}$. Since $t\leftarrow {(=)}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}\to f$, we have

$${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{F}}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}\left(f\right).$$

However, since the predicate halts-p is not signifiably computable in Lisp on Unicode,

$$\neg (\exists P_k)P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}}\wedge {\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathtt{U}\mathtt{n}\mathtt{i}\mathtt{c}\mathtt{o}\mathtt{d}\mathtt{e},\mathtt{L}\mathtt{i}\mathtt{s}\mathtt{p}}(f,P_k).$$

   □

8. Signifiable Computability of Functions on Finite Memory Devices

We now proceed to modify some of the definitions in Section 5 for situations when functions signifiable by programs in $\mathcal{L}$ on $\mathcal{A}$ are computed on an FMD $\mathcal{D}$. We associate with every triplet $\mathcal{L},\mathcal{A},\mathcal{D}$ a non-empty set of error messages

$${\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}}=\left\{t_{cap}\right\}\cup \{t\in {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}|\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)\ge \left|t\right|\},$$

(41)

where $t_{cap}\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $|t_{cap}|\le \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$, $t_{cap}\notin {\mathtt{E}\mathtt{R}\mathtt{R}}_{\mathcal{A},\mathcal{L}}$, is a unique error message whose size does not exceed the memory capacity of $\mathcal{D}$. An important difference between the functions and predicates in Section 5 and the functions and predicates in this section is that the latter return $t_{cap}$ when the memory capacity of $\mathcal{D}$ is exceeded.

The function in (42) returns ${\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$ if the size of $\sigma$ does not exceed the memory capacity of $\mathcal{D}$. Otherwise, the function returns $t_{cap}$.

$$\begin{array}{ccc}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto \{"\mathtt{0}","\mathtt{1}",t_{cap}\};\hfill & \hfill & \\ \\ {\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=\left\{\begin{array}{cc}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\hfill & \mathrm{if}\left|\sigma \right|\le \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right);\hfill \\ t_{cap}\hfill & \mathrm{otherwise}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(42)

The function in (43) returns ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is a valid program state and the size of $\sigma$ does not exceed the memory capacity of $\mathcal{D}$. Otherwise, $t_{err}$ or $t_{cap}$ are returned.

$$\begin{array}{ccc}{\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \{t_{err},t_{cap}\};\hfill & \hfill & \\ \\ {\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=\left\{\begin{array}{cc}{\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}";\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{0}";\hfill \\ t_{cap}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=t_{cap}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(43)

The function in (44) returns ${\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is valid and the size of $\sigma$ does not exceed the memory capacity of $\mathcal{D}$. Otherwise, $t_{err}$ or $t_{cap}$ are returned.

$$\begin{array}{ccc}{\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right):{\mathcal{A}}^{+}\mapsto {\mathcal{A}}^{+}\cup \{t_{err},t_{cap}\};\hfill & \hfill & \\ \\ {\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=\left\{\begin{array}{cc}{\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}";\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{0}";\hfill \\ t_{cap}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=t_{cap}.\hfill \end{array}\right.\hfill & \hfill & \\ \hfill & \hfill & \end{array}$$

(44)

The function in (45) returns ${\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is valid and the size of $\sigma$ does not exceed the memory capacity of $\mathcal{D}$. Otherwise, $t_{err}$ or $t_{cap}$ are returned.

$$\begin{array}{ccc}{\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \{t_{err},t_{cap}\};\hfill & \hfill & \\ \\ {\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=\left\{\begin{array}{cc}{\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}";\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{0}";\hfill \\ t_{cap}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=t_{cap}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(45)

The function in (46) ${\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is valid and the size of $\sigma$ does not exceed the memory capacity of $\mathcal{D}$. Otherwise, the function returns $t_{err}$ or $t_{cap}$.

$$\begin{array}{ccc}{\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right):{\mathcal{A}}^{+}\mapsto \{"\mathtt{0}","\mathtt{1}",t_{err},t_{cap}\};\hfill & \hfill & \\ \\ {\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=\left\{\begin{array}{cc}{\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}";\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{0}";\hfill \\ t_{cap}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=t_{cap}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(46)

The function in (47) returns ${\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is valid and the size of $\sigma$ does not exceed $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$. Otherwise, $t_{err}$ or $t_{cap}$ is returned.

$$\begin{array}{ccc}{\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \{t_{err},t_{cap}\};\hfill & \hfill & \\ \\ {\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=\left\{\begin{array}{cc}{\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}";\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{0}";\hfill \\ t_{cap}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=t_{cap}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(47)

The function in (48) returns ${\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is a valid program state and the size of $\sigma$ does not exceed the memory capacity of $\mathcal{D}$. Otherwise, it returns $t_{err}$ or $t_{cap}$.

$$\begin{array}{ccc}{\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right):{\mathcal{A}}^{+}\mapsto \{"\mathtt{0}","\mathtt{1}",t_{err},t_{cap}\};\hfill & \hfill & \\ \\ {\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=\left\{\begin{array}{cc}{\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}";\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{0}";\hfill \\ t_{cap}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=t_{cap}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(48)

The function in (49) returns ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)$, if $\sigma$ is valid and the size of $\sigma$ does not exceed the memory capacity of $\mathcal{D}$. Otherwise, $t_{err}$ or $t_{cap}$ are returned.

$$\begin{array}{ccc}{\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right):{\mathcal{A}}_{\mathcal{L}}^{+}\mapsto {\mathcal{A}}_{\mathcal{L}}^{+}\cup \{t_{err},t_{cap}\};\hfill & \hfill & \\ \\ {\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=\left\{\begin{array}{cc}{\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L}}\left(\sigma \right)\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}";\hfill \\ t_{err}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{0}";\hfill \\ t_{cap}\hfill & \mathrm{if}{\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=t_{cap}.\hfill \end{array}\right.\hfill & \hfill & \end{array}$$

(49)

We now define memory-dependent signifiable computation on discretely finte real numbers in (18). This definition is similar to its memory-independent counterpart in (13), but is defined in terms of memory-dependent functions and predicates defined above in this section.

Definition 18 (Signifiable Computation on Finite Memory).

A signifiable computation of $P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$ on an FMD $\mathcal{D}$ is a finite sequence of valid program states ${\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}$, $1\le j<l$, $1<l\in {\mathbb{Z}}^{+}$, such that

$$\begin{array}{cccc}{\sigma }_{i_1}\in {\mathfrak{S}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}\hfill & & & \wedge \hfill \\ {\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_l}\right)\hfill & =\hfill & "\mathtt{1}"\hfill & \wedge \hfill \\ {\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_l}\right)\hfill & =\hfill & "\mathtt{1}"\hfill & \wedge \hfill \\ {\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_j}\right)\hfill & =\hfill & {\sigma }_{i_{j+1}}\hfill & \wedge \hfill \\ {\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_l}\right)\hfill & =\hfill & P_k.\hfill & \end{array}$$

The predicate

$${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}))$$

holds if, and only if, ${\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l}$ is a signifiable computation of $P_k$ in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$.

Definition 19 (Signifiably Computable Function on Finite Memory).

A total function $f:{\mathbb{R}}^m\mapsto \mathbb{R}$ is signifiably computable in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$ if, and only if, there exists $P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$ and, for $1<n\in {\mathbb{Z}}^{+}$, $1\le j\le m\in {\mathbb{Z}}^{+}$, $(r_1,\dots ,r_m)\in {\mathbb{R}}^m$,

$$(\forall (r_1,\dots ,r_m)\in dom\left(f\right))f(r_1,\dots ,r_m)=r$$

if, and only if,

$$\begin{array}{cc}(\exists ({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n})){\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n}))\hfill & \wedge \hfill \\ ({\sigma }_{i_k},{\sigma }_{i_{k+1}})\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L}}\to s_{k,k+1}\hfill & \wedge \hfill \\ |s_{k,k+1}|\le \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)\hfill & \wedge \hfill \\ {\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}({\sigma }_{i_1},t_{i_j})\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r_j\hfill & \wedge \hfill \\ j\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t_{i_j}\hfill & \wedge \hfill \\ {\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_n}\right)\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r.\hfill & \end{array}$$

The predicate

$${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(f,P_k)$$

holds if, and only if, f is signifiably computable in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$ and $P_k$ is a program that signifies f in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$.

The next definition formalizes signifiably computable partial functions when the memory available for computation is confined to the memory capacity of $\mathcal{D}$ on which the signifiable computation is performed.

Definition 20 (Signifiably Partially Computable Function on Finite Memory).

A partial function $f:{\mathbb{R}}^m\mapsto \mathbb{R}$ is signifiably partially computable in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$ if, and only if, there exists $P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$ and, for $1<n\in {\mathbb{Z}}^{+}$, $1\le k<n$, $1\le j\le m\in {\mathbb{Z}}^{+}$, $(r_1,\dots ,r_m)\in {\mathbb{R}}^m$,

$$\begin{array}{ccc}(r_1,\dots ,r_m)\in dom\left(f\right)\hfill & \wedge \hfill & f(r_1,\dots ,r_m)=r\hfill \end{array}$$

if, and only if,

$$\begin{array}{cc}(\exists ({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n})){\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n}))\hfill & \wedge \hfill \\ ({\sigma }_{i_k},{\sigma }_{i_{k+1}})\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to s_{k,k+1}\hfill & \wedge \hfill \\ |s_{k,k+1}|\le \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)\hfill & \wedge \hfill \\ {\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L}}({\sigma }_{i_1},t_{i_j})\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r_j\hfill & \wedge \hfill \\ j\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to t_{i_j}\hfill & \wedge \hfill \\ {\mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}}_{\mathcal{A},\mathcal{L}}\left({\sigma }_{i_n}\right)\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r.\hfill & \end{array}$$

The predicate

$${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{P}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(f,P_k)$$

holds if, and only if, f is signifiably partially computable in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$ and $P_k$ is a program that signifies f in $\mathcal{L}$ on $\mathcal{A}$ on $\mathcal{D}$.

The above definitions imply that $\mathcal{D}$ can hold $s_{k,k+1}$ in its memory. In other words, the text $s_{k,k+1}$ that signifies two consecutive valid program states in a signifiable computation does not exceed the memory capacity of $\mathcal{D}$. We will hereafter state that such an FMD has a sufficiently large memory capacity, whence the next definition.

Definition 21 (Sufficient Memory Capacity).

Let $\mathcal{D}$ be an FMD and $P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}$. Then, $\mathcal{D}$ has a sufficient memory capacity relative to $P_k$ if, for any sequence of states such that

$${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_l})),$$

$$({\sigma }_{i_k},{\sigma }_{i_{k+1}})\leftarrow {\doteqdot }_{\mathcal{A},\mathcal{L}}\to s_{k,k+1}\wedge \left|s_{k,k+1}\right|\le \mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right),1\le k<l\in {\mathbb{Z}}^{+}.$$

The predicate

$${\mathtt{S}\mathtt{M}\mathtt{C}\mathtt{A}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(P_k\right)$$

holds if, and only if, $\mathcal{D}$ has a sufficient memory capacity relative to $P_k$.

We now axiomatize the signifiable computability of ${\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$.

SCT Axiom 7. 

$$(\exists P_k)\left\{P_k\in {\mathfrak{P}}_{{\widehat{\dot{F}}}_{\mathcal{A},\mathcal{L}}}\wedge {\mathtt{S}\mathtt{M}\mathtt{C}\mathtt{A}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(P_k\right)\wedge {\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L},\mathcal{D}}({\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}},P_k)\right\}.$$

SCT Axiom 7 concretizes CCT Axiom A3 by formalizing a facility (i.e., ${\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$) to move a computation forward step-by-step when a step is identical to a valid program state. SCT Axiom 7 also broadens CCT Axiom A8 by stating that there is an explicit finite bound (i.e., $\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$) on the amount of memory available for signifiable computation whenever signifiable computation is carried out by a computing agent (e.g., an operating system or a virtual machine) on $\mathcal{D}$.

Since the functions ${\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$ (43), ${\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$ (44), ${\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$ (45), ${\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$ (46), ${\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$ (47), ${\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$ (48), ${\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$ (49), and ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$ (18) are defined in terms of ${\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}$, we have

Definition 22 (Sufficiently Powerful Finite Memory Device).

An FMD $\mathcal{D}$ is sufficiently powerful relative to $\mathcal{L}$ on $\mathcal{A}$ if, for any f, such that

$$\begin{array}{ccc}f\hfill & \in \hfill & \{{\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L},\mathcal{D}},{\mathtt{C}\mathtt{I}\mathtt{N}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}},{\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}}_{\mathcal{A},\mathcal{L},\mathcal{D}},{\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}},\hfill \\ \hfill & \hfill & {\mathtt{N}\mathtt{P}\mathtt{I}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}},{\mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}},{\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}},{\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\},\hfill \end{array}$$

$$(\exists P_k)\left\{P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\wedge {\mathtt{S}\mathtt{M}\mathtt{C}\mathtt{A}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(P_k\right)\wedge {\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(f,P_k)\right\}.$$

9. Main Results

We now present the two theorems, which we refer to as the Debugger Theorems, that constitute the main results of this investigation. The theorems are so called, because they characterize some properties of the debugger (DBGR) function defined as

$$\begin{array}{ccc}{\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,s):{\mathcal{A}}^{+}\times {\mathcal{A}}^{+}\mapsto {\mathcal{A}}^{+}\cup \{t_{cap},t_{err}\};\hfill & \hfill & \\ \\ {\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,s)=\left\{\begin{array}{cc}{\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}^{n-1}\left(\sigma \right)\hfill & \mathrm{if}\begin{array}{cc}{\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{D},\mathcal{A},\mathcal{L}}\left(\sigma \right)="\mathtt{1}"\hfill & \wedge \hfill \\ (\forall {\sigma }_{i_j},{\sigma }_{i_{j+1}})\{{\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_j}\right)\ne {\sigma }_{i_{j+1}}\hfill & \vee \hfill \\ \{{\sigma }_{i_{j+1}}\ne t_{err}\wedge {\sigma }_{i_{j+1}}\ne t_{cap}\}\};\hfill & \end{array}\hfill \\ \\ t_{err}\hfill & \mathrm{if}(\exists {\sigma }_{i_j}){\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_j}\right)=t_{err};\hfill \\ \\ t_{cap}\hfill & \mathrm{if}(\exists {\sigma }_{i_j}){\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_j}\right)=t_{cap},\hfill \end{array}\right.\hfill & \hfill & \\ \\ \mathrm{where}\sigma ={\sigma }_{i_1},s\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to n\in {\mathbb{Z}}^{+},n>1,1\le j<n.\hfill & \hfill & \end{array}$$

(50)

We define a debuggable FMD relative to $\mathcal{L}$ on $\mathcal{A}$ as

Definition 23 (Debuggable Finite Memory Device).

An FMD $\mathcal{D}$ is debuggable relative to $\mathcal{L}$ on $\mathcal{A}$ if

$$(\exists P_k)\left\{P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}\wedge {\mathtt{S}\mathtt{M}\mathtt{C}\mathtt{A}\mathtt{P}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(P_k\right)\wedge {\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L},\mathcal{D}}({\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}},P_k)\right\}.$$

We now prove

Lemma 7. 

Let $\mathcal{D}$ be an FMD debuggable relative to $\mathcal{L}$ on $\mathcal{A}$. Let $s\in {\mathcal{A}}_{\mathcal{L}}^{+}$ such that, for $1<n\in {\mathbb{Z}}^{+}$,

$$s\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to n\wedge {\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}".$$

Then,

$${\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,s)=t_{cap}$$

if, and only if, for $1\le j<n$,

$${\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_j}\right)="\mathtt{1}"\wedge {\mathtt{N}\mathtt{X}\mathtt{T}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_j}\right)=t_{cap}.$$

Proof. 

We omit the subscripts $\mathcal{A},\mathcal{L},\mathcal{D}$ for brevity and let $\sigma ={\sigma }_{i_1}$. If $\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}\left({\sigma }_{i_1}\right)="\mathtt{1}"$ and, for $1\le j<n$, $\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}\left({\sigma }_{i_j}\right)="\mathtt{1}"$ and $\mathtt{N}\mathtt{X}\mathtt{T}\left({\sigma }_{i_j}\right)=t_{cap}$, then $\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}({\sigma }_{i_1},s)=t_{cap}$, for $s\leftarrow (=)\to j+1=n$. Conversely, assume that $\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}({\sigma }_{i_1},s)=t_{cap}$. Since $\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}\left({\sigma }_{i_1}\right)$ = $"\mathtt{1}"$,

$$\{\mathtt{N}\mathtt{X}\mathtt{T}\left({\sigma }_{i_1}\right)={\sigma }_{i_2}\wedge \mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}\left({\sigma }_{i_2}\right)="\mathtt{1}"\}\vee \mathtt{N}\mathtt{X}\mathtt{T}\left({\sigma }_{i_1}\right)=t_{cap}.$$

If $\mathtt{N}\mathtt{X}\mathtt{T}\left({\sigma }_{i_1}\right)=t_{cap}$, then $j=1$ and $n=2$. Otherwise, we proceed from $j=2$ and examine each consecutive pair $({\sigma }_{i_j}$, ${\sigma }_{i_{j+1}})$ in the same fashion as the pair $({\sigma }_{i_1}$, ${\sigma }_{i_2})$ to find $2\le j<n$ and $j+1=n\leftarrow (=)\to s$ such that $\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}\left({\sigma }_{i_j}\right)$ = $"\mathtt{1}"$ and $\mathtt{N}\mathtt{X}\mathtt{T}\left({\sigma }_{i_j}\right)$ = $t_{cap}$.    □

Corollary 7.1. 

Let $\mathcal{D}$ be an FMD debuggable relative to $\mathcal{L}$ on $\mathcal{A}$. Let $s\in {\mathcal{A}}_{\mathcal{L}}^{+}$ such that, for $1<n\in {\mathbb{Z}}^{+}$,

$$s\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to n\wedge {\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}".$$

Then,

$${\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,s)=t_{err}$$

if, and only if, for $1\le j<n$,

$${\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_j}\right)="\mathtt{1}"\wedge {\mathtt{N}\mathtt{X}\mathtt{T}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left({\sigma }_{i_j}\right)=t_{err}.$$

We now prove

Theorem 1. 

Let $\mathcal{D}$ be an FMD debuggable relative to $\mathcal{L}$ and $\mathcal{A}$. Let $f:{\mathbb{R}}^m\mapsto \mathbb{R}$ such that

$${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{P}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(f,P_k)\wedge P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}.$$

Then, if

$$\begin{array}{ccc}\sigma \in {\mathcal{A}}_{\mathcal{L}}^{+}\hfill & \wedge \hfill & \\ (r_1,\dots ,r_m)\notin dom\left(f\right)\hfill & \wedge \hfill & \\ {\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}"\hfill & \wedge \hfill & \\ {\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=P_k\hfill & \wedge \hfill & \\ {\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,t_{i_j})\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r_j\hfill & \wedge \hfill & \\ t_{i_j}\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to j\hfill & \wedge \hfill & \\ 1\le j\le m\in {\mathbb{Z}}^{+}\hfill & \wedge \hfill & \\ \neg (\exists s){\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,s)=t_{err},\hfill & \hfill & \end{array}$$

then

$$(\exists n\in {\mathbb{Z}}^{+})\left\{1<n\wedge n\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to s\wedge {\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D},}(\sigma ,s)=t_{cap}\right\}.$$

Proof. 

We omit the subscripts $\mathcal{A},\mathcal{L},\mathcal{D}$ for brevity. Let $\sigma ={\sigma }_{i_1}$ be such that $\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}\left({\sigma }_{i_1}\right)="\mathtt{1}"$, $\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}\left({\sigma }_{i_1}\right)=P_k$, and $\mathtt{I}\mathtt{V}\mathtt{V}({\sigma }_{i_1},t_{i_j})$ $\leftarrow (=)\to$ $r_j$, $1\le j\le m\in {\mathbb{Z}}^{+}$, $t_{i_j}\in {\mathcal{A}}^{+}$. Let $P_w\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ be such that $\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}(\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R},P_w)$.

Since $(r_1,\dots ,r_m)\notin dom\left(f\right)$, we have

$$\neg (\exists n>1)\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{O}\mathtt{M}\mathtt{P}(P_k,({\sigma }_{i_1},{\sigma }_{i_2},\dots ,{\sigma }_{i_n})),$$

whence

$$\neg (\exists n>1)\left\{{\mathtt{N}\mathtt{X}\mathtt{T}\mathtt{S}}^{n-1}\left({\sigma }_{i_1}\right)={\sigma }^{\prime }\wedge \mathtt{E}\mathtt{N}\mathtt{D}\mathtt{S}\left({\sigma }^{\prime }\right)="\mathtt{1}"\wedge \mathtt{O}\mathtt{U}\mathtt{T}\mathtt{V}\left({\sigma }^{\prime }\right)\leftarrow (=)\to f(r_1,\dots ,r_m)\right\}.$$

We observe that if, for some $\sigma$, $\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}\left(\sigma \right)="\mathtt{1}"$, $\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}\left(\sigma \right)=t\in {\mathcal{A}}_{\mathcal{L}}^{+}$, $t\leftarrow (=)\to z\in {\mathbb{Z}}^{+}$, $\mathtt{N}\mathtt{X}\mathtt{T}\left(\sigma \right)={\sigma }^{\prime }$, and $\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}\left({\sigma }^{\prime }\right)="\mathtt{1}"$, then, by Lemma 1,

$$\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}\left({\sigma }^{\prime }\right)=t^{\prime }\in {\mathcal{A}}_{\mathcal{L}}^{+}\wedge t^{\prime }\leftarrow (=)\to z^{\prime }\in {\mathbb{Z}}^{+}\wedge z^{\prime }=z+1.$$

Let $\mathtt{N}\mathtt{X}\mathtt{T}\left({\sigma }_{i_1}\right)={\sigma }_{i_2}$. If $|{\sigma }_{i_2}|>\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$, then $n=2$. Otherwise, we run $P_w$ to compute $\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}({\sigma }_{i_1},s_3)$, $s_3\leftarrow (=)\to 3$, whereby $P_w$ computes

$$\mathtt{N}\mathtt{X}\mathtt{T}\left(\mathtt{N}\mathtt{X}\mathtt{T}\left({\sigma }_{i_1}\right)\right)=\mathtt{N}\mathtt{X}\mathtt{T}\left({\sigma }_{i_2}\right)={\sigma }_{i_3}.$$

If $|{\sigma }_{i_3}|>\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$, then $n=3$. Otherwise, we continue incrementing the natural number corresponding to the previous state counter numeral by 1 and running $P_w$ on ${\sigma }_{i_1}$ and

$$s_4\leftarrow (=)\to 4,s_5\leftarrow (=)\to 5,\dots ,$$

(i.e., the numerals corresponding to the natural numbers $4,5,\dots$). After a finite number of such iterations, we necessarily reach $\sigma$ and ${\sigma }^{\prime }$ such that

$$\mathtt{N}\mathtt{X}\mathtt{T}\left(\sigma \right)={\sigma }^{\prime }\wedge \mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}\left(\sigma \right)=\mathtt{V}\mathtt{L}\mathtt{D}\mathtt{S}\left({\sigma }^{\prime }\right)="\mathtt{1}"\wedge \left|\sigma \right|<|{\sigma }^{\prime }|,$$

because in the standard decimal notation the numeral encoding $\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}\left({\sigma }^{\prime }\right)$ contains more digit signs than the numeral encoding $\mathtt{T}\mathtt{O}\mathtt{T}\mathtt{I}\left(\sigma \right)$, whence

$$(\exists n>3)\left\{s\leftarrow (=)\to n\wedge \mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}({\sigma }_{i_1},s_n)=t_{cap}\right\}.$$

   □

We now prove

Theorem 2. 

Let $\mathcal{D}$ be an FMD debuggable relative to $\mathcal{L}$ and $\mathcal{A}$. Then, there exists $f:{\mathbb{R}}^m\mapsto \mathbb{R}$ such that ${\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}}_{\mathcal{A},\mathcal{L}}(f,P_k)$, $P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$, and, for some $(r_1,\dots ,r_m)\in dom\left(f\right)$, if

$$\begin{array}{ccc}\sigma \in {\mathcal{A}}_{\mathcal{L}}^{+}\hfill & \wedge \hfill & \\ {\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}"\hfill & \wedge \hfill & \\ {\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=P_k\hfill & \wedge \hfill & \\ {\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,t_{i_j})\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to r_j\hfill & \wedge \hfill & \\ t_{i_j}\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to j\hfill & \wedge \hfill & \\ 1\le j\le m\in {\mathbb{Z}}^{+}\hfill & \wedge \hfill & \\ \neg (\exists s){\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,s)=t_{err},\hfill & \hfill & \end{array}$$

Then,

$$(\exists m\in {\mathbb{Z}}^{+})(\forall n\in {\mathbb{Z}}^{+})\left\{m\le n\wedge n\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to s\wedge {\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D},}(\sigma ,s)=t_{cap}\right\}.$$

Proof. 

We omit the subscripts $\mathcal{A}$, $\mathcal{L}$, $\mathcal{D}$ for brevity. Let $f:\mathbb{N}\mapsto {\mathbb{Z}}^{+}$ such that $f\left(x\right)=x+1$. Then, $\mathtt{S}\mathtt{G}\mathtt{N}\mathtt{C}\mathtt{F}(f,P_k)$, $P_k\in {\mathfrak{P}}_{{\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}}$ (cf., e.g., $P_j$ in Figure 1). Let $z\in {\mathbb{Z}}^{+}$ be the smallest positive integer such that $z\leftarrow (=)\to w$ and $\left|w\right|>\mathtt{C}\mathtt{C}\mathtt{A}\mathtt{P}\left(\mathcal{D}\right)$. Let

$$\begin{array}{ccc}\sigma \in {\mathcal{A}}_{\mathcal{L}}^{+}\hfill & \wedge \hfill & \\ \mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}\left(\sigma \right)="\mathtt{1}"\hfill & \wedge \hfill & \\ \mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}\left(\sigma \right)=P_k\hfill & \wedge \hfill & \\ \mathtt{I}\mathtt{V}\mathtt{V}(\sigma ,t_{i_1})\leftarrow (=)\to 0\hfill & \wedge \hfill & \\ t_{i_1}\leftarrow (=)\to 1.\hfill & & \end{array}$$

Since $\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}\left(\sigma \right)="\mathtt{1}"$, then, by (50),

$$(\exists m)\left\{1\le m\le z\wedge m\leftarrow (=)\to v\wedge \mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}(\sigma ,v)=t_{cap}\right\}.$$

   □

Corollary 2.1. 

Let $\mathcal{D}$ be an FMD debuggable relative to $\mathcal{L}$ and $\mathcal{A}$. Let f in Theorem (2) be such that if $(r_1,\dots ,r_m),(r_1^{\prime },\dots ,r_m^{\prime })\in dom\left(f\right)$ and $r_1<r_1^{\prime },\dots ,r_m<r_m^{\prime }$, then $f(r_1,\dots ,r_m)<f(r_1^{\prime },\dots ,r_m^{\prime })$. Then, for some $(y_1,\dots ,y_n)\in dom\left(f\right)$, if

$$\begin{array}{ccc}\sigma \in {\mathcal{A}}_{\mathcal{L}}^{+}\hfill & \wedge \hfill & \\ {\mathtt{S}\mathtt{T}\mathtt{A}\mathtt{R}\mathtt{T}\mathtt{S}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)="\mathtt{1}"\hfill & \wedge \hfill & \\ {\mathtt{P}\mathtt{R}\mathtt{O}\mathtt{G}}_{\mathcal{A},\mathcal{L},\mathcal{D}}\left(\sigma \right)=P_k\hfill & \wedge \hfill & \\ {\mathtt{I}\mathtt{V}\mathtt{V}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,t_{i_j})\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to y_j\hfill & \wedge \hfill & \\ t_{i_j}\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to j\hfill & \wedge \hfill & \\ 1\le j\le m\in {\mathbb{Z}}^{+}\hfill & \wedge \hfill & \\ \neg (\exists s){\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D}}(\sigma ,s)=t_{err},\hfill & \hfill & \end{array}$$

then

$$(\exists m\in {\mathbb{Z}}^{+})(\forall n\in {\mathbb{Z}}^{+})\left\{m\le n\wedge n\leftarrow {(=)}_{\mathcal{A},\mathcal{L}}\to v\wedge {\mathtt{D}\mathtt{B}\mathtt{G}\mathtt{R}}_{\mathcal{A},\mathcal{L},\mathcal{D},}(\sigma ,v)=t_{cap}\right\}.$$

10. Discussion

The proposed axiomatization broadens the scope of CCT Axiom A0 in that it makes the properties computable and partially computable apply to functions on discretely finite real numbers (cf. Definitions 15 and 16 and Lemma 5). The ontology of functions on discretely finite real numbers implied by the proposed axiomatization distinguishes three classes of functions: signifiable, signifiably computable, and signifiably partially computable. Per Lemma 5, signifiably computable functions are signifiably partially computable, but not vice versa. Per Lemma 6, there are signifiable functions that are not signifiably partially computable.

The proposed axiomatization characterizes signifiable computation on discretely finite real numbers in terms of two formal systems: the Former ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ that generates texts in $\mathcal{L}$ in $\mathcal{A}$ and the Transformer ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ that transforms texts formed by ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ into other texts in $\mathcal{L}$ on $\mathcal{A}$. These systems are co-dependent on each other and cannot exist in isolation. Neither system is involved in the interpretation of the results insomuch as such interpretation is outside of their scope. Both systems can be signified as programs in minimally adequate formalisms and those programs can be executed by different computing agents, such as human programmers or automated program synthesizers and debuggers. Consequently, ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ and ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ are not identical to the computing agent L of CCT Axioms A4, A5, A9 and A10. All texts produced by these two formal systems are spatiotemporally finite. While ${\widehat{\ddot{F}}}_{\mathcal{A},\mathcal{L}}$ always takes a finite amount of physical time, regardless of how time is measured, to form a text, ${\widehat{\ddot{T}}}_{\mathcal{A},\mathcal{L}}$ is not guaranteed to take a finite amount of physical time to transform a text into another text. The formation and transformation of texts can be signed by both systems and verified by third parties.

Programs that use continuous, random or analogue methods are evidently inconsistent with CCT Axioms A4 and A5. However, they are consistent with the proposed axiomatization in the following sense. If such programs are signified in a minimally adequate formalism, then their formation and transformation can be deterministically verified at least on some inputs in the domains of functions that those programs designate. Furthermore, if those programs are executed on an FMD debuggable relative to the said formalism, then, per the two Debugger Theorems, the programs can be effectively debugged on all signifiable inputs. It should be noted that this debugging is effective, because on any signifiable input, the program that signifies the debugger function in (50) on the said FMD returns either the output signifying a discretely finite real number, an error message, or a message that the computation cannot be carried forward, because the FMD’s memory capacity is exceeded. This integration of error into computation makes the proposed axiomatization different from the CCT axiomatization.

SCT Axiom 5 of the proposed axiomatization concretizes CCT Axiom A9, because it states that the computational capacity of a computing agent is a characteristic of not just the computing agent but also of the programming formalism. SCT Axiom 7 of the proposed axiomatization also concretizes CCT Axiom A8 by stating that there is an explicit finite bound on the memory available for signifiable computation whenever the computation is carried out by a computing agent on an FMD. Furthermore, the Debugger Theorems (cf. Section 9) indicate that CCT Axioms A6, A7, A8, and A10 do not apply to actual computability, i.e., situations when the signification of computation is performed on FMDs.

The concept of Debuggable FMD (cf. Definition 23) also bears on CCT Axiom A9 and distinguishes the proposed axiomatization from the CCT axiomatization. Debuggable FMDs are FMDs on which the debugger function (cf. Equation  (50)) can be signified by a program in a minimally adequate $\mathcal{L}$ on $\mathcal{A}$. Intuitively, debuggable FMDs are computational devices with finite amounts of memory available for computation that can be effectively debugged. Thus, the computational capacity of a computing agent is limited not only by a finite number of instruction types the agent can perform but also by a concrete finite amount of memory available for signifiable computation.

A fundamental difference between the proposed axiomatization and the CCT axiomatization is the explicit integration of cost into computation through the function TOTI (cf. Equations (31) and (45)). Cost is different from the standard Big-O analysis of computer science (cf., e.g., Ch. 2 in [11]). The Big-O analysis is based on two assumptions: (1) the number of steps can be known ahead of computation as a function of the size of the input, and (2) constant factors do not matter (e.g., $f\left(n\right)=kn\in O\left(n\right)$, for $k\in {\mathbb{Z}}^{+}$, even when $k={10}^{58}$, i.e., the estimated number of photons in the observable universe). A consequence of the second assumption, almost never explicitly stated, is that the energy is available on demand to carry forward the prescribed computation. The function TOTI is not based on either assumption. It simply states that the cost of computation increases by one abstract unit (e.g., one unit of energy required to obtain a result, one unit of hardware maintenance cost, one unit of economic unavailability of computed results for decision making, etc.) with every signified instruction performed by a computing agent. To put it differently, per Lemma 1, the cost of signifiable computation monotonically increases by one abstract unit with every new signifiable program state.

Our approach to typed instructions (cf., e.g., Equation (22) and Definition 8) is inspired by the approach originally proposed by Church in [12]. However, our end objective is different. We do not aim to integrate $\lambda$-calculus (or any other formalism) into Russell’s hierarchical theory of logical types (cf., e.g., [13,14]). Rather, we aim to formally characterize what is computable in principle and what is computable with performable processes on computational devices with finite amounts of memory.

The usage of logically quantified variables in our formalism makes no ontological commitment that assertions containing the said variables imply that the ranges of the variables actually exist [15] or that designating texts serve as senses of names [16]. While our formal apparatus (cf. Section 2) relies on the axiom of choice of the Zermelo–Fraenkel set theory, the proposed axioms, definitions, lemmas, theorems, and implications thereof should not be viewed as arguments for or against replacing the Zermelo–Fraenkel set theory with the axiom of choice with the modern type theory as the foundation of mathematics (cf., e.g., [17]). The alternative foundations of mathematics are beyond the scope of our article.

Finally, we make no claim that the proposed axiomatization has no alternatives. Rather, it is our hope that this investigation will motivate other computability theory and recursion theory researchers to take a closer look at the differences between general and actual computabilities and to seek alternative axiomatizations of computability to gain deeper insights into the theory and practice of computer science.

11. Conclusions

In our previous investigation [4], we formalized the signification and reference of real numbers and showed that discretely finite structures representable as tuples of discretely finite numbers are signifiable on finite memory devices. In this investigation, we offered an axiomatization of signifiable computation on discretely finite real numbers and proved two theorems to investigate the computability properties of signifiably and partially signifiably computable functions on finite memory devices. For the next part of our investigation of significable computability, which we intend to cover in our next article, we plan to further investigate connections between signifiable computability and the theory of primitive recursive functions (cf., e.g., [18,19]) and, if and when possible, to connect signifiable computability to formal approaches to symbolic AI [10].