A Unification Algorithm for GP 2 (Long Version)

Ivaylo Hristakiev; Detlef Plump

arXiv:1705.02171·cs.LO·May 8, 2017

A Unification Algorithm for GP 2 (Long Version)

Ivaylo Hristakiev, Detlef Plump

PDF

Open Access

TL;DR

This paper introduces a complete, sound, and terminating unification algorithm for GP 2 expressions, enabling static conflict analysis of graph programs by solving equations involving attributed graph labels.

Contribution

It presents the first rule-based unification algorithm for GP 2 expressions that handles associativity and unit laws, ensuring finitary solutions for conflict detection.

Findings

01

Algorithm is sound, complete, and terminating.

02

Generates a finite set of solutions for each input equation.

03

Handles unification modulo associativity and unit law.

Abstract

The graph programming language GP 2 allows to apply sets of rule schemata (or "attributed" rules) non-deterministically. To analyse conflicts of programs statically, graphs labelled with expressions are overlayed to construct critical pairs of rule applications. Each overlay induces a system of equations whose solutions represent different conflicts. We present a rule-based unification algorithm for GP expressions that is terminating, sound and complete. For every input equation, the algorithm generates a finite set of substitutions. Soundness means that each of these substitutions solves the input equation. Since GP labels are lists constructed by concatenation, unification modulo associativity and unit law is required. This problem, which is also known as word unification, is infinitary in general but becomes finitary due to GP's rule schema syntax and the assumption that rule…

Equations34

σ = {x^{'} \mapsto y, m^{'} \mapsto p, y^{'} \mapsto x, p^{'} \mapsto m}

σ = {x^{'} \mapsto y, m^{'} \mapsto p, y^{'} \mapsto x, p^{'} \mapsto m}

σ_{1} = {x, y \mapsto empty, n \mapsto 2} and σ_{2} = {x \mapsto z : 2, y \mapsto n : z}

σ_{1} = {x, y \mapsto empty, n \mapsto 2} and σ_{2} = {x \mapsto z : 2, y \mapsto n : z}

AU = {x : (y : z) = (x : y) : z, empty : x = x, x : empty = x} .

AU = {x : (y : z) = (x : y) : z, empty : x = x, x : empty = x} .

P = ⟨ s =^{?} t, σ_{P} ⟩

P = ⟨ s =^{?} t, σ_{P} ⟩

AU = {x : (y : z) = (x : y) : z, empty : x = x, x : empty = x}

AU = {x : (y : z) = (x : y) : z, empty : x = x, x : empty = x}

s θ =_{AU} tθ and x_{i} θ =_{AU} t_{i} θ

s θ =_{AU} tθ and x_{i} θ =_{AU} t_{i} θ

σ_{1} = {a \mapsto 2, x \mapsto empty, y \mapsto empty} and σ_{2} = {x \mapsto z : 2, y \mapsto a : z} .

σ_{1} = {a \mapsto 2, x \mapsto empty, y \mapsto empty} and σ_{2} = {x \mapsto z : 2, y \mapsto a : z} .

L : empty \to L and empty : L \to L

L : empty \to L and empty : L \to L

x : empty : 1 : empty \to x : 1 : empty \to x : 1 .

x : empty : 1 : empty \to x : 1 : empty \to x : 1 .

\begin{array}[]{rcl}\sigma_{1}&=&\{\mathtt{x}\mapsto 2,\,\mathtt{y}\mapsto\mathtt{a}\}\\ \sigma_{2}&=&\{\mathtt{x}\mapsto\mathtt{y^{\prime}:2},\,\mathtt{y}\mapsto\mathtt{a:y^{\prime}}\}\\ \sigma_{3}&=&\{\mathtt{a}\mapsto 2,\,\mathtt{x}\mapsto\mathtt{empty},\,\mathtt{y}\mapsto\mathtt{empty}\}\end{array}

\begin{array}[]{rcl}\sigma_{1}&=&\{\mathtt{x}\mapsto 2,\,\mathtt{y}\mapsto\mathtt{a}\}\\ \sigma_{2}&=&\{\mathtt{x}\mapsto\mathtt{y^{\prime}:2},\,\mathtt{y}\mapsto\mathtt{a:y^{\prime}}\}\\ \sigma_{3}&=&\{\mathtt{a}\mapsto 2,\,\mathtt{x}\mapsto\mathtt{empty},\,\mathtt{y}\mapsto\mathtt{empty}\}\end{array}

T y p e (< s t r in g >, < p os >) \to {L i s t V a r, A t o mV a r, A t o m E x p r, E m pt y L i s t V a r, e m pt y}

T y p e (< s t r in g >, < p os >) \to {L i s t V a r, A t o mV a r, A t o m E x p r, E m pt y L i s t V a r, e m pt y}

L oo k A h e a d (< s t r in g >, < p os >) \to {t r u e, f a l se}

L oo k A h e a d (< s t r in g >, < p os >) \to {t r u e, f a l se}

P = ⟨ y : 2 =^{?} a : x ⟩

P = ⟨ y : 2 =^{?} a : x ⟩

δ = {a \mapsto 2, x \mapsto empty, y \mapsto empty}

δ = {a \mapsto 2, x \mapsto empty, y \mapsto empty}

P = ⟨ y : 2 =^{?} a : x ⟩

P = ⟨ y : 2 =^{?} a : x ⟩

δ = {x \mapsto a : 1, y \mapsto 1 : 2}

δ = {x \mapsto a : 1, y \mapsto 1 : 2}

P = ⟨ n =^{?} y : n ⟩ δ = {y \mapsto empty}

P = ⟨ n =^{?} y : n ⟩ δ = {y \mapsto empty}

Peer Reviews

No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.

Videos

No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.

Taxonomy

TopicsModel-Driven Software Engineering Techniques · Logic, programming, and type systems · Formal Methods in Verification

Full text

2014 \volumetitleGraph Computation Models

Selected Revised Papers from GCM 2014 \volumeshortSelected Revised Papers from GCM 2014 \guestedsRachid Echahed, Annegret Habel, Mohamed Mosbah

11institutetext: The University of York, UK

A Unification Algorithm for GP 2 (Long Version)

Ivaylo Hristakiev\sponsorThis author’s work is supported by a PhD scholarship of the UK Engineering and Physical Sciences Research Council (EPSRC) and Detlef Plump

Abstract

The graph programming language GP 2 allows to apply sets of rule schemata (or “attributed” rules) non-deterministically. To analyse conflicts of programs statically, graphs labelled with expressions are overlayed to construct critical pairs of rule applications. Each overlay induces a system of equations whose solutions represent different conflicts. We present a rule-based unification algorithm for GP expressions that is terminating, sound and complete. For every input equation, the algorithm generates a finite set of substitutions. Soundness means that each of these substitutions solves the input equation. Since GP labels are lists constructed by concatenation, unification modulo associativity and unit law is required. This problem, which is also known as word unification, is infinitary in general but becomes finitary due to GP’s rule schema syntax and the assumption that rule schemata are left-linear. Our unification algorithm is complete in that every solution of an input equation is an instance of some substitution in the generated set.

keywords:

graph programs, word unification, critical pair analysis

††volume: 71

1 Introduction

A common programming pattern in the graph programming language GP 2 [Plu12, BFPR15] is to apply a set of graph transformation rules as long as possible. To execute such a loop $\{r_{1},\dots,r_{n}\}!$ on a host graph, in each iteration an applicable rule $r_{i}$ is selected and applied. As rule selection and rule matching are non-deterministic, different graphs may result from the loop. Thus, if the programmer wants the loop to implement a function, a static analysis that establishes or refutes functional behaviour would be desirable.

The above loop is guaranteed to produce a unique result if the rule set $\{r_{1},\dots,r_{n}\}$ is terminating and confluent. However, conventional confluence analysis via critical pairs [Plu05] assumes rules with constant labels whereas GP employs rule schemata (or “attributed” rules) whose graphs are labelled with expressions. Confluence of attributed graph transformation rules has been considered in [HKT02, EEPT06, GLEO12], but we are not aware of algorithms that check confluence over non-trivial attribute algebras such as GP’s which includes list concatenation and Peano arithmetic. The problem is that one cannot use syntactic unification (as in logic programming) when constructing critical pairs and checking their joinability, but has to take into account all equations valid in the attribute algebra.

For example, [HKT02] presents a method of constructing critical pairs in the case where the equational theory of the attribute algebra is represented by a confluent and terminating term rewriting system. The algorithm first computes normal forms of the attributes of overlayed nodes and subsequently constructs the most general (syntactic) unifier of the normal forms. This has been shown to be incomplete [EEPT06, p.198] in that the constructed set of critical pairs need not represent all possible conflicts. For, the most general unifier produces identical attributes—but it is necessary to find all substitutions that make attributes equivalent in the algebra’s theory.

Graphs in GP rule schemata are labelled with lists of integer and string expressions, where lists are constructed by concatenation. In host graphs, list entries must be constant values. Integers and strings are subtypes of lists in that they represent lists of length one.

As a simple example, consider the program in Figure 1 for calculating shortest distances. The program expects input graphs with non-negative integers as edge labels, and arbitrary lists as node labels. There must be a unique marked node (drawn shaded) whose shortest distance to each reachable node has to be calculated.

The rule schemata $\mathtt{init}$ and $\mathtt{add}$ append distances to the labels of nodes that have not been visited before, while $\mathtt{reduce}$ decreases the distance of nodes that can be reached by a path that is shorter than the current distance.

To construct the conflicts of the rule schemata $\mathtt{add}$ and $\mathtt{reduce}$ , their left-hand sides are overlayed. For example, the structure of the left-hand graph of $\mathtt{reduce}$ can match the following structure in two different ways:

\begin{picture}(2.5,1.1)(0.0,0.0) { } { } {\put(0.0,0.0){}} {\put(0.0,0.0){}}{\put(0.4,0.6){}}{\put(2.1,0.6){}}\end{picture}

Consider a copy of $\mathtt{reduce}$ in which the variables have been renamed to $\mathtt{x^{\prime}}$ , $\mathtt{m^{\prime}}$ , etc. To match $\mathtt{reduce}$ and its copy differently requires solving the system of equations $\langle\mathtt{x{:}m}=^{?}\mathtt{y^{\prime}{:}p^{\prime}},\,\mathtt{y{:}p}=^{?}\mathtt{x^{\prime}{:}m^{\prime}}\rangle$ . Solutions to these equations should be as general as possible to represent all potential conflicts resulting from the above overlay. In this simple example, it is clear that the substitution

[TABLE]

is a most general solution. It gives rise to the following critical pair:111For simplicity, we ignore the condition of $\mathtt{reduce}$ .

$\begin{array}[]{ccccc}\begin{picture}(2.5,1.1)(0.0,0.0) { } { } {\put(0.0,0.0){}} {\put(0.0,0.0){}}{\put(0.4,0.6){}}{\put(2.1,0.6){}} \put(0.4,0.6){ \raise 0.0pt\hbox to0.0pt{\kern 0.0pt\put(0.0,0.0){{\makebox(0.0,0.0)[]{$ \mathtt{x{:}p{+}n^{\prime}} $}}}\hss}\ignorespaces} \put(2.1,0.6){ \raise 0.0pt\hbox to0.0pt{\kern 0.0pt\put(0.0,0.0){{\makebox(0.0,0.0)[]{$ \mathtt{y{:}p} $}}}\hss}\ignorespaces} \put(0.4,0.6){ \raise-15.6491pt\hbox to0.0pt{\kern 0.0pt\put(0.0,-198825.0){{\makebox(0.0,0.0)[]{\tiny 1}}}\hss}\ignorespaces} \put(2.1,0.6){ \raise-14.22636pt\hbox to0.0pt{\kern 0.0pt\put(0.0,-198825.0){{\makebox(0.0,0.0)[]{\tiny 2}}}\hss}\ignorespaces}{ \put(0.4,0.6){\put(2.1,0.6){\put(0.0,792494.0){}}\put(2.1,0.6){\put(0.0,792494.0){\makebox(0.0,0.0)[]{$ \mathtt{n} $}}}}}{ \put(2.1,0.6){\put(0.4,0.6){\put(0.0,-951002.0){}}\put(0.4,0.6){\put(0.0,-951002.0){\makebox(0.0,0.0)[]{$ \mathtt{n^{\prime}} $}}}}}\end{picture}&\begin{picture}(0.8,1.1)(0.0,0.0) { \put(0.4,0.6){}\put(0.4,0.6){\makebox(0.0,0.0)[]{$ \Leftarrow $}}}\end{picture}&\begin{picture}(2.5,1.1)(0.0,0.0) { } { } {\put(0.0,0.0){}} {\put(0.0,0.0){}}{\put(0.4,0.6){}}{\put(2.1,0.6){}} \put(0.4,0.6){ \raise 0.0pt\hbox to0.0pt{\kern 0.0pt\put(0.0,0.0){{\makebox(0.0,0.0)[]{$ \mathtt{x{:}m} $}}}\hss}\ignorespaces} \put(2.1,0.6){ \raise 0.0pt\hbox to0.0pt{\kern 0.0pt\put(0.0,0.0){{\makebox(0.0,0.0)[]{$ \mathtt{y{:}p} $}}}\hss}\ignorespaces} \put(0.4,0.6){ \raise-14.22636pt\hbox to0.0pt{\kern 0.0pt\put(0.0,-198825.0){{\makebox(0.0,0.0)[]{\tiny 1}}}\hss}\ignorespaces} \put(2.1,0.6){ \raise-14.22636pt\hbox to0.0pt{\kern 0.0pt\put(0.0,-198825.0){{\makebox(0.0,0.0)[]{\tiny 2}}}\hss}\ignorespaces}{ \put(0.4,0.6){\put(2.1,0.6){\put(0.0,792494.0){}}\put(2.1,0.6){\put(0.0,792494.0){\makebox(0.0,0.0)[]{$ \mathtt{n} $}}}}}{ \put(2.1,0.6){\put(0.4,0.6){\put(0.0,-951002.0){}}\put(0.4,0.6){\put(0.0,-951002.0){\makebox(0.0,0.0)[]{$ \mathtt{n^{\prime}} $}}}}}\end{picture}&\begin{picture}(0.8,1.1)(0.0,0.0) { \put(0.4,0.6){}\put(0.4,0.6){\makebox(0.0,0.0)[]{$ \Rightarrow $}}}\end{picture}&\begin{picture}(2.5,1.1)(0.0,0.0) { } { } {\put(0.0,0.0){}} {\put(0.0,0.0){}}{\put(0.4,0.6){}}{\put(2.1,0.6){}} \put(0.4,0.6){ \raise 0.0pt\hbox to0.0pt{\kern 0.0pt\put(0.0,0.0){{\makebox(0.0,0.0)[]{$ \mathtt{x{:}m} $}}}\hss}\ignorespaces} \put(2.1,0.6){ \raise 0.0pt\hbox to0.0pt{\kern 0.0pt\put(0.0,0.0){{\makebox(0.0,0.0)[]{$ \mathtt{y{:}m{+}n} $}}}\hss}\ignorespaces} \put(0.4,0.6){ \raise-14.22636pt\hbox to0.0pt{\kern 0.0pt\put(0.0,-198825.0){{\makebox(0.0,0.0)[]{\tiny 1}}}\hss}\ignorespaces} \put(2.1,0.6){ \raise-14.22636pt\hbox to0.0pt{\kern 0.0pt\put(0.0,-198825.0){{\makebox(0.0,0.0)[]{\tiny 2}}}\hss}\ignorespaces}{ \put(0.4,0.6){\put(2.1,0.6){\put(0.0,792494.0){}}\put(2.1,0.6){\put(0.0,792494.0){\makebox(0.0,0.0)[]{$ \mathtt{n} $}}}}}{ \put(2.1,0.6){\put(0.4,0.6){\put(0.0,-951002.0){}}\put(0.4,0.6){\put(0.0,-951002.0){\makebox(0.0,0.0)[]{$ \mathtt{n^{\prime}} $}}}}}\end{picture}\end{array}$

In general though, equations can arise that have several independent solutions. For example, the equation $\langle\mathtt{n{:}x}=^{?}\mathtt{y{:}2}\rangle$ (with $\mathtt{n}$ of type $\mathtt{int}$ and $\mathtt{x}$ , $\mathtt{y}$ of type $\mathtt{list}$ ) has the minimal solutions

[TABLE]

where $\mathtt{empty}$ represents the empty list and $\mathtt{z}$ is a list variable.

Seen algebraically, we need to solve equations modulo the associativity and unit laws

[TABLE]

This problem is similar to word unification [BS01], which attempts to solve equations modulo associativity. (Some authors consider $AU$ -unification as word unification, e.g. [Jaf90]). Solvability of word unification is decidable, albeit in PSPACE [Pla99], but there is not always a finite complete set of solutions. The same holds for AU-unification (see Section 3). Fortunately, GP’s syntax for left-hand sides of rule schemata forbids labels with more than one list variable. It turns out that by additionally forbidding shared list variables between different left-hand labels of a rule, rule overlays induce equation systems possessing finite complete sets of solutions.

This paper is the first step towards a static confluence analysis for GP programs. In Section 3, we present a rule-based unification algorithm for equations between left-hand expressions of rule schemata. We show that the algorithm always terminates and that it is sound in that each substitution generated by the algorithm is an AU-unifier of the input equation. Moreover, the algorithm is complete in that every unifier of the input equation is an instance of some unifier in the computed set of solutions.

This paper is an extended version of the workshop paper [HP15].

2 GP Rule Schemata

We refer to [Plu12, BFPR15] for the definition of GP and more example programs. In this section, we define (unconditional) rule schemata which are the “building blocks” of graph programs.

A graph over a label set $\mathcal{C}$ is a system $G=(V,E,s,t,l,m)$ , where $V$ and $E$ are finite sets of nodes (or vertices) and edges, $s,t\colon E\to V$ are the source and target functions for edges, $l\colon V\to\mathcal{C}$ is the node labelling function and $m\colon E\to\mathcal{C}$ is the edge labelling function. We write $\mathcal{G}(\mathcal{C})$ for the class of all graphs over $\mathcal{C}$ .

Figure 2 shows an example for the declaration of a rule schema.

The types $\mathtt{int}$ and $\mathtt{string}$ represent integers and character strings. Type $\mathtt{atom}$ is the union of $\mathtt{int}$ and $\mathtt{string}$ , and $\mathtt{list}$ represents lists of atoms. Given lists $l_{1}$ and $l_{2}$ , we write $l_{1}\mathop{\mathtt{:}}l_{2}$ for the concatenation of $l_{1}$ and $l_{2}$ . The empty list is denoted by $\mathtt{empty}$ . In pictures of graphs, nodes or edges without label (such as the dashed edge in Figure 2) are implicitly labelled with the empty list. We equate lists of length one with their entry to obtain the syntactic and semantic subtype relationships shown in Figure 3. For example, all labels in Figure 2 are list expressions.

Figure 4 gives a grammar in Extended Backus-Naur Form defining the abstract syntax of labels. The function length return the length of a variable, while indeg and outdeg access the indegree resp. outdegree of a left-hand node in the host graph.

Figure 4 defines four syntactic categories of expressions: Integer, String, Atom and List, where Integer and String are subsets of Atom which in turn is a subset of List. Category Node is the set of node identifiers used in rule schemata. Moreover, IVar, SVar, AVar and LVar are the sets of variables of type $\mathtt{int}$ , $\mathtt{string}$ , $\mathtt{atom}$ and $\mathtt{list}$ . We assume that these sets are disjoint and define $\mathrm{Var}=\mathrm{IVar}\cup\mathrm{SVar}\cup\mathrm{AVar}\cup\mathrm{LVar}$ . The mark components of labels are represented graphically rather than textually.

Each expression $l$ has a unique smallest type, denoted by $\mathrm{type}(l)$ , which can be read off the hierarchy in Figure 3 after $l$ has been normalised with the rewrite rules shown at the beginning of Subsection 3.2. We write $\mathrm{type}(l_{1})<\mathrm{type}(l_{2})$ or $\mathrm{type}(l_{1})\leq\mathrm{type}(l_{2})$ to compare types according to the subtype hierarchy. If the types of $l_{1}$ and $l_{2}$ are incomparable, we write $\mathrm{type}(l_{1})\mathop{\|}\mathrm{type}(l_{2})$ .

The values of rule schema variables at execution time are determined by graph matching. To ensure that matches induce unique “actual parameters”, expressions in the left graph of a rule schema must have a simple shape.

Definition 2.1 (Simple expression).

A simple expression contains no arithmetic operators, no length or degree operators, no string concatenation, and at most one occurrence of a list variable.

In other words, simple expressions contain no unary or binary operators except list concatenation, and at most one occurrence of a list variable. For example, given the variable declarations of Figure 2, a:x and y:n:n are simple expressions whereas $\mathtt{n\ast 2}$ or x:y are not simple.

Our definition of simple expressions is more restrictive than that in [Plu12] because we exclude string concatenation and the unary minus. These operations (especially string concatenation) would considerably inflate the unification algorithm and its completeness proof, without posing a substantial challenge.

Definition 2.2 (Rule schema).

A rule schema $\langle L,\,R,\,I\rangle$ consists of graphs $L,R$ in $\mathcal{G}(\mathrm{Label})$ and a set $I$ , the interface, such that $I=V_{L}\cap V_{R}$ . All labels in $L$ must be simple and all variables occurring in $R$ must also occur in $L$ .

When a rule schema is graphically declared, as in Figure 2, the interface $I$ is represented by the node numbers in $L$ and $R$ . Nodes without numbers in $L$ are to be deleted and nodes without numbers in $R$ are to be created. All variables in $R$ have to occur in $L$ so that for a given match of $L$ in a host graph, applying the rule schema produces a graph that is unique up to isomorphism.

Assumption 1 (Left-linearity).

We assume that rule schemata $\langle L,\,R,\,I\rangle$ are left-linear, that is, the labels of different nodes or edges in $L$ do not contain the same list variable.

This assumption is necessary to ensure that the solutions of the equations resulting from overlaying two rule schemata can be represented by a finite set of unifiers. For example, without this assumption it is easy to construct two rule schemata that induce the system of equations $\langle\mathtt{x:1=^{?}y,\;y=^{?}1:x}\rangle$ . This system has solutions $\{\mathtt{x\mapsto empty,y\mapsto 1}\}$ , $\{\mathtt{x\mapsto 1,y\mapsto 1:1}\}$ ,

$\{\mathtt{x\mapsto 1:1,y\mapsto 1:1:1}\},\ldots$ which form a infnite, minimal and compete set of solutions (See Definition 3.3 below).

3 Unification

We start with introducing some technical notions such as substitutions, unification problems and complete sets of unifiers. Then, in Subsection 3.2, we present our unification algorithm. In Subsection 3.3, we prove that the algorithm terminates and is sound.

3.1 Preliminaries

A substitution is a family of mappings $\sigma=(\sigma_{X})_{X\in\{I,S,A,L\}}$ where $\sigma_{I}\colon\mathrm{IVar}\to\mathrm{Integer}$ , $\sigma_{S}\colon\mathrm{SVar}\to\mathrm{String}$ , $\sigma_{A}\colon\mathrm{AVar}\to\mathrm{Atom}$ , $\sigma_{L}\colon\mathrm{LVar}\to\mathrm{List}$ . Here Integer, String, Atom and List are the sets of expressions defined by the GP label grammar of Figure 4. For example, if $\mathtt{z}\in\mathrm{LVar}$ , $\mathtt{x}\in\mathrm{IVar}$ and $\mathtt{y}\in\mathrm{SVar}$ , then we write $\sigma=\{\mathtt{x}\mapsto\mathtt{x+1},\,\mathtt{z}\mapsto\mathtt{y:-x:y}\}$ for the substitution that maps $\mathtt{x}$ to $\mathtt{x+1}$ , $\mathtt{z}$ to $\mathtt{y:-x:y}$ and every other variable to itself.

Applying a substitution $\sigma$ to an expression $t$ , denoted by $t\sigma$ , means to replace every variable $x$ in $t$ by $\sigma(x)$ simultaneously. In the above example, $(\mathtt{z:-x})\sigma=\mathtt{y:-x:y:-(x+1)}$ .

By $\mathrm{Dom}(\sigma)$ we denote the set $\{x\in\mathrm{Var}\mid\sigma(x)\neq x\}$ and by $\mathrm{VRan}(\sigma)$ the set of variables occurring in the expressions $\{\sigma(x)\mid x\in\mathrm{Var}\}$ . A substitution $\sigma$ is idempotent if $\mathrm{Dom}(\sigma)\mathop{\cap}\mathrm{VRan}(\sigma)~{}=~{}\emptyset$ . The composition of two substitutions $\sigma$ and $\theta$ , is defined as $x(\sigma\circ\theta)=\begin{cases}(x\sigma)\theta&\text{if~{}}x\in\mathrm{Dom}(\sigma)\\ x\theta&\text{otherwise}\end{cases}$ and is an associative operation.

Definition 3.1 (Unification problem).

A unification problem is a pair of an equation and a substitution

[TABLE]

where $s$ and $t$ are simple list expressions without common variables.

The symbol $=^{?}$ signifies that the equation must be solved rather than having to hold for all values of variables. The purpose of $\sigma_{P}$ is for the unification algorithm (Section 3.2) to record a partial solution. An illustration of this concept will be seen in Figure 8.

In section 2, we already assumed that GP rule schemata need to be left-linear. Now, the problem of solving a system of equations $\{s_{1}=t_{1},s_{2}=t_{2}\}$ can be broken down to solving individual equations and combining the answers - if $\sigma_{1}$ and $\sigma_{2}$ are solutions to each individual equation, then $\sigma_{1}\cup\sigma_{2}$ is a solution to the combined problem as $\sigma_{1}$ and $\sigma_{2}$ do not share variables.

Consider the equational axioms for associativity and unity,

[TABLE]

where $\mathtt{x},\mathtt{y},\mathtt{z}$ are variables of type list, and let $=_{\mathrm{AU}}$ be the equivalence relation on expressions generated by these axioms.

Definition 3.2 (Unifier).

Given a unification problem $P=\langle s=^{?}t,\sigma_{P}\rangle$ a unifier of $P$ a is a substitution $\theta$ such that

[TABLE]

for each binding $\{\mathtt{x_{i}\mapsto t_{i}}\}$ in $\sigma_{P}$ .

The set of all unifiers of $P$ is denoted by $\mathcal{U}(P)$ . We say that $P$ is unifiable if $\mathcal{U}(P)\neq\emptyset$ .

The special unification problem $\mathtt{fail}$ represents failure and has no unifiers. A problem $P~{}=~{}\langle s=^{?}t,\varnothing\rangle$ is initial and $P=\langle\varnothing,\sigma_{P}\rangle$ is solved.

A substitution $\sigma$ is more general on a set of variables $X$ than a substitution $\theta$ if there exists a substitution $\lambda$ such that $x\theta=_{\mathrm{AU}}x\sigma\lambda$ for all $x\in X$ . In this case we write $\sigma\leqq_{X}\theta$ and say that $\theta$ is an instance of $\sigma$ on $X$ . Substitutions $\sigma$ and $\theta$ are equivalent on $X$ , denoted by $\sigma=_{X}\theta$ , if $\sigma\leqq_{X}\theta$ and $\theta\leqq_{X}\sigma$ .

Definition 3.3 (Complete set of unifiers [Plo72]).

A set $\mathcal{C}$ of substitutions is a complete set of unifiers of a unification problem $P$ if

(Soundness) $\mathcal{C}\subseteq\mathcal{U}(P)$ , that is, each substitution in $\mathcal{C}$ is a unifier of $P$ , and 2. 2.

(Completeness) for each $\theta\in\mathcal{U}(P)$ there exists $\sigma\in\mathcal{C}$ such that $\sigma\leqq_{X}\theta$ , where $X~{}=~{}\mathrm{Var}(P)$ is the set of variables occurring in $P$ .

Set $\mathcal{C}$ is also minimal if each pair of distinct unifiers in $\mathcal{C}$ are incomparable with respect to $\leqq_{X}$ .

If a unification problem $P$ is not unifiable, then the empty set $\varnothing$ is a minimal complete set of unifiers of $P$ .

For simplicity, we replace $=^{?}$ with $=$ in unification problems from now on.

Example 3.4.

The minimal complete set of unifiers of the problem $\langle\mathtt{a:x}=\mathtt{y:2}\rangle$ (where a is an atom variable and x,y are list variables) is $\{\sigma_{1},\sigma_{2}\}$ with

[TABLE]

We have $\sigma_{1}(\mathtt{a:x})=\mathtt{2:empty}=_{\mathrm{AU}}\mathtt{2}=_{\mathrm{AU}}\mathtt{empty:2}=\sigma_{1}(\mathtt{y:2})$ and $\sigma_{2}(\mathtt{a:x})=\mathtt{a:z:2}=\sigma_{2}(\mathtt{y:2})$ . Other unifiers such as $\sigma_{3}=\{\mathtt{x}\mapsto 2,\,\mathtt{y}\mapsto\mathtt{a}\}$ are instances of $\sigma_{2}$ .

3.2 Unification Algorithm

We start with some notational conventions for the rest of this section:

•

$L,M$ stand for simple expressions,

•

$\mathtt{x,y,z}$ stand for variables of any type (unless otherwise specified),

•

$\mathtt{a,b}$ stand for

(i)

simple string or integer expressions, or 2. (ii)

string, integer or atom variables

•

$\mathtt{s,t}$ stand for

(i)

simple string or integer expressions, or 2. (ii)

variables of any type

Preprocessing.

Given a unification problem $P=\langle s=^{?}t,\sigma\rangle$ , we rewrite the terms in $s$ and $t$ using the reduction rules

[TABLE]

where $L$ ranges over list expressions. These reduction rules are applied exhaustively before any of the transformation rules. For example,

[TABLE]

We call this process normalization. In addition, the rules are applied to each instance of a transformation rule (that is, once the formal parameters have been replaced with actual parameters) before it is applied, and also after each transformation rule application.

Transformation rules.

Figure 5 shows the transformation rules, the essence of our approach, in an inference system style where each rule consists of a premise and a conclusion.

[TABLE]

The rules induce a transformation relation $\Rightarrow$ on unification problems. In order to apply any of the rules to a problem $P$ , the problem part of its premise needs to be matched onto $P$ . Subsequently, the boolean condition of the premise is checked and the rule instance is normalized so that its premise is identical to $P$ .

For example, the rule Orient3 can be matched to $P=\langle\mathtt{a:2}=\mathtt{m},\;\sigma\rangle$ (where $\mathtt{a}$ and $\mathtt{m}$ are variables of type $\mathtt{atom}$ and $\mathtt{list}$ , respectively) by setting $\mathtt{y}\mapsto\mathtt{a}$ , $\mathtt{x}\mapsto\mathtt{m}$ , $M\mapsto 2$ , and $L\mapsto\mathtt{empty}$ . The rule instance and its normal form are then

[TABLE]

where the conclusion of the normal form is the result of applying Orient3 to $P$ .

Showing that a unification problem has no solution can be a lengthy affair because we need to compute all normal forms with respect to $\Rightarrow$ . Instead, the rules Occur and Clash1 to Clash4, shown in Figure 6, introduce failure. Failure cuts off parts of the search tree for a given problem $P$ . This is because if $P\Rightarrow\mathrm{fail}$ , then $P$ has no unifiers and it is not necessary to compute another normal form. Effectively, the failure rules have precedence over the other rules. They are justified by the following lemmata.

Lemma 3.5.

A normalised equation $\mathtt{x}=L$ with $\mathtt{x}\neq L$ has no solution if $L$ is a simple expression, $\mathtt{x}\in Var(L)$ and $\mathrm{type}(\mathtt{x})=\texttt{list}$ .

Proof 3.6.

Since $\mathtt{x}\in Var(L)$ and $\mathtt{x}\neq L$ , $L$ is of the form $s_{1}:s_{2}:\ldots:s_{n}$ with $n\geq 2$ and $\mathtt{x}\in Var(s_{i})$ for some $1\leq i\leq n$ . As $L$ is normalised, none of the terms $s_{i}$ contains the constant empty. Also, since $L$ is simple, it contains no list variables other than $\mathtt{x}$ and $\mathtt{x}$ is not repeated. It follows $\sigma(\mathtt{x})\not=_{\mathrm{AU}}\sigma(L)$ for every substitution $\sigma$ .

Lemma 3.7.

Equations of the form $\mathtt{a}:L=\texttt{empty}$ or $\texttt{empty}=\mathtt{a}:L$ have no solution if $\mathtt{a}$ is an atom expression.

Lemma 3.8.

An equation $\mathtt{a}:L=\mathtt{b}:M$ with $\mathtt{a}\neq\mathtt{b}$ has no solution if $\mathtt{a}$ and $\mathtt{b}$ are atom expressions without variables.

The algorithm.

The unification algorithm in Figure 7 starts by normalizing the input equation, as explained above. It uses a queue of unification problems to search the derivation tree of $P$ with respect to $\Rightarrow$ in a breadth-first manner. The first step is to put the normalized problem $P$ on the queue.

The variable $\mathtt{next}$ holds the head of the queue. If $\mathtt{next}$ is in the form $\langle\varnothing,\sigma\rangle$ , then $\sigma$ is a unifier of the original problem and is added to the set U of solutions. Otherwise, the next step is to construct all problems $P^{\prime}$ such that $\mathtt{next}\Rightarrow P^{\prime}$ . If $P^{\prime}$ is $\mathtt{fail}$ , then the derivation tree below $\mathtt{next}$ is ignored, otherwise $P^{\prime}$ gets normalized and enqueued.

An example tree traversed by the algorithm is shown in Figure 8. Nodes are labelled with unification problems and edges represent applications of transformation rules. The root of the tree is the problem $\langle\mathtt{y:2=a:x}\rangle$ to which the rules Decomp1, Subst2 and Subst3 can be applied. The three resulting problems form the second level of the search tree and are processed in turn. Eventually, the unifiers

[TABLE]

are found, which represent a complete set of unifiers of the initial problem. Note that the set is not minimal because $\sigma_{1}$ is an instance of $\sigma_{2}$ .

The algorithm is similar to the A-unification (word unification) algorithm presented in [Sch92] which looks at the head of the problem equation. That algorithm terminates for the special case that the input problem has no repeated variables, and is sound and complete. Our approach can be seen as an extension from A-unification to AU-unification, to handle the unit equations, and presented in the rule-based style of [BS01]. In addition, our algorithm deals with GP’s subtype system.

3.3 Termination and Soundness

We show that the unification algorithm terminates if the input problem contains no repeated list variables, where termination of the algorithm follows from termination of the relation $\Rightarrow$ .

Theorem 3.9 (Termination).

If $P$ is a unification problem without repeated list variables, then there is no infinite sequence $P\Rightarrow P_{1}\Rightarrow P_{2}\Rightarrow\dots$

Proof 3.10.

Define the size $|L|$ of an expression $L$ by

•

[math] if $L=\mathtt{empty}$ ,

•

$1$ if $L$ is an expression of category Atom (see Figure 4) or a list variable,

•

$|M|+|N|+1$ if $L=M:N$ .

We define a lexicographic termination order by assigning to a unification problem $P=\langle L=M,\sigma\rangle$ the tuple $(n_{1},n_{2},n_{3},n_{4})$ , where

•

$n_{1}$ is the size of $P$ , that is, $n_{1}=|L|+|M|$ ;

•

$n_{2}=\begin{cases}0&\text{if~{}}L\text{ starts with a variable}\\ 1&\text{otherwise}\end{cases}$

•

$n_{3}=\begin{cases}1&\text{if~{}}\mathrm{type}(\mathtt{x})>\mathrm{type}(\mathtt{y})\\ 0&\text{otherwise}\end{cases}$

where $\mathtt{x}$ and $\mathtt{y}$ are the starting symbols of $L$ and $M$

•

$n_{4}=|L|$

The table in Figure 9 shows that for each transformation step $P\Rightarrow P^{\prime}$ , the tuple associated with $P^{\prime}$ is strictly smaller than the tuple associated with $P$ in the lexicographic order induced by the components $n_{1}$ to $n_{4}$ .

For most rules, the table entries are easy to check. All the rules except for Orient decrease the size of the input equation $s=^{?}t$ . The Orient rules keep the size equal, but move variables and expressions of a bigger type to the left-hand side.

Lemma 3.11.

If $P\Rightarrow P^{\prime}$ , then $\mathcal{U}(P)\supseteq\mathcal{U}(P^{\prime})$ .

Proof 3.12.

We show that for each transformation rule, a unifier $\theta$ of the conclusion unifies the premise.

Note that for Remove, Decomp3 and Orient1-4, we have that $\sigma_{P^{\prime}}=\sigma_{P}$ .

•

Remove

$\begin{array}[]{lcl}\theta\in\mathcal{U}(\langle\varnothing,\sigma_{P^{\prime}}\rangle)&\iff&\theta\in\mathcal{U}(\langle\varnothing,\sigma_{P}\rangle)\\ &\iff&\theta\in\mathcal{U}(\langle\varnothing,\sigma_{P}\rangle)\wedge L\theta=L\theta\\ &\iff&\theta\in\mathcal{U}(\langle L=L,\sigma_{P}\rangle)\\ \end{array}$

•

Decomp3

$\begin{array}[]{lcl}\theta\in\mathcal{U}(\langle L=M,\sigma_{P^{\prime}}\rangle)&\iff&\theta\in\mathcal{U}(\langle L=M,\sigma_{P}\rangle)\\ &\iff&\theta\in\mathcal{U}(\langle L=M,\sigma_{P}\rangle)\wedge\mathtt{s\theta=s\theta}\\ &\iff&\theta\in\mathcal{U}(\langle\mathtt{s}:L=\mathtt{s}:M,\sigma_{P}\rangle)\\ \end{array}$

•

Decomp1 - We have $\mathtt{x\theta=s\theta}$ and $L\theta=M\theta$ .

Then $(\mathtt{x}:L)\theta=(\mathtt{s}:L)\theta=(\mathtt{s}:M)\theta$ as required.

•

Decomp1’ - We have $\mathtt{x\theta=a\theta}$ and $L\theta=M\theta$ .

Then $(\mathtt{x}:L)\theta=(\mathtt{a}:L)\theta=(\mathtt{a}:M)\theta$ as required.

•

Decomp2 - We have $\mathtt{x\theta=(y:x^{\prime})\theta}$ and $\mathtt{(x^{\prime}}:L)\theta=M\theta$ .

Then $(\mathtt{x}:L)\theta=(\mathtt{y:x^{\prime}}:L)\theta=(\mathtt{y}:M)\theta$ as required.

•

Decomp2’ - We have $\mathtt{y\theta=(x:y^{\prime})\theta}$ and $L\theta=(\mathtt{y^{\prime}}:M)\theta$ .

Then $(\mathtt{y}:M)\theta=(\mathtt{x:y^{\prime}}:M)\theta=(\mathtt{x}:L)\theta$ as required.

•

Decomp4 - We have $\mathtt{x\theta=a\theta}$ and $\mathtt{y}\theta=(\mathtt{empty})\theta=\mathtt{empty}$ .

Then $(\mathtt{a:y})\theta=(\mathtt{x:y})\theta=(\mathtt{x:empty})\theta=\mathtt{x}\theta$ as required.

•

Subst1 - We have $\mathtt{x\theta}=L\theta$

$\begin{array}[]{lcl}\theta\in\mathcal{U}(\langle\varnothing,\sigma_{S^{\prime}}\rangle)&\iff&\theta\in\mathcal{U}(\langle\varnothing,\sigma_{S}\circ(\mathtt{x}\mapsto L)\rangle)\\ &\iff&\theta\in\mathcal{U}(\langle\varnothing,\sigma_{S}\circ(\mathtt{x}\mapsto L)\rangle)\wedge\mathtt{x}\theta=L\theta\\ &\iff&\theta\in\mathcal{U}(\langle\mathtt{x}=L,\sigma_{S}\rangle)\\ \end{array}$

•

Subst2 - We have $\mathtt{x}\theta=(\mathtt{empty})\theta$ and $L\theta=M\theta$ .

Then $(\mathtt{x}:L)\theta=(\mathtt{empty}:L)\theta=L\theta=M\theta$ as required.

•

Subst3 - We have $\mathtt{x\theta=(a:x^{\prime})\theta}$ and $\mathtt{(x^{\prime}}:L)\theta=M\theta$ .

Then $(\mathtt{x}:L)\theta=(\mathtt{a:x^{\prime}}:L)\theta=(\mathtt{a}:M)\theta$ as required.

•

Orient1-4 - Since $=_{\mathrm{AU}}$ is an equivalence relation and hence symmetric, a unifier of the conclusion is also a unifier of the premise.

Theorem 3.13 (Soundness).

If $P\Rightarrow^{+}P^{\prime}$ with $P^{\prime}=\langle\varnothing,\sigma_{P^{\prime}}\rangle$ in solved form, then $\sigma_{P^{\prime}}$ is a unifier of $P$ .

Proof 3.14.

We have that $\sigma_{P^{\prime}}$ is a unifier of $P^{\prime}$ by definition. A simple induction with 3.11 shows that $\sigma_{P^{\prime}}$ must be a unifier of $P$ .

3.4 Completeness

In order to prove that our algorithm is complete, by 3.3 we have to show that for any unifier $\delta$ , there is a unifier in our solution set that is more general.

Our proof involves using a selector algorithm that takes a unification problem $\langle s=^{?}t\rangle$ together with an arbitrary unifier $\delta$ , and outputs a path of the unification tree associated with a more general unifier than $\delta$ . This is very similar to [Sie78] where completeness of a A-unification algorithm is shown via such selector.

Lemma 3.15 (Selector Lemma).

There exists an algorithm $\textsf{Select}(\delta,s=^{?}t)$ that takes an equation $s=^{?}t$ and a unifier $\delta$ as input and produces a sequence of selections $B~{}=~{}(b_{1},\ldots,b_{k})$ such that:

•

Unify( $s=^{?}t$ ) has a path specified by $B$ .

•

For all selections $b\in B$ : if $\sigma$ is the substitution corresponding to $b$ , then there exists an instantiation $\lambda$ such that $\sigma\circ\lambda\leq\delta$ .

For the selector algorithm and proof see section 4.

For example, consider the unification problem $\langle\mathtt{y:2=a:x}\rangle$ and $\delta=(\mathtt{x\mapsto 1:2},\mathtt{y\mapsto a:1})$ as a unifier. The unification tree was shown in Figure 8. Select( $\delta,\mathtt{y:2=a:x}$ ) would produce selections $(\textsf{Subst3, Decomp2', Orient1, Subst1})$ , which corresponds to the right-most path in the tree. The unifier at the end of this path is $\sigma=(\mathtt{x\mapsto y^{\prime}:2,y\mapsto a:y^{\prime}})$ which is more general than $\delta$ by instantiation $\lambda=(\mathtt{y^{\prime}\mapsto 1})$ .

Now we are able to state our completeness result, which follows directly from Lemma 3.15.

Theorem 3.16 (Completeness).

For every unifier $\delta$ of a unification problem $\langle s=^{?}t\rangle$ , there exist a unifier $\sigma$ generated by Unify such that $\sigma\leq\delta$ .

4 Proving Completeness: The Select Algorithm

As already stated, the Select algorithm takes a unification problem $s=^{?}t$ together with a unifier $\delta$ , and outputs a path of the unification tree associated with a unifier that is at least as general $\delta$ .

The algorithm itself is presented below, together with several examples of how it works. Afterwards, we are able to prove the Selector Lemma meaning that Select is correct w.r.t. Unify.

Preprocessing

Preprocessing of the problem $s=t$ w.r.t. a unifier $\delta$ involves expanding each variable to the correct number of symbols, i.e. $x\rightarrow x_{1}:\ldots:x_{n}$ where $n=|x\delta|$ .

Call $x$ the parent symbol of $x_{1},\ldots,x_{n}$ , and the expanded strings $\overline{s}$ and $\overline{t}$ .

Furthermore, for each binding $\{x\mapsto empty\}$ in $\delta$ , replace $x$ with $x_{e}$ in s̄ and t̄. When Select sees such an empty list variable, it will be able to select Subst2.

Also, pad the shorter string with extra $\mathtt{empty}$ symbols to make s̄ and t̄ of equal length.

For example, the problem $a:x=y:b$ has unifier $\delta=(x\mapsto acb,y\mapsto acb)$ and the expansion would transform it into $a:x_{1}:x_{2}:x_{3}=y_{1}:y_{2}:y_{3}:b$ where each ”pseudo”-variable can hold exactly one symbol.

The expanded s̄ and t̄ can be represented graphically as the diagram below:

a $x_{1}$$x_{2}$$x_{3}$ s̄ $y_{1}$$y_{2}$$y_{3}$ bt̄mn

Predicates

•

A basic look-ahead is implemented as a predicate $L(s,k)$ that returns the number of adjacent ”pseudo”-variables of $s_{k}$ to the right of $s_{k}$ . If $s_{k}$ has no ”pseudo”-variables or a constant then $L(s,k)=0$ .

For example, for the above strings:

[TABLE]

This predicate is really only useful for list variables.

•

Another predicate

[TABLE]

returns the type of the symbol of $<string>$ at position $<pos>$ .

For example for the string $\overline{s}=a:"a":x_{e}:y:empty$

[TABLE]

•

Another predicate

[TABLE]

determines if the word after the given symbol (or sequence of ”pseudo”-variables when $Type(<string>,<pos>)=ListVar$ ) is not the $\mathtt{empty}$ constant (or the blank symbol $\Delta$ at the end of the preprocessed string).

For example for the string $\overline{s}=x_{1}:x_{2}:a$

[TABLE]

The Select Algorithm

The algorithm is essentially a 3-tape TM with look-ahead. The head looks at both input tapes simultaneously (the ”head” of the current problem) as defined by pointers $m$ and $n$ , and can move each pointer separately and only to the right.

It starts with preprocessing the input problem as explained above. Depending on the predicate values at $m$ and $n$ , specific selections are recorded and pointers are updated. This is repeated until the pointers both reach the end of the input strings.

Select $(s,t,\delta)\to B$ :

Preprocess( $s,t,\delta$ ) $\to\overline{s},\overline{t}$

$m=1,n=1$ // the head position

$B=""$ // initial selection

if $m>length(\overline{s})\text{~{}and~{}}n>length(\overline{t})$ return B

Case analysis on $L(\overline{s},m)$ and $L(\overline{t},n)$ :

Case 1.

$L(\overline{s},m)<L(\overline{t},n)$

Since $L(\overline{t},n)>0$ , $\overline{t_{n}}$ must be a list variable

Do subcase analysis on type of $\overline{s_{m}}$ and look ahead results

Case 1.1.

$Type(\overline{s_{m}})=ListVar$ /* $x:L=y:M$ */

/* It cannot be the case that the $LookAhead(\overline{s_{m}})$ returns $false$ (i.e. $L\neq empty$ ) as $\overline{t_{n}}$ is not of type $EmptyListVar$ ( $L(\overline{t_{n}})>0$ ) */

select Decomp2’ /* $x:L=y:M$ with $L\neq empty$ */

$m=m+1+L(\overline{s_{m}})$ , $n=n+1+L(\overline{s_{m}})$ /* move head to end of shorter substring */

Case 1.2.

$Type(\overline{s_{m}})=AtomVar$ /* $a:L=y:M$ */

select Orient3, swap input tapes and pointers

Case 1.3.

$Type(\overline{s_{m}})=AtomExpr$ /* $a:L=y:M$ */

select Orient1, swap input tapes and pointers

Case 1.4.

$Type(\overline{s_{m}})=EmptyListVar$ /* $x_{e}:L=y:M$ */

/* It cannot be the case that the $LookAhead(\overline{s_{m}})$ returns $false$ (i.e. $L\neq empty$ ) as $\overline{t_{n}}$ is not of type $EmptyListVar$ ( $L(\overline{t_{n}})>0$ ) */

select Subst2, $m$ ++, no change for $n$

Case 1.5.

$Type(\overline{s_{m}})=empty$

/* cannot happen, as $\overline{t_{n}}$ is not of type $EmptyListVar$ ( $L(\overline{t_{n}})>0$ ) and $\delta$ is a unifier */

Case 2.

$L(\overline{s},m)>L(\overline{t},n)$

Since $L(\overline{s},m)>0$ , $\overline{s_{m}}$ must be a list variable

if $LookAhead(\overline{s_{m}})=false$

then (Case 2.1)

select Subst1 /* $\mathtt{x}=\mathtt{y}:M$ */

$m=m+1+L(\overline{s_{m}})$ , $n=length(\overline{t})+1$ /* move head to end of both strings */

else /* $L\neq empty$ */

Case 2.2.

$Type(\overline{t_{n}})=ListVar$

select Decomp2 /* $\mathtt{x}:L=\mathtt{y}:M$ with $L\neq M$ and $\mathtt{x}$ should start with $\mathtt{y}$ */

$m=m+1+L(\overline{t_{n}})$ , $n=n+1+L(\overline{t_{n}})$ /* move head to end of shorter substring */

Case 2.3.

$Type(\overline{t_{n}})=AtomVar~{}or~{}AtomExpr$

select Subst3 /* $\mathtt{x}:L=\mathtt{a}:M$ with $L\neq M$ and $\mathtt{x}$ should start with $\mathtt{a}$ */

$m$ ++, $n$ ++

Case 2.4.

$Type(\overline{t_{n}})=EmptyListVar$

select Decomp2 /* $\mathtt{x}:L=y_{e}:M$ with $L\neq M$ and $\mathtt{x}$ should start with $y$ */

$m$ ++, $n$ ++

Case 2.5.

$Type(\overline{t_{n}})=empty$

/* cannot happen, same reason as 1.5 */

Case 3.

$L(\overline{s},m)=L(\overline{t},n)$

Case 3.1.

$L(\overline{s},m)=L(\overline{t},n)>0$

Both $\overline{s}_{m}$ and $\overline{t}_{n}$ must be list variables

if $LookAhead(\overline{s_{m}})=false$

select Subst1 /* $\mathtt{x}=\mathtt{y}:M$ */

$m=m+1+L(\overline{s_{m}})$ , $n=length(\overline{t})+1$ /* move head to end of both strings */

else /* $L\neq empty$ */

select Decomp1 /* $\mathtt{x}:L=\mathtt{y}:M$ */

$m=m+1+L(\overline{s_{m}})$ , $n=n+1+L(\overline{s_{m}})$ /* move head to next pair of unrelated symbols */

Case 3.2.

$L(\overline{s},m)=L(\overline{t},n)=0$

/* This is the largest subcase because $\overline{s_{m}}$ and $\overline{t_{n}}$ can be of any of the possible types. */

Do case analysis on $Type(\overline{s}_{m})$ and $Type(\overline{t}_{n})$ :

**3.2.1. ** $(ListVar,ListVar)$ – same as 3.1

**3.2.2. ** $(ListVar,AtomVar)$ – same as 3.1

**3.2.3. ** $(ListVar,AtomExpr)$ – same as 3.1

**3.2.4. ** $(ListVar,EmptyListVar)$ – same as 2.4

**3.2.5. ** $(ListVar,empty)$ – cannot happen as $\delta$ is a unifier

**3.2.6. ** $(AtomVar,ListVar)$ – Orient3 (like 1.2)

**3.2.7-8 ** $(AtomVar,AtomVar)$ or $(AtomVar,AtomExpr)$

if $LookAhead(\overline{s_{m}})=false$

if $LookAhead(\overline{t_{n}})=false$

select Subst1 /* $\mathtt{a}=\mathtt{b}$ */

$m$ ++, $n$ ++ /* move head to end of both strings */

else

select Decomp4 /* $\mathtt{a}=\mathtt{b:y}$ with $\delta(\mathtt{y})=\mathtt{empty}$ */

$m$ ++, $n$ ++ /* move head to next pair of unrelated symbols */

else /* $L\neq empty$ */

select Decomp1’ /* $\mathtt{a}:L=\mathtt{b}:M$ */

$m$ ++, $n$ ++ /* move head to next pair of unrelated symbols */

**3.2.9. ** $(AtomVar,EmptyListVar)$ – same as 1.2

*3.2.10. ** $(AtomVar,empty)$ / cannot happen due to failure lemmata */

**3.2.11. ** $(AtomExpr,ListVar)$ – same as 1.3

**3.2.12. ** $(AtomExpr,AtomVar)$ – same as 1.3

**3.2.13. ** $(AtomExpr,AtomExpr)$ –

/* must be the same expression due to not considering the subunification algorithm for String-Char */

select Decomp3, $m$ ++, $n$ ++

**3.2.14. ** $(AtomExpr,EmptyListVar)$ – same as 1.3

*3.2.15. ** $(AtomExpr,empty)$ – / cannot happen due to failure lemmata */

**3.2.16-18. ** $(EmptyListVar,ListVar)$ or $(EmptyListVar,AtomVar)$ or $(EmptyListVar,AtomExpr)$

/* It must be the case that there is something following $\overline{s_{m}}$ for $\delta$ to be a unifier. */

select Subst2, $m$ ++ (like 1.4)

**3.2.19. ** $(EmptyListVar,EmptyListVar)$ – same as 3.1

**3.2.20. ** $(EmptyListVar,empty)$ – select Subst1, $m$ ++, $n=length(\overline{t_{n}})+1$

*3.2.21. ** $(empty,ListVar)$ / cannot happen as $\delta$ is a unifier */

*3.2.22 & 3.2.23 ** $(empty,AtomVar)$ or $(empty,AtomExpr)$ / cannot happen due to failure lemmata */

**3.2.24. ** $(empty,EmptyListVar)$ – select Orient4, swap tapes and pointers

*3.2.25. ** $(empty,empty)$ select Remove / nothing left to solve */

Examples

Below are some examples of how the algorithm behaves when presented with a unification problem and a unifier.

The first two examples are of the problem $P=\langle\mathtt{y:2=^{?}a:x}\rangle$ , with its unification tree already shown in Figure 8. The third example is of the problem $P=\langle\mathtt{n=^{?}y:n}\rangle$ that has a single most general unifier $\sigma=\{\mathtt{y\mapsto empty}\}$ .

Example 4.1.

[TABLE]

$y_{e}$ 2 $\Delta$ s̄ $a$$x_{e}$$\Delta$ t̄select Subst2 $m$ ++(case 3.2.17) $m=1$$n=1$$\rightarrow$$y_{e}$ 2 $\Delta$ s̄ $a$$x_{e}$$\Delta$ t̄select Orient1swap tapes & pointers(case 3.2.12) $m=2$$n=1$$\rightarrow$$y_{e}$ 2 $\Delta$ t̄ $a$$x_{e}$$\Delta$ s̄select Decomp1’ $m$ ++, $n$ ++(case 3.2.8) $n=2$$m=1$$\rightarrow$$y_{e}$ 2 $\Delta$ t̄ $a$$x_{e}$$\Delta$ s̄select Subst1 $m$ ++, $n=3$ (case 3.2.20) $m=2$$n=3$$\rightarrow$$y_{e}$ 2 $\Delta$ s̄ $a$$x_{e}$$\Delta$ t̄end $m=3$$n=3$

Example 4.2.

[TABLE]

$y_{1}$$y_{2}$ 2 $\Delta$ s̄ $a$$x_{1}$$x_{2}$$\Delta$ t̄select Subst3 $m++,n++$ (case 2.3) $m=1$$n=1$$\rightarrow$$y_{1}$$y_{2}$ 2 $\Delta$ s̄ $a$$x_{1}$$x_{2}$$\Delta$ t̄select Decomp2’ $m++,n++$ (case 2.1) $m=2$$n=2$$\rightarrow$$y_{1}$$y_{2}$ 2 $\Delta$ s̄ $a$$x_{1}$$x_{2}$$\Delta$ t̄select Orient1swap tapes & pointers(case 3.2.11) $m=3$$n=3$$\rightarrow$$y_{1}$$y_{2}$ 2 $\Delta$ t̄ $a$$x_{1}$$x_{2}$$\Delta$ s̄select Subst1 $m++,n++$ (case 3.2.3) $m=3$$n=3$$\rightarrow$$\rightarrow$$y_{1}$$y_{2}$ 2 $\Delta$ s̄ $a$$x_{1}$$x_{2}$$\Delta$ t̄end $m=4$$n=4$

Example 4.3.

[TABLE]

$n$$\mathtt{e}$$\Delta$ s̄ $y_{e}$$n$$\Delta$ t̄select Orient3swap tapes & pointers(case 3.2.9) $m=1$$n=1$$\rightarrow$$n$$\mathtt{e}$$\Delta$ t̄ $y_{e}$$n$$\Delta$ s̄select Subst2 $m$ ++(case 3.2.17) $m=1$$n=1$$\rightarrow$$n$$\mathtt{e}$$\Delta$ t̄ $y_{e}$$n$$\Delta$ s̄select Subst1 $m$ ++, $n$ ++(case 3.2.7) $m=2$$n=1$$\rightarrow$$n$$\mathtt{e}$$\Delta$ t̄ $y_{e}$$n$$\Delta$ s̄end $n=2$$m=3$

Lemma 4.4 (Selector Lemma).

Let $B$ be the sequence of selections defined by $\textsf{Select}(\delta,s=^{?}t)$ where $\delta(s)=\delta(t)$

Unify( $s=^{?}t$ ) has a path specified by $B$ .
For all selections $b\in B$ :

•

2.1) the symbols examined by Unify at $b$ are parent symbols of the symbols Select sees at head position $(m,n)$ for selection $b$

•

2.2) if $\sigma$ is the substitution corresponding to selection $b$ , then $\sigma\leq\delta$ , i.e. exist substitution $\lambda$ such that $\sigma\circ\lambda\subseteq\delta$

Proof 4.5.

By induction on the number of the selections $(b_{1},b_{2},\ldots)$ of $B$

Base Case

The initial selection $b_{1}$ of Select is based on the first symbols of $\overline{s}$ and $\overline{t}$ as this is the initial head position ( $m$ and $n$ are initialized to 1). The transformation rules of Unify also examine the head of the initial problem. Also, Select does not throw away list variables that should be removed due to Subst2, so condition 2.1) is trivially satisfied. For 2.2), $\sigma_{1}=\varnothing$ by definition of initial unification problem, and let $\lambda_{1}=\varnothing$ . Therefore $\sigma_{1}\circ\lambda_{1}=\varnothing\subseteq\delta$ as required.

Hypothesis

Assume the statements of the theorem are true for selection $b_{k}$ with a corresponding node in the unification tree $\langle P_{k},\sigma_{k}\rangle$ and let $(m,n)$ be the head position of Select before outputting selection $b_{k+1}$ .

2.1) the symbols at the head of the problem $P_{k}$ ( $\mathtt{x}$ and $\mathtt{y}$ ) are parent symbols of $\overline{s}_{m},\overline{t}_{n}$

2.1) exists substitution $\lambda_{k}$ such that $\sigma_{k}\circ\lambda_{k}\subseteq\delta$

Inductive case

There are several possible cases for the selection $b_{n+1}$ . We have to show that from $b_{n}$ ,

i

Unify can generate selection $b_{k+1}$ (i.e. the selected rule is applicable) and 2. ii

The symbols at the head of the next unification problem $P_{k+1}$ (where $P_{k}\Rightarrow P_{k+1}$ via the rule $b_{k+1}$ ) are parent symbols of $\overline{s}_{m_{new}}$ and $\overline{t}_{n_{new}}$ 3. iii

exists instantiation $\lambda_{n+1}$ such that $\sigma_{n+1}~{}\circ~{}\lambda_{n+1}~{}\subseteq~{}\delta$

For all Orient rules, we can notice that:

•

they do not change the head of the unification problem nor they generate a supplementary substitution $\sigma_{k+1}$ , so conditions ii and iii trivially hold

•

they always swap left-hand side with right-hand side; so does Select for each Orient selection

Therefore, we only need to prove condition i for each Orient selection.

We now have to consider all the cases from $P_{k}$ to $P_{k+1}$ in Select via rule $b_{k+1}$ .

Case 1.

$L(\overline{s},m)<L(\overline{t},n)$

It must be the case that $\overline{t}_{n}$ is a list variable because $L(\overline{t},n)>0$ only for list variables.

Call $\mathtt{x}$ and $\mathtt{y}$ the parent symbols of $\overline{s_{m}}$ and $\overline{t_{n}}$ in $s$ and $t$ .

Case 1.1.

$Type(\overline{s_{m}})=ListVar$

By hypothesis, it follows that $\mathtt{x}$ and $\mathtt{y}$ are also list variables.

Suppose nothing follows $\mathtt{x}$ (i.e. $LookAhead(\overline{s}_{m})=false$ ). Then the unification problem at node $b_{k}$ must be of the form $\mathtt{x}=\mathtt{y}:M$ . However, we have that $L(\overline{s},m)<L(\overline{t},n)$ which contradicts that $\delta$ is a unifier.

Therefore, there must be something following $\mathtt{x}$ . Then the current unification problem must be of the form $\mathtt{x}:L=\mathtt{y}:M$ . Then rule Decomp2’ is applicable (condition i satisfied). Because $\mathtt{x}$ has the shorter expansion by $\delta$ , $\overline{t}_{n+L(\overline{s}_{m})+1}$ is a child variable of $\mathtt{y}$ and condition ii holds.

For iii, let $\lambda_{k}^{\prime}=(\overline{s_{n}}\ldots\overline{s_{m+L(\overline{s}_{m})}}\mapsto T)$ where $T=\delta(\overline{s_{m}}\ldots\overline{s_{m+L(\overline{s}_{m})}})$ . For $\delta$ to be a unifier, it must contain term(s) $(\overline{t_{n}}\ldots\overline{t_{n+L(\overline{s}_{m})}}\mapsto T)$ :

[TABLE]

Case 1.2.

$Type(\overline{s_{m}})=AtomVar$

It holds by hypothesis that $\mathtt{x}$ and $\mathtt{y}$ are atom and list variables so rule Orient3 is applicable.

Case 1.3.

$Type(\overline{s_{m}})=AtomExpr$

The argument is the same as above except that $\mathtt{x}$ is an atom expression and Orient1 becomes applicable.

Case 1.4.

$Type(\overline{s_{m}})=EmptyListVar$

Because $L(\overline{t}_{n})>L(\overline{s}_{m})=0$ , there must be something after $\overline{s_{m+L(\overline{s}_{m})}}$ (i.e. $LookAhead(\overline{s}_{m})=true$ ) for $\delta$ to be a unifier. Also, by hypothesis $\mathtt{x}$ must be a list variable since $\mathtt{x}\delta~{}=~{}\mathtt{empty}$ . Therefore rule Subst2 is applicable (condition i holds). The resulting unification problem is $(\{L=M\}\{\mathtt{x}\mapsto\texttt{empty}\};~{}\sigma_{k}\circ\{\mathtt{x}\mapsto\texttt{empty}\})$ . Select moves the position $m$ by 1 and keeps $n$ , therefore condition ii also holds.

For condition iii:

[TABLE]

Case 1.5.

$Type(\overline{s_{m}})=\mathtt{empty}$

As explained, this subcase cannot occur if $\delta$ is a unifier.

Case 2.

$L(\overline{s},m)>L(\overline{t},n)$

As in the previous case, it follows that $\overline{s}_{m}$ is a list variable with $|\delta(x)|>0$ for its parent symbol $\mathtt{x}$ . By hypothesis, $\mathtt{x}$ is also a list variable.

Case 2.1.

Let $LookAhead(\overline{s}_{m})=false$ , i.e. nothing follows $\mathtt{x}$

The unification problem at node $b_{k}$ must be of the form $\mathtt{x}=L$ so rule Subst1 is applicable (condition i satisfied). Since the resulting unification problem is $\langle\varnothing,\sigma_{k}\circ\{\mathtt{x}\mapsto y:M\}\rangle$ and Select moves the head position to the end of the strings s̄ and t̄, condition ii is satisfied.

For iii, let $\lambda_{k}^{\prime}=(L\mapsto T)$ where $T=\delta(L)$ . For $\delta$ to be a unifier, it must contain term(s) $(\mathtt{x}\mapsto T)$

[TABLE]

Now let $LookAhead(\overline{s}_{m})=true$ and the problem is of the form $\mathtt{x}:L=s:M$ with $L\neq empty$ .

Case 2.2.

$Type(\overline{t_{n}})=ListVar$

By hypothesis, $\mathtt{y}$ must be a list variable. Then rule Decomp2 is applicable (condition i satisfied). Because $\mathtt{x}$ has the longer expansion by $\delta$ , $\overline{s_{m+L(\overline{t}_{n})+1}}$ is a child variable of $\mathtt{x}$ and condition ii holds.

For iii, let $\lambda_{k}^{\prime}=(\overline{s_{n}}\ldots\overline{s_{m+L(\overline{t}_{n})}}\mapsto T)$ where $T=\delta(\overline{s_{m}}\ldots\overline{s_{m+L(\overline{t}_{n})}})$ , and the argument becomes identical to Case 1.1 ( $\mathtt{x}$ starts with $\mathtt{y}$ , so $\sigma_{k+1}=\sigma_{k}\circ\{\mathtt{x}\mapsto\mathtt{y:x^{\prime}}\}$ )

Case 2.3.

$Type(\overline{t_{n}})=AtomVar$ or $Type(\overline{t_{n}})=AtomExpr$

By hypothesis, $\mathtt{y}$ is an atom variable or atom expression. Then the problem is of the form $\mathtt{x}:L=\mathtt{a}:M$ with $L\neq\mathtt{empty}$ . So rule Subst3 is applicable (condition i satisfied). Positions are incremented by 1, so condition ii holds as $\overline{s}_{m+1}$ and $\mathtt{x^{\prime}}$ (in Orient3) must have the same parent symbol.

For iii, let $\lambda_{k}^{\prime}=(\overline{t}_{n}\mapsto T)$ where $T=\delta(\overline{t}_{n})$ . It follows that $\delta$ must contain term ( $\overline{s}_{m}\mapsto T$ ) to be a unifier.

[TABLE]

Case 2.4.

$Type(\overline{t_{n}})=EmptyListVar$

We have that $\overline{t}_{n}$ is of the form $\mathtt{y}_{e}$ where $\mathtt{y}$ is a list variable with $\delta(\mathtt{y})=\mathtt{empty}$ . The unification problem is then of the form $\mathtt{x:L=y:M}$ . Rule Decomp2 becomes applicable

Let $\lambda_{k}^{\prime}=(\mathtt{y\mapsto empty})$

[TABLE]

Case 3.

$L(\overline{s},m)=L(\overline{t},n)$

Case 3.1.

$L(\overline{s},m)=L(\overline{t},n)>0$

It must be the case that $\overline{s}_{m}$ and $\overline{t}_{n}$ are list variables because $L(\overline{s}_{m})>0$ and $L(\overline{t},n)>0$ only for list variables.

By hypothesis, it follows that $\mathtt{x}$ and $\mathtt{y}$ are also list variables.

If there is nothing after the $\mathtt{x}$ (i.e. $LookAhead(\overline{s}_{m})=false$ ). Then Subst1 is applicable and the argument is the same as Case 2.1.

Otherwise, it must be that $L\neq\mathtt{empty}$ so rule Decomp1 is applicable. Here the problem is of the form $\mathtt{x:L=y:M}$ and the generated substitution is $\sigma_{k+1}=\sigma_{k}\circ(\mathtt{x\mapsto y})$ .

For ii, the argument is similar to Case 2.2 except that now both $\overline{s}_{m+L(\overline{s_{m}})+1}$ and $L$ , and $\overline{t}_{n+L(\overline{s_{m}})+1}$ and $M$ must have the same pairs of parent symbols.

Let $\lambda_{k}^{\prime}=(\mathtt{y\mapsto\delta(y)})$ . It must be the case that $\delta$ also contains term $(\mathtt{x\mapsto\delta(y)})$ to be a unifier.

[TABLE]

Case 3.2.

$L(\overline{s},m)=L(\overline{t},n)=0$

This is the largest subcase because $\overline{s_{m}}$ and $\overline{t_{n}}$ can be of any of the possible types.

**3.2.1-3 ** $(ListVar,ListVar)$ or $(ListVar,AtomVar)$ or $(ListVar,AtomExpr)$ –

Same as 3.1 because the parent symbol of $\overline{t}_{n}$ can be matched by $s$ in Decomp1.

**3.2.4. ** $(ListVar,EmptyListVar)$ – same as Case 2.4

**3.2.5. ** $(ListVar,empty)$ – cannot happen as $\delta$ is a unifier

**3.2.6. ** $(AtomVar,ListVar)$ – same as Case 1.2

**3.2.7. ** $(AtomVar,AtomVar)$ or $(AtomVar,AtomExpr)$

•

$LookAhead(\overline{s}_{m})=true$ , i.e. $L\neq\mathtt{empty}$ - then the problem is of the form $\mathtt{a}:L=\mathtt{b}:M$ ( $\mathtt{a}$ and $\mathtt{b}$ are also atom variables by hypothesis) and rule Decomp1’ is applicable. Unify generates $\sigma_{k+1}=\sigma_{k}\circ\{\mathtt{a\mapsto b}\}$ .

Let $\lambda_{k}^{\prime}=(\overline{s}_{m}\mapsto\delta(\overline{s}_{m}))=(\mathtt{a\mapsto\delta(a)})$ . Then $\delta$ must also contain term $(\overline{t}_{n}\mapsto\delta(\overline{s}_{m}))$ to be a unifier:

[TABLE]

•

$LookAhead(\overline{s}_{m})=false$ , i.e. the problem is $\mathtt{a=b:M}$ .

–

If $LookAhead(\overline{t}_{n})=true$ , then $M$ can only be a single list variable for $\delta$ to be a unifier with $\delta(\mathtt{y})=\mathtt{empty}$ . This makes rule Decomp4 applicable. For iii, the argument is the same as in the previous item (with $\sigma_{k+1}=\sigma_{k}\circ\{\mathtt{a\mapsto b}\}$ ).

–

If $LookAhead(\overline{t}_{n})=false$ , then the problem is of the form $\mathtt{a=b}$ , which makes Subst1 is applicable and the argument is the same as Case 2.1

**3.2.9. ** $(AtomVar,EmptyListVar)$ – same as Case 1.2

**3.2.10. ** $(AtomVar,empty)$ – cannot happen due to failure lemmata

**3.2.11. ** $(AtomExpr,ListVar)$ – same as Case 1.3

**3.2.12. ** $(AtomExpr,AtomVar)$ – same as Case 1.3

**3.2.13. ** $(AtomExpr,AtomExpr)$ – Both symbols must be the same atom expression due to not considering the subunification algorithm for String-Char. So rule Decomp3 is applicable. Conditions ii and iii hold trivially.

**3.2.14. ** $(AtomExpr,EmptyListVar)$ – same as 1.3

**3.2.16-18. ** $(EmptyListVar,ListVar)$ or $(EmptyListVar,AtomVar)$ or $(EmptyListVar,AtomExpr)$ It must be the case that there is something following $\overline{s_{m}}$ for $\delta$ to be a unifier. Proceed proof like Case 1.4

**3.2.19. ** $(EmptyListVar,EmptyListVar)$ – same as 3.1

**3.2.20. ** $(EmptyListVar,empty)$

It follows that $\mathtt{x}$ (the parent of $\overline{s}_{m}$ ) is a list variable with $\delta(\mathtt{x})=\mathtt{empty}$ . Also, since there are no repeated list variables, for $\delta$ to be a unifier there must be nothing following $\mathtt{x}$ . So the problem is of the form $\mathtt{x=empty}$ and rule Subst1 is applicable.

For condition iii, proceed as Case 1.4

**3.2.21. ** $(empty,ListVar)$ – cannot happen because $\delta$ is a unifier

**3.2.22 & 3.2.23 ** $(empty,AtomVar)$ or $(empty,AtomExpr)$ – cannot happen due to failure lemmata

**3.2.24. ** $(empty,EmptyListVar)$

It follows that $\mathtt{y}$ (the parent of $\overline{t}_{n}$ ) is a list variable with $\delta(\mathtt{y})=\mathtt{empty}$ . So the problem has the form $\mathtt{empty=x}:L$ and rule Orient4 is applicable.

**3.2.25. ** $(empty,empty)$

It follows that rule Remove is applicable. Conditions ii and iii hold trivially.

5 Conclusion

This paper presents groundwork for a static confluence analysis of GP programs. We have constructed a rule-based unification algorithm for systems of equations with left-hand expressions of rule schemata, and have shown that the algorithm always terminates and is sound. Moreover, we have proved completeness in that every unifier of the input problem is an instance of some unifier in the computed set of solutions.

Future work includes establishing a Critical Pair Lemma in the sense of [Plu05]; this entails developing a notion of independent rule schema applications, as well as restriction and embedding theorems for derivations with rule schemata. Another topic is to consider critical pairs of conditional rule schemata (see [EGH*+*12]).

In addition, since critical pairs contain graphs labelled with expressions, checking joinability of critical pairs will require sufficient conditions under which equivalence of expressions can be decided. This is because the theory of GP’s label algebra includes the undecidable theory of Peano arithmetic.

{acknowledge}

We thank the anonymous referees of GCM 2014 for their comments on previous versions of this paper.

Bibliography14

The reference list from the paper itself. Each links out to its DOI / PubMed record.

1[BFPR 15] C. Bak, G. Faulkner, D. Plump, C. Runciman. A Reference Interpreter for the Graph Programming Language GP 2. In Proc. Graphs as Models (Ga M 2015) . Electronic Proceedings in Theoretical Computer Science 181, pp. 48–64. 2015. 10.4204/EPTCS.181 · doi ↗
2[BS 01] F. Baader, W. Snyder. Unification Theory. In Robinson and Voronkov (eds.), Handbook of Automated Reasoning . Pp. 445–532. Elsevier and MIT Press, 2001.
3[EEPT 06] H. Ehrig, K. Ehrig, U. Prange, G. Taentzer. Fundamentals of Algebraic Graph Transformation . Monographs in Theoretical Computer Science. Springer-Verlag, 2006.
4[EGH + 12] H. Ehrig, U. Golas, A. Habel, L. Lambers, F. Orejas. M-Adhesive Transformation Systems with Nested Application Conditions. Part 2: Embedding, Critical Pairs and Local Confluence. Fundamenta Informaticae 118(1):35–63, 2012.
5[GLEO 12] U. Golas, L. Lambers, H. Ehrig, F. Orejas. Attributed Graph Transformation with Inheritance: Efficient Conflict Detection and Local Confluence Analysis Using Abstract Critical Pairs. Theoretical Computer Science 424:46–68, 2012. 10.1016/j.tcs.2012.01.032 · doi ↗
6[HKT 02] R. Heckel, J. M. Küster, G. Taentzer. Confluence of Typed Attributed Graph Transformation Systems. In Proc. International Conference on Graph Transformation (ICGT 2002) . Lecture Notes in Computer Science 2505, pp. 161–176. Springer-Verlag, 2002.
7[HP 15] I. Hristakiev, D. Plump. A Unification Algorithm for GP 2. In Graph Computation Models (GCM 2014), Revised Selected Papers . Electronic Communications of the EASST 71. 2015.
8[Jaf 90] J. Jaffar. Minimal and Complete Word Unification. Journal of the ACM 37(1):47–85, 1990.

TL;DR

Contribution

Findings

Abstract

Peer Reviews

Videos

Taxonomy

A Unification Algorithm for GP 2 (Long Version)

Abstract

keywords:

1 Introduction

2 GP Rule Schemata

Definition 2.1** (Simple expression).**

Definition 2.2** (Rule schema).**

Assumption 1** (Left-linearity).**

3 Unification

3.1 Preliminaries

Definition 3.1** (Unification problem).**

Definition 3.2** (Unifier).**

Definition 3.3** (Complete set of unifiers [Plo72]).**

Example 3.4**.**

3.2 Unification Algorithm

Preprocessing.

Transformation rules.

Lemma 3.5**.**

Proof 3.6**.**

Lemma 3.7**.**

Lemma 3.8**.**

The algorithm.

3.3 Termination and Soundness

Theorem 3.9** (Termination).**

Proof 3.10**.**

Lemma 3.11**.**

Proof 3.12**.**

Theorem 3.13** (Soundness).**

Proof 3.14**.**

3.4 Completeness

Lemma 3.15** (Selector Lemma).**

Theorem 3.16** (Completeness).**

4 Proving Completeness: The Select Algorithm

Preprocessing

Predicates

The Select Algorithm

Case 1**.**

Case 1.1**.**

Case 1.2**.**

Case 1.3**.**

Case 1.4**.**

Case 1.5**.**

Case 2**.**

Case 2.2**.**

Case 2.3**.**

Case 2.4**.**

Case 2.5**.**

Case 3**.**

Case 3.1**.**

Case 3.2**.**

Examples

Example 4.1**.**

Example 4.2**.**

Example 4.3**.**

Lemma 4.4** (Selector Lemma).**

Proof 4.5**.**

Base Case

Hypothesis

Inductive case

Case 1**.**

Case 1.1**.**

Case 1.2**.**

Case 1.3**.**

Case 1.4**.**

Case 1.5**.**

Case 2**.**

Case 2.1**.**

Case 2.2**.**

Case 2.3**.**

Case 2.4**.**

Case 3**.**

Case 3.1**.**

Case 3.2**.**

Definition 2.1 (Simple expression).

Definition 2.2 (Rule schema).

Assumption 1 (Left-linearity).

Definition 3.1 (Unification problem).

Definition 3.2 (Unifier).

Definition 3.3 (Complete set of unifiers [Plo72]).

Example 3.4.

Lemma 3.5.

Proof 3.6.

Lemma 3.7.

Lemma 3.8.

Theorem 3.9 (Termination).

Proof 3.10.

Lemma 3.11.

Proof 3.12.

Theorem 3.13 (Soundness).

Proof 3.14.

Lemma 3.15 (Selector Lemma).

Theorem 3.16 (Completeness).

Case 1.

Case 1.1.

Case 1.2.

Case 1.3.

Case 1.4.

Case 1.5.

Case 2.

Case 2.2.

Case 2.3.

Case 2.4.

Case 2.5.

Case 3.

Case 3.1.

Case 3.2.

Example 4.1.

Example 4.2.

Example 4.3.

Lemma 4.4 (Selector Lemma).

Proof 4.5.

Case 1.

Case 1.1.

Case 1.2.

Case 1.3.

Case 1.4.

Case 1.5.

Case 2.

Case 2.1.

Case 2.2.

Case 2.3.

Case 2.4.

Case 3.

Case 3.1.

Case 3.2.