A meta-probabilistic-programming language for bisimulation of probabilistic and non-well-founded type systems

We can now describe interpretation in $\mathbb{M}$ via the GLTS defined above. To do so, we map specific symbols/edges in the metagraph to actions in $\mathcal{A}$ (corresponding to the grounding domain $F$ in [8]). Specifically, edges carrying symbols of a function type, $A\rightarrow B$, dependent product type, $\prod a:A.B$, or the $\operatorname{transform}$ symbol, are mapped to specific forms of rewrite rule, as specified below. All other edges are mapped to the $\operatorname{null}$ transform. Fig. 2 specifies the general forms of the rewrite rules for function application, and transform rules (we note the $\operatorname{transform}$ is equivalent to the 2-argument $\operatorname{match}$ keyword/function in the current version of the MeTTa language, see [16]). The dependent product rule is identical to Fig. 2a, with $A\rightarrow B$ replaced with $\prod a:A.m_{1}$ For explicitness, we give these below also in equational form. We note that, for convenience variable names are denoted using $\$$, although these should be ultimately mapped to the names $v_{1},v_{2},...$.

In Eq. 3.2, $M^{\prime}_{1}$ and $M^{\prime}_{2}$ denote metagraphs isomorphic to $M_{1}$ and $M_{2}$, using a disjoint set of variables, while $M^{\prime\prime}_{1}$ and $M^{\prime\prime}_{2}$ are defined similarly, with variables disjoint to the previous subsets. The rule in Eq. 3.2 is defined so as to return a 2-tuple of matches; in general, the size of the tuple returned should be large enough to allow for any number of matches (i.e the number of nodes in $M$), and if the number of matches is less than this, it will be padded with $\operatorname{null}$ values.

fun-app nodes. For a given annotated $\operatorname{fun-app}$ node, i.e. $\operatorname{connect}(@,F,\operatorname{null},\{(1,0)\}))$, where $@=\operatorname{edge}(1,\mathcal{X},(@,n),[\top])$ and $F$ is a graph consisting of a target $\operatorname{fun-app}$ node and its two arguments, the full rewrite rule $\operatorname{rewrite}_{F}$ is found by forming a metagraph homomorphism between $R^{7}_{\operatorname{fun-app}}$ (labeled by $*$ as the input of the rule), and $F$, replacing the variables in $R_{\operatorname{fun-app}}$ by their values in $F$. The resulting graph is denoted $R_{\operatorname{fun-app}}(F)$. The rule $\operatorname{rewrite}_{F}$ is then defined by the subgraphs $L=\operatorname{connect}(\$M_{0},\operatorname{connect}(@,l_{\operatorname{fun-app}}(F),\operatorname{null},\{(1,0)\})),\operatorname{null},\{((n_{1},m_{1}),(n_{2},m_{1}),...\})$, $R=\operatorname{connect}((\$M_{0},r_{\operatorname{fun-app}}(F),\operatorname{null},\{((n_{1},m),(n_{2},m),...\})$, where $M_{0}$ is the graph of all nodes in $M$ targeting $F$, $m_{1}$ is the index of the $\operatorname{fun-app}$ node in $F$, $m_{2}$ is the index of the $**$ output node in $r_{\operatorname{fun-app}}(F)$, and $\phi$ is defined by the partial homomorphism consisting of the identity map on all nodes labeled $LR$.

transform nodes. For a given annotated $\operatorname{transform}$ node, the full rewrite rule is defined similarly. Hence, for $\operatorname{connect}(@,F,\operatorname{null},\{(1,0)\}))$, where $@=\operatorname{edge}(1,\mathcal{X},(@,n),[\top])$ and $F$ is a graph consisting of a target $\operatorname{transform}$ node and its two arguments, the full rewrite rule $\operatorname{rewrite}_{F}$ is found by forming a metagraph homomorphism between $R^{2}_{\operatorname{transform}}$ (labeled by $*$ as the input of the rule), and $F$, replacing the variables in $R_{\operatorname{transform}}$ by their values in $F$. The resulting graph is denoted $R_{\operatorname{transform}}(F)$. The rule $\operatorname{rewrite}_{F}$ is then defined by the subgraphs $L=\operatorname{connect}(\$M_{0},\operatorname{connect}(@,l_{\operatorname{transform}}(F),\allowbreak\operatorname{null},\{(1,0)\})),\operatorname{null},\{((n_{1},m_{1}),(n_{2},m_{1}),...\})$, $R=\operatorname{connect}((\$M_{0},r_{\operatorname{transform}}(F),\allowbreak\operatorname{null},\{((n_{1},m),(n_{2},m),...\})$, where $M_{0}$ is the graph of all nodes in $M$ targeting $F$, $m_{1}$ is the index of the $\operatorname{transform}$ node in $F$, $m_{2}$ is the index of the $**$ output node in $r_{\operatorname{transform}}(F)$, and $\phi$ is defined by the partial homomorphism consisting of the identity map on all nodes labeled $LR$.

$\mathbb{M}$-evaluation. The above provides groundings for activated nodes in a metagraph; as noted, nodes not of the form above result in a $\operatorname{null}$ update. Evaluation in $\mathbb{M}$ involves repeatedly updating the current pointed metgraph according to the grounding of the node currently pointed to. The conditions in Eq. 3 imply there will be at most one edge labeled with $\dagger$ in a metagraph, whose target $F$ specifies the rule by which the graph is updated. This is expressed via the single partial function, $\operatorname{update}:\mathcal{M}_{\mathbb{M}}\rightarrow\mathcal{M}_{\mathbb{M}}$. The action of $\operatorname{update}$ is determined by the form of $F$. If $F$ is not an activated subgraph, i.e. it is not the target of an $@$-edge, the action $\operatorname{update}$ cannot be applied (i.e. evaluation halts). If however $F$ is the target of an $@$-edge, $\operatorname{update}$ first checks if $F$ itself has any activated targets. If so, then $\operatorname{update}$ simply applies a graph rewrite which moves the pointer $\dagger$ to the first such activated target (in the ordering of the edge). If not, $\operatorname{update}$ applies $\operatorname{rewrite}_{F}$, which automatically ensures that the update will finish with $\dagger$ pointing to the output subgraph, labeled $**$. These dynamics define a reduced GLTS, with $X=\mathcal{M}_{\mathbb{M}}$, $A=\{\operatorname{update}\}$, and $f(M)=\{(\operatorname{update},M^{\prime}|\operatorname{update}(M)=M^{\prime})\}$. Note that there may be multiple $M^{\prime}$’s for which $\operatorname{update}(M)=M^{\prime}$ if $\operatorname{rewrite}_{F}$ for a $\operatorname{fun-app}$ node is non-deterministic. Processes are defined by the fixed point $\text{Proc}=\nu(P_{\text{fin}}(A\times\triangleright X)))$. Normal forms of $\mathcal{M}_{\mathbb{M}}$ are metagraphs for which $\operatorname{update}$ cannot be applied (i.e. their grounding is $\operatorname{null}$). Processes which reach a normal form are said to be terminating, and the initial expression of the process is said to evaluate to the normal form reached. Alternatively, certain expressions may not reach a normal form, resulting instead in a non-terminating computation.

The syntax for the simply typed lambda calculus may be defined via mutually recursive definitions of variable, type and expression datatypes:

We refrain from explicitly stating the rules for type assignment as can be found in [2], which determine a typing relation $\_:\_$ between $\mathcal{E}$ and $\mathcal{T}$ given a context $\Gamma$, which can be modeled as a partial map from $\mathcal{V}$ to $\mathcal{T}$. Together, these determine a set of valid expressions, $\mathcal{E}_{(\_:\_,\Gamma)}$, and the computational dynamics is defined by the $\beta$-reduction relation over this type:

where $a[b/c]$ denotes substitution of $b$ for $c$ in $a$, where any bound variables in $c$ are renamed so as not to clash with bound variables in $a$.

To simulate the simply typed lambda calculus in $\mathbb{M}$, we restrict the $\mathbb{M}$ atomspace to include only metagraphs labeled with types using the restricted type syntax of Eq. 4.1, and including only keywords/symbols $\{:,=,\rightarrow,\operatorname{fun-app},@,\dagger\}$. Then, we add the following constraint to those of Eq. 3:

Hence, all typing relations are between symbols or variables (representing global and local variables respectively) and types. The context $\Gamma$ is then represented by an atomspace consisting of a set of $:$ edges between symbols and types. A given lambda expression $e=\lambda x:t_{1}.e^{\prime}$, where $e^{\prime}:t_{2}$ is then simulated by choosing an unused symbol, $f_{e}\in\mathcal{S}$, and introducing the following atoms to atomspace:

where $m_{e^{\prime}}$ is the metagraph corresponding to expression $e^{\prime}$ (we note that Eq. 4.1 defines a combinator corresponding to the lambda term $e$). With the atomspace so specified, reduction of an expression $e$ in context $\Gamma$ in the simply typed lambda calculus corresponds to repeated application of $\operatorname{update}$ to the pointed atomspace containing $\Gamma$ and $m_{e}$, with $@$ edges attached to all function application nodes, and the $\dagger$ pointing to $m_{e}$. The computation terminates with $\dagger$ pointing to the normal form of $e$. The required bisimulation thus involves pairing tuples $(\Gamma,e)$ in the simply typed lambda calculus with their corresponding pointed atomspaces in $\mathbb{M}$. We note further that the untyped lambda calculus can be defined by simply removing $\mathcal{T}$ from the syntax in Eq. 4.1, and letting lambda expressions take the form $\lambda v_{n}.\mathcal{E}$. All members of $\mathcal{E}$. are considered legal expressions, and the $\mathbb{M}$ bisimulation is achieved by converting all type symbols to $\top_{\operatorname{Type}}$, hence treating $\top_{\operatorname{Type}}$ as a Scott domain.

In a pure type system (PTS, [2]), types and terms are not distinguished syntactically. PTS expressions follow the syntax:

Here, $\mathcal{C}$ is a set of constant symbols, which in a PTS are used to represent sorts. The typing relation $:$ for a PTS is defined via a set of axioms and rules. The former consist of a set of judgements $\mathcal{A}=\{s_{m}:s_{n}|(m,n)\in A\subset N\times N\}$, and the latter a set of triplets $\mathcal{R}=\{(s_{l},s_{m},s_{n})|(l,m,n)\in R\subset N\times N\times N\}$. The typing rules for a PTS are identical to the typed lambda calculus, except for the introduction rule for dependent products, which takes the form:

  $\Gamma\vdash A:s_{l}\;\;\Gamma,A:s_{l}\vdash B:s_{m}\;\;(s_{l},s_{m},s_{n})\in\mathcal{R}$                   $\Gamma\vdash(\prod x:A.B):s_{n}$

The legal expressions then consist of the sorts, and any expression that can be typed in a context $\Gamma$, consisting of multiple typing judgments $e_{1}:e_{2}$. The $\beta$-reduction relation is established identically to the simple lambda calculus above. Notice that there is no restriction on the form of $\mathcal{A}$ and $\mathcal{R}$; hence the typing relation $:$ may be arbitrary between sorts (and hence may contain cycles), while the dependent product (i.e. dependent function types) may live in arbitrary sorts with respect to their inputs.

To simulate a PTS in $\mathbb{M}$, we select a collection of fixed types $t_{1}...t_{N}$ to represent the sorts. We then add edges of the following forms to atomspace: