Towards an ASM thesis for reflective sequential algorithms

TL;DR

This paper extends Gurevich's ASM thesis to reflective sequential algorithms by proposing postulates and a new model, reflective ASM, to characterize their fundamental behavior.

Contribution

It introduces a set of postulates for reflective sequential algorithms and a corresponding ASM model, proposing a new theoretical framework for their characterization.

Findings

Postulates for reflective sequential algorithms proposed

A new reflective ASM model defined

Conjecture that the model captures all RSAs

Abstract

Starting from Gurevich's thesis for sequential algorithms (the so-called "sequential ASM thesis"), we propose a characterization of the behaviour of sequential algorithms enriched with reflection. That is, we present a set of postulates which we conjecture capture the fundamental properties of reflective sequential algorithms (RSAs). Then we look at the plausibility of an ASM thesis for the class of RSAs, defining a model of abstract state machine (which we call reflective ASM) that we conjecture captures the class of RSAs as defined by our postulates.

Full text

1 Reflective Sequential Algorithms

In this paper we are concerned with linguistic reflection [6], which can be defined as the ability of an algorithm to change itself.

In the field of computable functions this idea of reflection is as old as the field itself, think for instance of universal Turing machines. It has also been implemented in many programming languages. A prime example is LISP [5], where programs and data are represented uniformly as lists, and thus programs represented as data can be executed dynamically by means of an evaluation operator. Database theory is another field in which reflection has been deeply studied. It was shown that reflection can increase the expressive power of relational algebra [3] and relational machines [1]. Nowadays, most programming languages allow for some form of dynamic SQL, where the SQL queries are produced and evaluated dynamically during the program run-time, as opposed to static SQL where the queries are fixed at the time of compilation.

In the field of behavioural theory of algorithms however, linguistic reflection has not (up to our knowledge) been formally studied yet. This is surprising since dynamic self modifying code is a matter of increasing practical importance and key for the development of type-safe, dynamic agents, autonomous computing, and adaptive systems among others. The development of a good theoretical basis to describe, understand and prove properties of such systems, is then a pressing issue.

Our aim in this work is to contribute to the development of a behavioural theory of reflective algorithms. In particular, we are concerned with reflective sequential algorithms (RSAs), i.e., algorithms which are sequential in the precise sense of Gurevich’s famous thesis [4], but which have the additional ability to change themselves.

In the remaining part of this section we propose to capture the class of RSAs by means of three postulates which naturally extend the sequential time, abstract state and bounded exploration postulates in Gurevich’s thesis [4]. Then, in Section 2 we define a model of reflective ASM which we conjecture capture the class of RSAs as defined by our postulates. Section 3 concludes this short paper with two examples of RSAs which satisfy our postulates.

Similar to Gurevich’s thesis for sequential algorithms [4], our first postulate states that every RSA works in sequential time. The key difference is that RSAs need to be able to change themselves. Thus, it seems natural to consider every state of a RSA as an extended state which includes (a representation of) a sequential algorithm (in the precise sense of Gurevich’s thesis [4]) as part of it. In this way, transitions from one step to the next can also involve changes to the algorithm which now forms part of the state. Given a state $\bf S$ and a sequential algorithm $A$, we use $({\bf S},A)$ to denote an extended state which extends $\bf S$ with (a representation of) $A$.

Postulate 1** (Reflective Sequential Time Postulate)**

A RSA $\mathcal{A}$ consists of the following:

• •

A non-empty set $\mathcal{S}_{\mathcal{A}}$ of extended states, where each state is extended with (a representation of) a sequential algorithm which forms part of the state.

• •

A non-empty subset $\mathcal{I}_{\mathcal{A}}\subseteq\mathcal{S}_{\mathcal{A}}$ of initial extended states such that for all $({\bf S}_{i},A_{i}),({\bf S}_{j},A_{j})\in\mathcal{I}_{\mathcal{A}}$, $A_{i}=A_{j}$ (i.e., such that all initial extended states of $\mathcal{A}$ contain exactly the same sequential algorithm).

• •

A one-step transformation function $\tau_{\mathcal{A}}:\mathcal{S}_{\mathcal{A}}\rightarrow\mathcal{S}_{\mathcal{A}}$ such that $\tau_{\mathcal{A}}(({\bf S}_{i},A_{i}))=({\bf S}_{j},A_{j})$ iff $\tau_{A_{i}}(({\bf S}_{i},A_{i}))=({\bf S}_{j},A_{j})$, where $\tau_{A_{i}}$ denotes the one-step transformation function of the sequential algorithm $A_{i}$.

The concept of run remains the same as in the thesis for sequential algorithms, except that we consider extended states instead of arbitrary states. That is, a run or computation of $\mathcal{A}$ is a sequence of extended states $({\bf S}_{0},A_{0}),({\bf S}_{1},$ $A_{1}),$ $({\bf S}_{2},A_{2}),\ldots,$ where $({\bf S}_{0},A_{0})$ is an initial extended state in $\mathcal{I}_{A}$ and $({\bf S}_{i+1},$ $A_{i+1})=\tau_{\cal A}(({\bf S}_{i},A_{i}))$ holds for every $i\geq 0$.

While behavioural equivalent sequential algorithms have the same runs, this is not necessarily the case for RSA. In fact we can think of different runs $({\bf S}_{0},A_{0}),({\bf S}_{1},A_{1}),$ $({\bf S}_{2},A_{2}),\ldots,$ and $({\bf S}_{0}^{\prime},A_{0}^{\prime}),({\bf S}_{1}^{\prime},A_{1}^{\prime}),$ $({\bf S}_{2}^{\prime},A_{2}^{\prime}),\ldots,$ where ${\bf S}_{i}={\bf S}_{i}^{\prime}$ and $A_{i}$ is behavioural equivalent (in the classical sense) to $A_{i}^{\prime}$ for every $i\geq 0$. Since such runs clearly represent the same behaviour, we call them essentially equivalent runs and define behavioural equivalent RSAs as RSAs which have essentially equivalent classes of runs.

As in the sequential ASM thesis, our second postulate defines (extended) states as first-order structures. However, extended states are not just arbitrary first-order structures, since each extended state must also include (an encoding of) a sequential algorithm given by a finite text. It is important to note that the vocabulary of a RSA is not necessarily fixed. That is, we do not only allow RSAs to change themselves, but also to change their vocabularies.

Postulate 2** (Reflective Abstract State Postulate)**

• •

Extended states of RSAs are first-order structures.

• •

*Every extended state $({\bf S},A)$ is formed by the union of an arbitrary first-order structure ${\bf S}$ and a finite first-order structure ${\bf S}_{A}$ which encodes the sequential algorithm $A$. *

• •

The one-step transformation $\tau_{\mathcal{A}}$ of a RSA $\cal A$ does not change the base set of any extended state of $\cal A$.

• •

The sets $\mathcal{S}_{\mathcal{A}}$ and $\mathcal{I}_{\mathcal{A}}$ of, respectively, extended states and initial extended states of a RSA $\cal A$, are both closed under isomorphisms.

• •

Any isomorphism between two extended states $({\bf S}_{1},A_{1})$ and $({\bf S}_{2},A_{2})$ of a RSA $\cal A$, is also an isomorphism from $\tau_{\mathcal{A}}(({\bf S}_{1},A_{1}))$ to $\tau_{\mathcal{A}}(({\bf S}_{2},A_{2}))$.

Our next (key) definition of strong coincidence of two extended states over a set of ground terms, is based on the fact that by the sequential accessibility principle of the ASM thesis for sequential algorithms [4], the only way in which $A$ can access an element $a$ of the base set of the state $({\bf S},A)$ is by producing a ground term that evaluates to $a$ in $({\bf S},A)$.

Definition 1

Following the standard approach in reflective programming [6], for every extended state $({\bf S},A)$, we fix a total surjective function $\mathit{raise}_{({\bf S},A)}:S_{A}\rightarrow\mathit{Ground}_{A}$ which maps (raises) elements from the domain $S_{A}$ of the finite structure ${\bf S}_{A}$ that encodes $A$, to (the level of) well formed ground terms in the finite set $\mathit{Ground}_{A}$ formed by all the ground terms used by the sequential algorithm $A$ to access elements of the extended state $({\bf S},A)$.

Let $({\bf S},A)$ be an extended state, let $\Sigma_{S}$ and $\Sigma_{A}$ be the vocabularies of $\bf S$ and of the finite structure ${\bf S}_{A}$ which encodes the sequential algorithm $A$, respectively, let $\mathit{val}_{({\bf S},A)}(t)$ denote the interpretation in $({\bf S},A)$ of a ground term $t$ of vocabulary $\Sigma_{S}\cup\Sigma_{A}$, and let $\mathit{val}_{{\bf S}_{A}}(t)$ denote the interpretation in ${\bf S}_{A}$ of a ground term $t$ of vocabulary $\Sigma_{A}$. We say that two extended states $({\bf S}_{1},A_{1})$ and $({\bf S}_{2},A_{2})$ strongly coincide on a set $W_{S}\cup W_{A}$ of ground terms of vocabulary $(\Sigma_{{\bf S}_{1}}\cup\Sigma_{A_{1}})\cap(\Sigma_{{\bf S}_{2}}\cup\Sigma_{A_{2}})$ and $\Sigma_{A_{1}}\cap\Sigma_{A_{2}}$, respectively, iff the following holds:

• •

For every $t\in W_{S}$, $\mathit{val}_{({\bf S}_{1},A_{1})}(t)=\mathit{val}_{({\bf S}_{2},A_{2})}(t)$.

• •

For every $t\in W_{A}$ and corresponding $a_{1}=\mathit{val}_{{\bf S}_{A_{1}}}(t)$ and $a_{2}=\mathit{val}_{{\bf S}_{A_{2}}}(t)$,

• –

$\mathit{raise}_{({\bf S}_{1},A_{1})}(a_{1})=\mathit{raise}_{({\bf S}_{2},A_{2})}(a_{2})$, and

• –

$\mathit{val}_{({\bf S}_{1},A_{1})}(\mathit{raise}_{({\bf S}_{1},A_{1})}(a_{1}))=\mathit{val}_{({\bf S}_{2},A_{2})}(\mathit{raise}_{({\bf S}_{2},A_{2})}(a_{2}))$.

We can now introduce our third and last postulate. It generalizes the bounded exploration postulate for sequential algorithms in [4] to RSAs. The key difference with the analogous postulate in the sequential ASM thesis, is that we use a stronger notion of coincidence. This is necessary because for each RSA $\cal A$, we want to have a finite bounded exploration witness set $W_{\cal A}$ which allows us to “extract” from every extended state $({\bf S}_{i},A_{i})$ of $\cal A$, a corresponding bounded exploration witness $W_{A_{i}}$ for $A_{i}$ (in the sense of the sequential ASM thesis).

Let $({\bf S},A)$ be the extended state of a RSA $\cal A$, we use $\Delta({\bf S},A)$ to denote the unique set of updates produced by the sequential algorithm $A$ in the extended state $({\bf S},A)$, which by virtue of Postulate $1$ coincides with the set of updates produced by the RSA $\cal A$ in the extended state $({\bf S},A)$. The formal definition of update and update set produced by a sequential algorithm is exactly the same as in [4, 2].

Postulate 3** (Reflective Bounded Exploration Postulate)**

For every RSA $\cal A$, there is a finite set $W_{S}\cup W_{A}$ of ground terms (called reflective bounded exploration witness) such that $\Delta({\bf S}_{1},A_{1})=\Delta({\bf S}_{2},A_{2})$ whenever extended states $({\bf S}_{1},A_{1})$ and $({\bf S}_{2},A_{2})$ of $\cal A$ strongly coincide on $W_{S}\cup W_{A}$.

A reflective sequential algorithm (RSA) is an algorithm satisfying the Reflective Sequential Time, Reflective Abstract State and Reflective Bounded Exploration Postulates. In our next section we introduce a model of ASM machine which we conjecture characterizes this class of RSAs.

2 Reflective ASMs

The set of ASM rules of the reflective ASMs, as well as the interpretation of these rules in terms of update sets, coincide with those of the sequential ASMs as defined in [4].

States of reflective ASMs are extended states. Each extended state $({\bf S},R)$ of a reflective ASM is formed by the union of an arbitrary first-order structure $\bf S$ and a finite first-order structure ${\bf S}_{R}$ which encodes the sequential ASM rule $R$ as an abstract syntax tree $T_{R}$. ${\bf S}_{R}$ is formed by:

• •

A finite set $V$ of nodes.

• •

A finite set $L$ of labels which includes a different label for each ASM rule and each function symbol in the vocabulary of $({\bf S},R)$.

• •

A nullary function symbol $\mathit{self}$ interpreted as the root node of $T_{R}$.

• •

Boolean binary function symbols $\mathit{child}$ and $\mathit{sibling}$ interpreted by the children and next sibling relationships of $T_{R}$, respectively.

• •

A function symbol $\mathit{label}$ interpreted as a total labeling function of the nodes in $V$ with labels from $L$.

• •

Nullary function symbols (constants) $l_{\mathrm{par}}$, $l_{\mathrm{if}}$, $l_{\mathrm{update}}$, $l_{\mathrm{import}}$ interpreted by the labels in $L$ corresponding to the ASM rules ${\bf par}$, $\bf if$, $\bf update$ and $\bf import$, respectively.

• •

A different nullary function symbol (constant) $l_{f}$ for each function symbol $f$ in the vocabulary of $({\bf S},R)$, interpreted by the label in $L$ corresponding to the function symbol $f$.

• •

A different nullary function symbol (constant) $\mathit{node}_{w_{v}}$ for each node $v\in V\setminus\{\mathit{self}\}$ which is interpreted by $v$. Here $w_{v}$ is the word in the language defined by the grammar $P\rightarrow n\mid P.n$ where $n\in\mathbb{N}$, such that $w_{v}=n$ if $v$ is the $n$-th child of $\mathit{self}$ and $w_{v}=w_{v^{\prime}}.n$ if $v$ is the $n$-th child of the node $v^{\prime}$. For instance, if $v$ is the node in $T_{R}$ corresponding to the second child of the first child of $\mathit{self}$, then the constant $\mathit{node}_{1.2}$ is interpreted by $v$.

Let $\Delta({\bf S},R)$ denote the set of updates yielded by a sequential ASM rule $R$ on an extended state $({\bf S},R)$. Let $({\bf S},R)+\Delta({\bf S},R)$ be the extended state obtained by applying the updates in $\Delta({\bf S},R)$ to $({\bf S},R)$. A reflective ASM $\mathcal{M}$ is formed by:

• •

A non-empty set $\mathcal{S}_{\mathcal{M}}$ of extended states which is closed under isomorphisms.

• •

A non-empty subset $\mathcal{I}_{\mathcal{M}}\subseteq\mathcal{S}_{\mathcal{M}}$ of initial extended states such that for all $({\bf S}_{1},R_{1}),({\bf S}_{2},R_{2})\in\mathcal{I}_{\mathcal{M}}$, $R_{1}=R_{2}$.

• •

A transition function $\tau_{\mathcal{M}}$ over $\mathcal{S}_{\mathcal{M}}$ such that $\tau_{\mathcal{M}}(({\bf S},R))=({\bf S},R)+\Delta({\bf S},R)$ for every $({\bf S},R)\in\mathcal{S}_{\mathcal{M}}$.

A run of a reflective sequential ASM is a finite or infinite sequence of extended states $({\bf S}_{0},R_{0}),({\bf S}_{1},R_{1}),({\bf S}_{2},R_{2}),\ldots$, where $({\bf S}_{0},R_{0})$ is an initial extended state in $\mathcal{S}_{\mathcal{M}}$ and $({\bf S}_{i+1},R_{i+1})=\tau_{\mathcal{M}}(({\bf S}_{i},R_{i}))$ holds for every $i\geq 0$.

3 Examples

Let the sequential ASM rule in Figure $1$ be the rule encoded in the initial states of a reflective ASM $\cal M$. It follows that every run of $\cal M$ produces an infinite sequence of extended states $({\bf S}_{0},R_{0})$, $({\bf S}_{1},R_{1}),\ldots$ where each state $({\bf S}_{i+1},R_{i+1})$ is obtained by updating the sub-tree rooted at $\mathit{node}_{1.2}$ of the syntax tree of $R_{i}$ so that it encodes the term $g+\underbrace{a+\ldots+a}_{(i+1)-\text{times}}$ instead of $g+\underbrace{a+\ldots+a}_{i-\text{times}}$, and by updating the location $(f,())$ with the value of the term $g+\underbrace{a+\ldots+a}_{i-\text{times}}$ in ${\bf S}_{i}$.

If for every extended state $({\bf S},R)$ of ${\cal M}$, we fix the function $\mathit{raise}_{({\bf S},A)}:S_{R}\rightarrow\mathit{Ground}_{R}$ in Definition 1 to be such that, $\mathit{raise}_{({\bf S},A)}(a_{i})=t_{i}$ iff the sub-tree of $T_{R}$ rooted at $a_{i}$ ($T_{R}$ been the syntax tree encoded in ${\bf S}_{R}$) corresponds to the well formed ground term $t_{i}$ in the set $\mathit{Ground}_{R}$ of ground terms in $R$, and $\mathit{raise}_{({\bf S},A)}(a_{i})=\mathtt{undef}$ otherwise. Then it is clear that the set $W=W_{S}\cup W_{A}$ where $W_{S}=\{\mathtt{true},\mathtt{false},l_{+},l_{a}\}$ and $W_{A}=\{\mathit{node}_{1.2}\}$, is a reflective bounded exploration witness for $\cal M$.

As a second example, we consider the relational reflective machine (RRM) defined in [1] as a formal machine that computes only computable queries, as opposed to Turing machines. In RRMs the input (relational) database is stored in the so called relational store and it can be accessed only through first-order logic queries that are dynamic, i.e., are built during the execution of the machine. As part of its proof of completeness, such reflection power is used to find out the size of the domain of the database. To that end, the machine goes on building (and then executing) for each $n\geq 1$ the sentence $\exists x_{1}\ldots x_{n}(\bigwedge_{1\leq i\neq j\leq n}(x_{i}\neq x_{j}))$ until it becomes false, meaning that the previous value of $n$ is the wanted size. Note that the kind of reflection that the RRM uses is a bit different to the one we propose in this work. We could call it “partial reflection”, since the sequence of actions performed in each transition, except for the queries to the relational store, never changes. We could then think in a different definition of the reflective ASM to represent partial reflection, as follows. Essentially, we only add to the sequential ASM a rule ${\bf eval}\,t$, which takes a term $t$ as its argument, and interpret its value as the root of the syntax tree of a sequential ASM rule (other than ${\bf eval}$) which is then executed.