Sharing Equality is Linear

TL;DR

This paper introduces the first linear-time algorithm for checking equality of shared lambda-terms, significantly improving previous polynomial bounds by leveraging DAG representations and bisimulation techniques.

Contribution

It presents a novel linear-time algorithm for sharing equality of lambda-terms, enhancing efficiency over existing polynomial-time methods.

Findings

First linear-time sharing equality algorithm for lambda-terms

Uses DAG representation and bisimulation techniques

Improves computational bounds from polynomial to linear

Abstract

The $\lambda$-calculus is a handy formalism to specify the evaluation of higher-order programs. It is not very handy, however, when one interprets the specification as an execution mechanism, because terms can grow exponentially with the number of $\beta$-steps. This is why implementations of functional languages and proof assistants always rely on some form of sharing of subterms. These frameworks however do not only evaluate $\lambda$-terms, they also have to compare them for equality. In presence of sharing, one is actually interested in the equality---or more precisely $\alpha$-conversion---of the underlying unshared $\lambda$-terms. The literature contains algorithms for such a sharing equality, that are polynomial in the sizes of the shared terms. This paper improves the bounds in the literature by presenting the first linear time algorithm. As others before us, we are inspired by Paterson and Wegman's algorithm for first-order unification, itself based on representing terms with sharing as DAGs, and sharing equality as bisimulation of DAGs.

Equations

$$\begin{array}[]{r\colspace rcl}\textsc{(Named) Terms}&\tm,\tmtwo&\grameq&\var\mid\lambda{\var}.\tm\mid\tm~{}\tmtwo\end{array}$$

$$\begin{array}[]{r\colspace rcl}\textsc{(l.n.) Terms}&\tm,\tmtwo&\grameq&\underline{i}\mid\overline{a}\mid\tm\,\tmtwo\mid\lambda\tm\quad(i\in\mathbb{N},\,a\in\mathbb{A})\end{array}$$

$$d::=\text{pleft}\mid \text{pdown}\mid \text{pright}$$

$$\text{tra}::=ϵ\mid \text{pcons}d\text{tra}$$

$$\mathtt{index}(\text{nodel}\mid \text{Path}\text{tra}\text{node}\text{nodel})$$

$$\mathtt{index}(\text{nodel}\mid \text{Pathp}\text{pcons}d\text{tra}\text{node}\text{nodelx})$$

$$\mathtt{index}(\text{nodel}\mid \text{Pathp}\text{pcons}d\text{tra}\text{node}\text{nodex})$$

$$(G,\text{undir},\mathtt{canonic},\text{building},\mathtt{queue},\mathtt{active})$$

$$\sum \{\ast \}\#parents(\text{node})+\#edges(\sim ,\text{node})+1\mid \text{lx@crefcreftypecap refnumvq-peek is executed with local }\text{node}$$

$$\le$$

$$=$$

$$O(|N|)+O(|N|)+O(|N|+|E|+|\text{Que}|)=O(|N|+|E|+|\text{Que}|).$$

Full text

These frameworks however do not only evaluate \lats, they also have to compare them for equality. In presence of sharing, one is actually interested in equality of the underlying unshared \lats. The literature contains algorithms for such a sharing equality, that are polynomial in the sizes of the shared terms.

This paper improves the bounds in the literature by presenting the first linear time algorithm. As others before us, we are inspired by Paterson and Wegman’s algorithm for first-order unification, itself based on representing terms with sharing as DAGs, and sharing equality as bisimulation of DAGs. Beyond the improved complexity, a distinguishing point of our work is a dissection of the involved concepts. In particular, we show that the algorithm computes the smallest bisimulation between the given DAGs, if any.

lambda-calculus, sharing, alpha-equivalence, bisimulation

1. Introduction

Origin and Downfall of the Problem

For as strange as it may sound, the \lac is not a good setting for evaluating and representing higher-order programs. It is an excellent specification framework, but—it is simply a matter of fact—no tool based on the \lac implements it as it is.

Reasonable evaluation and sharing.

Fix a dialect $\lambda_{X}$ of the \lac with a deterministic evaluation strategy $\to_{X}$, and note ${\tt nf}_{X}(\tm)$ the normal form of $\tm$ with respect to $\to_{X}$. If the \lac were a reasonable execution model then one would at least expect that mechanizing an evaluation sequence $\tm\to_{X}^{n}{\tt nf}_{X}(\tm)$ on random access machines (RAM) would have a cost polynomial in the size of $\tm$ and in the number $n$ of $\beta$-steps. In this way a program of $\lambda_{X}$ evaluating in a polynomial number of steps can indeed be considered as having polynomial cost.

Unfortunately, this is not the case, at least not literally. The problem is called size explosion: there are families of terms whose size grows exponentially with the number of evaluation steps, obtained by nesting duplications one inside the other—simply writing down the result ${\tt nf}_{X}(\tm)$ may then require cost exponential in $n$.

In many cases sharing is the cure because size explosion is caused by an unnecessary duplications of subterms, that can be avoided if such subterms are instead shared, and evaluation is modified accordingly.

The idea is to introduce an intermediate setting $\lambda_{{\tt sh}X}$ where $\lambda_{X}$ is refined with sharing (we are vague about sharing on purpose) and evaluation in $\lambda_{X}$ is simulated by some refinement $\to_{{\tt sh}X}$ of $\to_{X}$. A term with sharing $\tm$ represents the ordinary term $\tm{\downarrow}\,$ obtained by unfolding the sharing in $\tm$—the key point is that $\tm$ can be exponentially smaller than $\tm{\downarrow}\,$. Evaluation in $\lambda_{{\tt sh}X}$ produces a shared normal form ${\tt nf}_{{\tt sh}X}(\tm)$ that is a compact representation of the ordinary result, that is, such that ${\tt nf}_{{\tt sh}X}(\tm){\downarrow}\,={\tt nf}_{X}(\tm{\downarrow}\,)$. The situation can then be refined as in the following diagram:

$\lambda_{X}$RAM\lambda_{{\tt sh}X}$$polynomial$$polynomial$$polynomial

Let us explain it. One says that $\lambda_{X}$ is reasonably implementable if both the simulation of $\lambda_{X}$ in $\lambda_{{\tt sh}X}$ up to sharing and the mechanization of $\lambda_{{\tt sh}X}$ can be done in time polynomial in the size of the initial term $\tm$ and of the number $n$ of $\beta$-steps. If $\lambda_{X}$ is reasonably implementable then it is possible to reason about it as if it were not suffering of size explosion. The main consequence of such a schema is that the number of $\beta$-steps in $\lambda_{X}$ then becomes a reasonable complexity measure—essentially the complexity class $\mathsf{P}$ defined in $\lambda_{X}$ coincides with the one defined by RAM or Turing machines.

The first result in this area appeared only in the nineties and for a special case—Blelloch and Greiner showed that weak (that is, not under abstraction) call-by-value evaluation is reasonably implementable (Blelloch and Greiner, 1995). The strong case, where reduction is allowed everywhere, has received a positive answer only in 2014, when Accattoli and Dal Lago have shown that leftmost-outermost evaluation is reasonably implementable (Accattoli and Lago, 2014).

Reasonable conversion and sharing.

Some higher-order settings need more than evaluation of a single term. They often also have to check whether two terms $\tm$ and $\tmtwo$ are $X$-convertible—for instance to implement the equality predicate, as in OCaml, or for type checking in settings using dependent types, typically in Coq. These frameworks usually rely on a set of folklore and ad-hoc heuristics for conversion, that quickly solve many frequent special cases. In the general case, however, the only known algorithm is to first evaluate $\tm$ and $\tmtwo$ to their normal forms ${\tt nf}_{X}(\tm)$ and ${\tt nf}_{X}(\tmtwo)$ and then check ${\tt nf}_{X}(\tm)$ and ${\tt nf}_{X}(\tmtwo)$ for equality—actually, for $\alpha$-equivalence because terms in the \lac are identified up to $\alpha$. One can then say that conversion in $\lambda_{X}$ is reasonable if checking ${\tt nf}_{X}(\tm)\alphaeq{\tt nf}_{X}(\tmtwo)$ can be done in time polynomial in the sizes of $\tm$ and $\tmtwo$ and in the number of $\beta$ steps to evaluate them.

Sharing is the cure for size explosion during evaluation, but what about conversion? Size explosion forces reasonable evaluations to produce shared results. Equality in $\lambda_{X}$ unfortunately does not trivially reduce to equality in $\lambda_{{\tt sh}X}$, because a single term admits many different shared representations in general. Therefore, one needs to be able to test sharing equality, that is to decide whether $\tm{\downarrow}\,\alphaeq\tmtwo{\downarrow}\,$ given two shared terms $\tm$ and $\tmtwo$.

For conversion to be reasonable, sharing equality has to be testable in time polynomial in the sizes of $\tm$ and $\tmtwo$. The obvious algorithm that extracts the unfoldings $\tm{\downarrow}\,$ and $\tmtwo{\downarrow}\,$ and then checks $\alpha$-equivalence is of course too naïve, because computing the unfolding is exponential. The tricky point therefore is that sharing equality has to be checked without unfolding the sharing.

In these terms, the question has first been addressed by Accattoli and Dal Lago in (Accattoli and Lago, 2012), where they provide a quadratic algorithm for sharing equality. Consequently, conversion is reasonable.

A closer look to the costs.

Once established that strong evaluation and conversion are both reasonable it is natural to wonder how efficiently can they be implemented. Accattoli and Sacerdoti Coen in (Accattoli and Coen, 2015) essentially show that strong evaluation can be implemented within a bilinear overhead, \iewith overhead linear in the size of the initial term and in the number of $\beta$-steps. Their technique has then been simplified by Accattoli and Guerrieri in (Accattoli and Guerrieri, 2017). Both works actually address open evaluation, which is a bit simpler than strong evaluation—the moral however is that evaluation is bilinear. Consequently, the size of the computed result is bilinear.

The bottleneck for conversion then seemed to be Accattoli and Dal Lago’s quadratic algorithm for sharing equality. The literature actually contains also other algorithms, studied with different motivations or for slightly different problems, discussed among related works in the next section. None of these algorithms however matches the complexity of evaluation.

In this paper we provide the first algorithm for sharing equality that is linear in the size of the shared terms, improving over the literature. Therefore, the complexity of sharing equality matches the one of evaluation, providing a combined bilinear algorithm for conversion, that is the real motivation behind this work.

Computing Sharing Equality

Sharing as DAGs.

Sharing can be added to \lats in different forms. In this paper we adopt a graphical approach. Roughly, a \lat can be seen as a (sort of) directed tree whose root is the topmost constructor and whose leaves are the (free) variables. A \lat with sharing is more generally a Directed Acyclic Graph (DAG). Sharing of a subterm $\tm$ is then the fact that the root node $\node$ of $\tm$ has more than one parent.

This type of sharing is usually called horizontal or subterm sharing, and it is essentially the same sharing as in calculi with explicit substitution, environment-based abstract machines, or linear logic—the details are different but all these approaches provide different incarnations of the same notion of sharing. Other types of sharing include so-called vertical sharing ($\mu$, letrec), twisted sharing (Blom, 2001), and sharing graphs (Lamping, 1990). The latter provide a much deeper form of sharing than our DAGs, and are required by Lamping’s algorithm for optimal reduction. To our knowledge, sharing equality for sharing graphs has never been studied—it is not even known whether it is reasonable.

Sharing equality as bisimilarity.

When \lats with sharing are represented as DAGs, a natural way of checking sharing equality is to test DAGs for bisimilarity. Careful here: the transition system under study is the one given by the directed edges of the DAG, and not the one given by $\beta$-reduction steps, as in applicative bisimilarity—our DAGs may have $\beta$-redexes but we do not reduce them in this paper, that is an orthogonal issue, namely evaluation. Essentially, two DAGs represent the same unfolded \lat if they have the same structural paths, just collapsed differently.

To be precise, sharing equality is based on what we call sharing equivalences, that are bisimulations plus some additional requirements about free variables and the requirement that they are equivalence relations.

Binders, cycles, and domination.

A key point of our problem is the presence of binders, \ieabstractions, and the fact that equality on usual \lats is $\alpha$-equivalence. Graphically, it is standard to see abstractions as getting a backward edge from the variable they bind—a way of representing scopes that dates back to Bourbaki in Eléments de Théorie des Ensembles, but also supported by the strong relationship between \lac and linear logic proof nets.

In this approach, binders introduce a form of cycle in the \ladag: while two free variables are bisimilar only if they coincide, two bound variables are bisimilar only when also their binders are bisimilar, suggesting that \lats with sharing are, as directed graphs, structurally closer to deterministic finite automata (DFA), that may have cycles, than to DAGs. The problem with cycles is that in general bisimilarity of DAGs cannot be checked in linear time—Hopcroft and Karp’s algorithm (Hopcroft and Karp, 1971), the best one, is only pseudo-linear, that is, with an inverse Ackermann factor.

Technically speaking, the cycles induced by binders are not actual cycles: unlike usual downward edges, backwards edges do not point to subterms of a node, but are merely a graphical representation of scopes. They are indeed characterized by a structural property called domination—exploring the DAG from the root, one necessarily visits the binder before the bound variable. Domination turns out to be one of the key ingredients for a linear algorithm in presence of binders.

Previous work.

Sharing equality bears similarities with unification, which are discussed in the next section. For what concerns sharing equality itself, in the literature there are only two algorithms explicitly addressing it. First, the already cited quadratic one by Accattoli and Dal Lago. Second, a $O(n\log n)$ algorithm by Grabmayer and Rochel (Grabmayer and Rochel, 2014) (where $n$ is the sum of the sizes of the shared terms to compare, and the input of the algorithm is a graph), obtained by a reduction to equivalence of DFAs and treating the more general case of \lats with letrec.

Contributions: a theory and a 2-levels linear algorithm.

This paper is divided in two parts. The first part develops a re-usable, self-contained, and clean theory of sharing equality, independent of the algorithm that computes it. Some of its concepts are implicitly used by other authors, but never emerged from the collective unconscious before (propagated queries in particular)—others instead are new. A key point is that we bypass the use of $\alpha$-equivalence by relating sharing equalities on DAGs with $\lambda$-terms represented in a locally nameless way (Charguéraud, 2012). In such an approach, bound names are represented using de Bruijn indices, while free variables are represented using names—thus $\alpha$-equivalence collapses on equality. The theory culminates with the sharing equality theorem, which connects equality of \lats and sharing equivalences on shared \lats, under suitable conditions.

The second part studies a linear algorithm for sharing equality by adapting Paterson and Wegman’s (shortened to PW) linear algorithm for first-order unification (Paterson and Wegman, 1978) to \lats with sharing. Our algorithm is actually composed by a 2-levels, modular approach, pushing further the modularity suggested—but not implemented—in the nominal unification study by Calvès & Fernández in (Calvès and Fernández, 2010a):

• •

Blind check: a reformulation of PW from which we removed the management of meta-variables for unification. It is used as a first-order test on \lats with sharing, to check that the unfolded terms have the same skeleton, ignoring variables.

• •

Variables check: a straightforward algorithm executed after the previous one, testing $\alpha$-equivalence by checking that bisimilar bound variables have bisimilar binders and that two different free variables are never equated.

The decomposition plus the correctness and the completeness of the checks crucially rely on the theory developed in the first part.

The value of the paper.

It is delicate to explain the value of our work. Three contributions are clear: 1) the improved complexity of the problem, 2) the consequent downfall on the complexity of $\beta$-conversion, and 3) the isolation of a theory of sharing equality. At the same time, however, our algorithm looks as an easy adaptation of PW, and binders do not seem to play much of a role. Let us then draw attention to the following points:

• •

Identification of the problem: the literature presents similar studies and techniques, and yet we are the first to formulate and study the problem per se (unification is different, and it is usually not formulated on terms with sharing), directly (\iewithout reducing it to DFAs, like in Grabmayer and Rochel), and with a fine-grained look at the complexity (Accattoli and Dal Lago only tried not to be exponential).

• •

The role of binders: the fact that binders can be treated straightforwardly is—we believe—an insight and not a weakness of our work. Essentially, domination allows to reduce sharing equality in presence of binders to the Blind check, under key assumptions on the context in which terms are tested (see queries, Sect. 4).

• •

Minimality. The set of shared representations of an ordinary \lat $\tm$ is a lattice: the bottom element is $\tm$ itself, the top element is the (always existing) maximally sharing of $\tm$, and for any two terms with sharing there exist inf and sup. Essentially, Accattoli & Dal Lago and Grabmayer & Rochel address sharing equality by computing the top elements of the lattices of the two \lats with sharing, and then comparing them for $\alpha$-equivalence. We show that our Blind check—and morally every PW-based algorithm—computes the sup of $\tm$ and $\tmtwo$, that is, the term having all and only the sharing in $\tm$ or $\tmtwo$, that is the smallest sharing equivalence between the two DAGs. This insight, first pointed out in PW’s original paper to characterize most general unifiers, is a prominent concept in our theory of sharing equality as well.

• •

Proofs, invariants, and detailed development. We provide detailed correctness, completeness, and linearity proofs, plus a detailed treatment of the relationship between equality on locally nameless \lats and sharing equivalences on \ladags. Our work is therefore self-contained, but for the fact that most of the theorems and their proofs have been moved to the appendix.

• •

Concrete implementation. We implemented our algorithm 111The code is available on http://www.cs.unibo.it/~sacerdot/sharing_equivalence.tgz. and verified experimentally its linear time complexity. However, let us stress that despite providing an implementation our aim is mainly theoretical. Namely, we are interested in showing that sharing equality is linear (to obtain that conversion is bilinear) and not only pseudo-linear, even though other algorithms with super-linear asymptotic complexity may perform better in practice.

2. Related Problems and Technical Choices

We suggest the reader to skip this section at a first reading.

Related problems.

There are various problems that are closely related to sharing equality, and that are also treated with bisimilarity-based algorithms. Let us list similarities and differences:

• •

First-order unification. On the one hand the problem is more general, because unification roughly allows to substitute variables with terms not present in the original DAGs, while in sharing equality this is not possible. On the other hand, the problem is less general, because it does not allow binders and does not test $\alpha$-equivalence. There are basically two linear algorithm for first-order unification, Paterson and Wegman’s (PW) (Paterson and Wegman, 1978) and Martelli and Montanari’s (MM) (Martelli and Montanari, 1982). Both rely on sharing to be linear. PW even takes terms with sharing as inputs, while MM deals with sharing in a less direct way, except in its less known variant (Martelli and Montanari, 1977) that takes in input terms shared using the Boyer-Moore technique (Boyer and Moore, 1972).

• •

Nominal unification is unification up to $\alpha$-equivalence (but not up to $\beta$ or $\eta$ equivalence) of $\lambda$-calculi extended with name swapping, in the nominal tradition. It has first studied by Urban, Pitts, and Gabbay (Urban et al., 2003) and efficient algorithms are due to two groups, Calvès & Fernández and Levy & Villaret, adapting PW and MM form first-order unification. It is very close to sharing equality, but the known best algorithms (Calvès and Fernández, 2010a; Levy and Villaret, 2010) are only quadratic. See (Calvès, 2013) for a unifying presentation.

• •

Pattern unification. Miller’s pattern unification can also be stripped down to test sharing equality. Qian presents a PW-inspired algorithm, claiming linear complexity (Qian, 1993), that seems to work only on unshared terms. We say claiming because the algorithm is very involved and the proofs are far from being clear. Moreover, according to Levy and Villaret in (Levy and Villaret, 2010): it is really difficult to obtain a practical algorithm from the proof described in (Qian, 1993). We believe that is fair to say that Qian’s work is hermetic (please try to read it!).

• •

Nominal matching. Calvès & Fernández in (Calvès and Fernández, 2010b) present an algorithm for nominal matching (a special case of unification) that is linear, but only on unshared input terms.

• •

Equivalence of DFA. Automata do not have binders, and yet they are structurally more general than \lats with sharing, since they allow arbitrary directed cycles, not necessarily dominated. As already pointed out, the best equivalence algorithm is only pseudo-linear (Hopcroft and Karp, 1971).

Algorithms for $\alpha$-equivalence extended with further principles (\egpermutations of let expressions), but not up to sharing unfolding, is studied by Schmidt-Schauß, Rau, and Sabel in (Schmidt-Schauß et al., 2013).

Hash-consing.

Hash-consing (Ershov, 1958; Goto, 1974) is a technique to share purely functional data, traditionally realised through a hash table (Allen, 1978). It is a eager approach to conversion of $\lambda$-terms, in which one keeps trace in a huge table of all the pairs of convertible terms previously encountered. Our approach is somewhat dual or lazy, as our technique does not record previous tests, only the current equality problem is analysed. With hash consing, to check that two terms are sharing equivalent it suffices to perform a lookup in the hash table, but first the terms have to be hash-consed (\ie maximally shared), which requires quasilinear running times.

Technical choices.

Our algorithm requires \lats to be represented as graphs. This choice is fair, since abstract machines with global environments such as those described by Accattoli and Barras in (Accattoli and Barras, 2017) do manipulate similar representations, and thus produce \ladags to be compared for sharing equality—moreover, it is essentially the same representation induced by the translation of $\lambda$-calculus into linear logic proof nets (Regnier, 1992; Accattoli, 2018) up to explicit sharing nodes—namely $?$-links—and explicit boxes. In this paper we do not consider explicit sharing nodes (that in $\lambda$-calculus syntax correspond to have sharing only on variables), but one can translate in linear time between that representation to ours (and viceversa) by collapsing these variables-as-sharing on their child if they are the child of some other node. Our results could be adapted to this other approach, but at the price of more technical definitions.

On the other hand, abstract machines with local environments (\egKrivine asbtract machine), that typically rely on de Bruijn indices, produce different representations where every subterm is paired with an environment, representing a delayed substitution. Those outputs cannot be directly compared for sharing equality, they first have to be translated to a global environment representation—the study of such a translation is future work.

3. Preliminaries

In this section we introduce \ladags, the representation of \lats with sharing that we consider in this paper. First of all we introduce the usual \lac without sharing.

\lats and equality.

The syntax of \lats is usually defined as follows:

[TABLE]

This representation of \lats is called named, since variables and abstractions bear names. Equality on named terms is not just syntactic equality, but $\alpha$-equality: terms are identified up to the renaming of bound variables, because for example the named terms $\lambda{\var}.{\lambda{\vartwo}.\var}$ and $\lambda{\vartwo}.{\lambda{\var}.\vartwo}$ should denote the same \lat.

This is the standard representation of \lats, but reasoning in presence of names is cumbersome, especially names for bound variables as they force the introduction of $\alpha$-equivalence classes. Moreover \lans naturally bear no names, thus we prefer to avoid assigning arbitrary variable names when performing the readback of a \lan to a \lat.

On closed \lats (terms with only bound variables), this suggests a nameless approach: by using de Bruijn indices, variables simply consist of an index, a natural number indicating the number of abstractions that occur between the abstraction to which the variable is bound and that variable occurrence. For example, the named term $\lambda{\var}.{\lambda{\vartwo}.\var}$ and the nameless term $\lambda\lambda\underline{1}$ denote the same \lat. The nameless representation can be extended to open \lats, but it adds complications because for example different occurrences of the same free variable unnaturally have different indices.

Since we are forced to work with open terms (because proof assistants require them) the most comfortable representation and the one we adopt in our proofs is the locally nameless representation (see Charguéraud (Charguéraud, 2012) for a thorough discussion). This representation combines named and nameless, by using de Bruijn indices for bound variables (thus avoiding the need for $\alpha$-equivalence), and names for free variables. This representation of \lats is the most faithful to our definition of \ladags: as we shall see, to compare two bound variable \lans one compares their binders, but to compare two free variable nodes one uses their identifier, which in implementations is usually their memory address or a user-supplied string.

The syntax of locally nameless (l.n.) terms is:

[TABLE]

where $\underline{i}$ denotes a bound variable of de Bruijn index $i$ ($\mathbb{N}$ is the set of natural numbers), and $\overline{a}$ denotes a free variable of name $a$ ($\mathbb{A}$ is a set of atoms).

In the rest of the paper, we switch seamlessly between different representations of \lats (without sharing): we use named terms in examples, as they are more human-friendly, but locally nameless terms in the technical parts, since much more elegant and short proofs can be obtained by avoiding to reason explicitly on bound names and $\alpha$-equivalence.

Terms as graphs, informally.

Graphically, \lats can be seen as syntax trees—please have a look at the example in Fig. 1(a). Note that in all Fig. 1 we provide names to bound variables (both in the graphs and in the terms below) only to make the examples more understandable; as already mentioned, our upcoming notion of \ladag follows the locally nameless convention (as in Fig. 2).

As seen in the figure, we apply two tweaks relative to variable nodes:

• •

Binding edges: bound variable \lans have a binding (dashed) edge towards the abstraction node that binds them;

• •

Variables merging: all the \lans corresponding to the occurrences of a same variable are merged together, like the three occurrences of $w$ in the example. In this way, the equality of free variable nodes is just the physical equality of \lans.

Sharing is realized by simply allowing all nodes to have more than one parent, as for instance the abstraction on $y$ in Fig. 1(b) —note that sharing can happen inside abstractions, \eg$\lambda{\vartwo}.w$ is shared under the abstraction on $\var$.

Our notion of \lats with sharing is given in Definition 3.7. It is built in in two steps: we first introduce pre–\ladags, and later define the required structural properties that make them \ladags.

Definition 3.1 (pre–\ladags).

A pre–\ladag is a directed graph with three kind of nodes:

• •

Application: an application node is labelled with $\LabelApp$ and has exactly two children, called left ($\pleft$) and right ($\pright$). We write $\napp{\node}{\nodex}$ for a node labelled by $\LabelApp$ whose left child is $\node$ and whose right child is $\nodex$.

• •

Abstraction: an abstraction node is labelled with $\LabelAbs$ and has exactly one child, called its body ($\pdown$). We write $\nabs{\node}$ for a node labelled by $\LabelAbs$ with body $\node$. We denote by $\nodel$ a generic abstraction node.

• •

Variable: a variable node is labelled with $\LabelVar$, and may be free or bound:

• –

A free variable node has no children, and is denoted by $\nfvar$. We assume a function $\texttt{name}(\cdot)$ that assigns to every free variable node $\node$ an atom $\texttt{name}(\node)\in\mathbb{A}$ that uniquely identifies it222We also assume that the set of atoms $\mathbb{A}$ is such that the equality of atoms can be tested in constant time.: this identifier is going to be used later, when defining the readback of \lans to \lats (cf. Definition 3.9).

• –

A bound variable node has exactly one child, called its binder ($\pback$). We write $\nbvar\nodel$ for a node labelled by $\LabelVar$ with binder $\nodel$. The corresponding binding edge is represented with a dashed line.

Domination.

Not every pre–\ladag represents a \ladag. For instance, the graph in Fig. 1(c) does not, because the bound variable $x$ is visible outside the scope of its abstraction, since there is a path to $x$ from the application above the abstraction that does not pass through the abstraction itself. One would say that such a graph represents $(\lambda{\var}.\var\var)(\var\var)$, but the variable $\var$ in $\var\var$ and the one in $\lambda{\var}.\var\var\alphaeq\lambda{\vartwo}.\vartwo\vartwo$ cannot be the same.

It is well-known that scopes corresponding to \lats are characterized by a property borrowed from control-flow graphs called domination (also called unique binding by Wadsworth (Wadsworth, 1971), and checkable in linear time (Alstrup et al., 1999; Buchsbaum et al., 1998; Gabow, 1990)): given two nodes $\node$ and $\nodetwo$ of a graph $G$, we say that $\node$ dominates $\nodetwo$ when every path from a root of $G$ to $\nodetwo$ crosses $\node$. To define this property formally, we first need to define paths in a pre–\ladag.

Notations for paths.

Paths are a crucial concept, needed both to define the readback to \lats and to state formally the properties of \ladags of being acyclic and dominated.

A path in a graph is determined by a start node together with a trace, \ie a sequence of directions. The allowed directions are “$\pleft$”, “$\pdown$”, and “$\pright$”: we are not going to consider paths that use binding edges “$\pback$”, because these edges simply denote scoping and do not actually point to subterms of (the readback of) a node.

Definition 3.2 (Paths, traces).

We define traces as finite sequences of directions:

[TABLE]

Let $\node,\nodex$ be nodes of a pre–\ladag, and $\tra$ be a trace. We define inductively the judgement “$\Path\tra\node\nodex$”, which reads “path from $\node$ to $\nodex$ (of trace $\tra$)”:

• •

Empty: $\Path\epsilon\node\node$.

• •

Abstraction: if $\Path\tra\node{\nabs\nodex}$, then $\Pathp{\pcons\pdown\tra}\node\nodex$.

• •

Application: if $\Path\tra\node{\napp{\nodex_{1}}{\nodex_{2}}}$, then $\Pathp{\pcons\pleft\tra}\node{\nodex_{1}}$ and $\Pathp{\pcons\pright\tra}\node{\nodex_{2}}$.

We just write $\Path\tra\node$ if $\Path\tra\node\nodex$ for some node $\nodex$ when the endpoint $\nodex$ is not relevant.

To state formally the requirements that make a pre–\ladag a \ladag, we need two additional concepts: the roots of a pre–\ladag, and paths crossing a node.

Root nodes.

pre–\ladags (and later \ladags) may have various root nodes. What is maybe less expected, is that these roots may share some parts of the graph. Consider Fig. 1(b), and imagine to remove the root and its edges: the outcome is still a perfectly legal pre–\ladag. We admit these configurations because they actually arise naturally in implementations, especially of proof assistants.

Definition 3.3 (Roots).

Let $\noder$ be a node of a pre–\ladag $G$. $\noder$ is a root if and only if the only path with endnode $\noder$ has empty trace.

Definition 3.4 (Path Crossing a Node).

Let $\node,\nodex$ be nodes of a pre–\ladag, and $\tra$ a trace such that $\Path\tra\node{}$. We define inductively the judgment “$\Path\tra\node{}$ crosses $\nodex$”:

• •

if $\Path\tra\node\nodex$, then $\Path\tra\node{}$ crosses $\nodex$

• •

if $\Path\tra\node{}$ crosses $\nodex$ and $\Pathp{\pcons d\tra}\node{}$, then $\Pathp{\pcons d\tra}\node{}$ crosses $\nodex$.

Definition 3.5 (Dominated pre–\ladag).

Let $G$ be a pre–\ladag, and $\node,\nodex$ be nodes of $G$: we say that $\nodex$ dominates $\node$ when every path $\Path\tra\noder\node$ from a root node $\noder$ crosses $\nodex$.

We say that $G$ is dominated when each bound variable node $\nbvar\nodel$ is dominatedd by its binder $\nodel$.

Definition 3.6 (Acyclic pre–\ladag).

We say that a pre–\ladag $G$ is acyclic when for every node $\node$ in $G$ and every trace $\tra$, $\Path\tra\node\node$ if and only if $\tra=\pempty$.

Our precise definition of \lats with sharing follows:

Definition 3.7 (\ladags).

A pre–\ladag $G$ is a \ladag if it satisfies the following additional structural properties:

• •

Finite: $G$ has a finite number of nodes.

• •

Acyclic: if binding edges are ignored, $G$ is a DAG (Def. 3.6).

• •

Dominated: bound variable nodes are dominated by their binder (Def. 3.5).

Readback.

The sharing in a \ladag can be unfolded by duplicating shared sub-graphs, obtaining a \latree. We prefer however to adopt another approach. We define a readback procedure associating a \lat $\den\noder$ (without sharing) to each root node $\noder$ of the \ladag, in such a way that shared sub-graphs simply appear multiple times. However, since we use de Bruijn indices for bound variables, any \lan by itself does not uniquely identify a \lat: in fact, its readback depends on the path through which it is reached from a root, also known as its access path (Ariola and Klop, 1996). That path determines the abstraction nodes encountered, and thus the indices to assign to bound variable nodes. We define formally ${\tt index}(\nodel\mid\Path\tra\node)$, the index of an abstraction node $\nodel$ according to a path $\Path\tra\node$ crossing $\nodel$ (recall that $\nodel,\nodelx$ denote abstraction nodes):

Definition 3.8 (${\tt index}(\cdot\mid\cdot)$).

Let $\node,\nodel$ be nodes of a \ladag $G$, and $\Path\tra\node$ a path crossing $\nodel$. We define ${\tt index}(\nodel\mid\Path\tra\node)$ by structural induction on the derivation of the judgement “$\Path\tra\node$ crosses $\nodel$”:

[TABLE]

Definition 3.9 (Readback to \lats $\trxnp\cdot$).

Let $G$ be a \ladag. For every root $\noder$ and path $\Path\tra\noder\node$, we define the readback $\trx{\Path\tra\noder\node}$ of $\node$ relative to the access path $\Path\tra\noder\node$, by cases on $\node$:

1. (1)

$\trx{\Path\tra\noder{\nbvar\nodel}}\defeq\underline{i}$ where $i\defeq{\tt index}(\nodel\mid\Path\tra\noder)$. 2. (2)

$\trx{\Path\tra\noder\nfvar}\defeq\overline{a}$ where $a\defeq\texttt{name}(\node)$. 3. (3)

$\trx{\Path\tra\noder{\nabs\nodex}}\defeq\lambda\trx{\Pathp{\pcons\pdown\tra}{\noder}\nodex}$. 4. (4)

$\trx{\Path\tra\noder{\napp{\node_{1}}{\node_{2}}}}\defeq\trx{\Pathp{\pcons\pleft\tra}{\noder}{\node_{1}}}\,{\trx{\Pathp{\pcons\pright\tra}{\noder}{\node_{2}}}}$.

When $\tra=\pempty$, we just write $\trxnp\noder$ instead of $\trx{\Path\pempty\noder}$.

Some remarks about Definition 3.9:

• •

The hypothesis that $\noder$ is a root node is necessary to ensure that the readback $\trx{\Path\tra\noder{}}$ is a valid locally-nameless term. In fact Point 1 of the definition uses ${\tt index}(\nodel\mid\Path\tra\noder)$, which is well-defined only if $\Path\tra\noder{\nbvar\nodel}$ crosses $\nodel$. When $\noder$ is a root node, this is the case by domination (Definition 3.5).

• •

The definition is recursive, but it is not immediately clear what is the measure of termination. In fact, the readback calls itself recursively on longer paths. Still, the definition is well-posed because paths do not use binding edges, and because \ladags are finite and acyclic (Definition 3.6).

4. The Theory of Sharing Equality

Sharing equivalence.

To formalize the idea that two different \ladags unfold to the same \lat, we introduce a general notion of equivalence between nodes (sharing equivalence, Definition 4.2) whose intended meaning is that two related nodes have the same readback. This notion shall rest on various requirements; the first one is that only homogeneous \lans can be related:

Definition 4.1 (Homogeneous nodes (Paterson and

Wegman, 1978)).

Let $\node,\nodex$ be nodes of a \ladag $G$. We say that $\node$ and $\nodex$ are homogeneous if they are both application nodes, or they are both abstraction nodes, or they are both free variable nodes, or they are both bound variable nodes.

In the following, let us denote by $\Rel$ a generic binary relation over the nodes of a \ladag $G$. We call a relation $\Rel$ homogeneous if it only relates pairs of homogeneous nodes, \ie $\node\Rel\nodex$ implies that $\node$ and $\nodex$ are homogeneous.

Another requirement for sharing equivalences is that they must be closed under certain structural rules. More in general, in the rest of this paper we are going to characterize various kinds of relations as being closed under different sets of rules, which can all be found in Figure 3:

• •

Equivalence rules: rules \RuleRefl \RuleSym \RuleTrans are the usual rules that characterize equivalence relations, respectively reflexivity, symmetry, and transitivity.

• •

Bisimulation rules:

• –

Downward propagation rules: rules \RuleAppl \RuleAbs \RuleAppr are downward propagation rules on the \ladag. The rules \RuleAppl  and \RuleAppr  state that if two application \lans are related, then also their corresponding left and right children should be related. The rule \RuleAbs  states that if two abstraction \lans are related, then also their bodies should be related.

• –

Scoping rule: the rule \RuleBV states that if two bound variable \lans are related, then also their binders should be related.

The last requirement for a sharing equivalence is the handling of free variable \lans: a sharing equivalence shall not equate two different free variable nodes, cf. the requirement Open in the upcoming definition.

We are now ready to define sharing equivalences:

Definition 4.2 ((Blind) sharing equivalences).

Let $\equiv$ be a binary relation over the nodes of a \ladag $G$.

• •

$\equiv$ is a blind sharing equivalence if:

• –

Equivalence: $\equiv$ is an equivalence relation;

• –

Blind bisimulation: $\equiv$ is homogeneous and closed under the rules \RuleAppl  \RuleAbs  \RuleAppr of Figure 3.

• •

$\equiv$ is a sharing equivalence if:

• –

Equivalence: $\equiv$ is an equivalence relation;

• –

Bisimulation: $\equiv$ is homogeneous and closed under the rules \RuleAppl  \RuleAbs  \RuleAppr  \RuleBV of Figure 3.

• –

Open: $v\equiv w$ implies $v=w$ for every free variable \lans $v,w$.

Equivalently, $\equiv$ is a sharing equivalence if it is a blind sharing equivalence and it also satisfies the following conditions on variable \lans: the open requirement for free variable nodes, and the closure under \RuleBV for bound variable nodes.

Example. Consider Fig. 2(a). The green (horizontal) waves are an economical representation of a sharing equivalence—nodes in the same class are connected by a green path, and reflexive/transitive waves are omitted.

{remark}

(Blind) sharing equivalences are closed by intersection, so that if there exists a (blind) sharing equivalence on a \ladag then there is a smallest one.

The requirements for a sharing equivalence $\equiv$ on a \ladag $G$ essentially ensure that $G$ quotiented by $\equiv$ has itself the structure of a \ladag. Note that blind sharing equivalences are not enough, because without the scoping rule, binders are not unique up to $\equiv$—it is nonetheless possible to prove that paths up to $\equiv$ are acyclic, which is going to be one of the key properties to prove the completeness of the Blind check.

{remark}

Let $\equiv$ be a blind sharing equivalence on a \ladag $G$. Then:

1. (1)

Acyclicity up to $\equiv$: paths upto $\equiv$ in $G$ are acyclic. 2. (2)

Sharing equivalences as \ladags: if $\equiv$ also satisfies the name conditions then $G/{\equiv}$ is a \ladag.

For instance, Fig. 2(b) shows the \ladag corresponding to the quotient of the one of Fig. 2(a) by the sharing equivalence induced by the green waves.

Sharing equivalences do capture equality of readbacks, as we shall show, in the following sense (this is a sketch given to guide the reader towards the proper relationship, formalized by Theorem 4.7 at the end of this section):

• •

sharing to $\alpha$: if $\node\equiv\nodetwo$ then $\den\node=\den\nodetwo$;

• •

$\alpha$ to sharing: if $\den\node=\den\nodetwo$ then there exists a sharing equivalence $\equiv$ such that $\node\equiv\nodetwo$.

(Spreaded) queries.

According to the sketch we just provided, to check the sharing equality of two terms with sharing, \ietwo \ladags with roots $\node$ and $\nodetwo$, it is enough to compute the smallest sharing equivalence $\equiv$ such that $\node\equiv\nodetwo$, if it exists, and failing otherwise. This is what our algorithm does. At the same time, however, it is slightly more general: it may test more than two nodes at the same time, \ie all the pairs of nodes contained in a query.

Definition 4.3 (Query).

A query $\Que$ over a \ladag $G$ is a binary relation over the root nodes of $G$.

The simplest case is when there are only two roots $\node$ and $\nodetwo$ and the query contains only $\node\Que\nodetwo$ (depicted as a blue wave in Fig. 2(a))—from now on however we work with a generic query $\Que$, which may relate nodes that are roots of not necessarily disjoint or even distinct \ladags; our focus is on the smallest sharing equivalence containing $\Que$.

Let us be more precise. Every query $\Que$ induces a number of other equality requests obtained by closing $\Que$ with respect to the equivalence and propagation clauses that every sharing equivalence has to satisfy. In other words, every query induces a spreaded query.

Definition 4.4 (Spreading $\DownEquivClos\Rel$).

Let $\Rel$ be a binary relation over the nodes of a \ladag $G$. The spreading $\DownEquivClos\Rel$ induced by $\Rel$ is the binary relation on the nodes of $G$ inductively defined by closing $\Rel$ under the rules \RuleRefl \RuleSym \RuleTrans \RuleAppl \RuleAbs \RuleAppr of Figure 3.

Example. The spreading $\DownEquivClos\Que$ of the (blue) query $\Que$ in Fig. 2(a) is the (reflexive and transitive closure) of the green waves.

Blind universality of $\DownEquivClos\Que$.

Note that the spreaded query $\DownEquivClos\Que$ is defined without knowing if there exists a (blind) sharing equivalence containing the query $\Que$—there might very well be none (if the nodes are not sharing equivalent). It turns out that the spreaded query $\DownEquivClos\Que$ is itself a blind sharing equivalence, whenever there exists a blind sharing equivalence containing the query $\Que$. In that case, unsurprisingly, $\DownEquivClos\Que$ is also the smallest blind sharing equivalence containing the query $\Que$.

Proposition 4.5 (Blind universality of $\DownEquivClos\Que$).

Let $\Que$ be a query. If there exists a blind sharing equivalence $\equiv$ containing $\Que$ then:

1. (1)

The spreaded query $\DownEquivClos\Que$ is contained in $\equiv$, \ie${\DownEquivClos\Que}\subseteq{\equiv}$. 2. (2)

$\DownEquivClos\Que$* is the smallest blind sharing equivalence containing $\Que$.*

Cycles up to $\DownEquivClos\Que$.

Let us apply Section 4(1) to $\DownEquivClos\Que$, and take the contrapositive statement: if paths up to $\DownEquivClos\Que$ are cyclic then $\DownEquivClos\Que$ is not a blind sharing equivalence. The Blind Check in Sect. 6 indeed fails as soon as it finds a cycle up to $\DownEquivClos\Que$. Note, now, that $\DownEquivClos\Que$ satisfies the equivalence and bisimulation requirements for a blind sharing equivalence by definition. The only way in which it might not be such an equivalence then, is if it is not homogeneous. Said differently, there is in principle no need to check for cycles, it is enough to test for homogeneity. We are going to do it anyway, because cycles provide earlier failures—there are also other practical reasons to do so, to be discussed in Sect. 6.

Universality of the spreaded query $\DownEquivClos\Que$.

Here it lies the key conceptual point in extending the linearity of Paterson and Wegman’s algorithm to binders and working up to $\alpha$-equivalence of bound variables.

In general the spreading $\DownEquivClos\Rel$ of a binary relation $\Rel$ may not be a sharing equivalence, even though a sharing equivalence containing $\Rel$ exists. Consider for instance the relation $\Rel$ in Fig. 2(d): $\Rel$ coincides with its spreading $\DownEquivClos\Rel$ (up to reflexivity), which is not a sharing equivalence because it does not include the \LabelAbs-nodes above the original query—note that spreading only happens downwards. To obtain a sharing equivalence one has to also include the \LabelAbs-nodes (Fig. 2(e)). The example does not show it, but in general then one has to start over spreading the new relation (eventually having to add other \LabelAbs-nodes found in the process, and so on). These iterations are obviously problematic in order to keep linear the complexity of the procedure—a key point of Paterson and Wegman’s algorithm is that every node is processed only once.

What makes possible to extend their algorithm to binders is that the query is context-free, \ie it is not in the scope of any abstraction, which is the case since it involves only pairs of roots, that therefore are above all abstractions as in Fig. 2(c). Then—remarkably—there is no need to iterate the propagation of the query. Said differently, if the relation $\Que$ is context-free then $\DownEquivClos\Que$ is universal.

The structural property of \ladags guaranteeing the absence of iterations for context-free queries is domination. Domination asks that to reach a bound variable from outside its scope one necessarily needs to first pass through its binder. The intuition is that if one starts with a context-free query then there is no need to iterate because binders are necessarily visited before the variables while propagating the query downwards.

Let us stress, however, that it is not evident that domination is enough. In fact, domination is about one bound variable and its only binder. For sharing equivalence instead one deals with a class of equivalent variables and a class of binders—said differently, domination is given in a setting without queries, and is not obvious that it gets along well with them. The fact that domination on single binders is enough for spreaded queries to be universal requires indeed a non-trivial proof and it is a somewhat surprising fact.

Proposition 4.6 (Universality of $\DownEquivClos\Que$).

Let $\Que$ be a query over a \ladag $G$. If there exists a sharing equivalence $\equiv$ containing $\Que$, then the spreaded query $\DownEquivClos\Que$ is the smallest sharing equivalence containing $\Que$.

The proof of this proposition is in Section A.4, page A.4, where it is obtained as a corollary of other results connecting equality of \lats and sharing equivalences, that also rely crucially on the the fact that queries only relate roots. It can also be proved directly, but it requires a very similar reasoning, which is why we rather prove it indirectly.

The sharing equality theorem.

We have now introduced all the needed concepts to state the precise connection between the equality of \lats, queries, and sharing equivalences, which is the main result of our abstract study of sharing equality.

Theorem 4.7 (Sharing equality).

Let $\Que$ be a query over a \ladag $G$. $\DownEquivClos\Que$ is a sharing equivalence if and only if $\trxnp\node=\trxnp\nodex$ for every \lans $\node,\nodex$ such that $\node\Que\nodex$.

Despite the—we hope—quite intuitive nature of the theorem, its proof is delicate and requires a number of further concepts and lemmas, developed in Appendices A–B. The key point is finding an invariant expressing how queries on roots propagate under abstractions and interact with domination, until they eventually satisfy the name conditions for a sharing equivalence, and vice versa.

Let us conclude the section by stressing a subtlety of Theorem 4.7. Consider Fig. 2(c)—with that query the statement is satisfied. Consider Fig. 2(d)—that relation is not a valid query because it does not relate root nodes, and in fact the statement would fail because the readback of the two queried nodes are not the same and not even well-defined. Consider the relation $\Rel$ in Fig. 2(e)—now $\Rel$ and $\DownEquivClos\Rel$ coincide (up to reflexivity) and $\DownEquivClos\Rel$ is a sharing equivalence, but the theorem (correctly) fails, because not all queried pairs of nodes are equivalent, as in Fig. 2(d).

5. Algorithms for Sharing Equality

From now on, we focus on the algorithmic side of sharing equality.

By the universality of spreaded queries $\DownEquivClos\Que$ (Proposition 4.6), checking the satisfability of a query $\Que$ boils down to compute $\DownEquivClos\Que$, and then check that it is a sharing equivalence: the fact that the requirements on variables are modular to the blind sharing requirement is one of our main contributions. Indeed it is possible to check sharing equality in two phases:

1. (1)

Blind Check: building $\DownEquivClos\Que$ and at the same time checking that it is a blind sharing equivalence, \ie that it is homogeneous; 2. (2)

Variables Check: verifing that $\DownEquivClos\Que$ is a sharing equivalence by checking the conditions for free and bound variable nodes.

Of course, the difficulty is doing it in linear time, and it essentially lies in the Blind Check.

The rest of this part presents two algorithms, the Blind Check (Algorithm 1) and the Variables Check (Algorithm 2), with proofs of correctness and completeness, and complexity analyses. The second algorithm is actually straightforward. Be careful, however: the algorithm for the Variables Check is trivial just because the subtleties of this part have been isolated in the previous section.

6. The Blind Check

In this section we introduce the basic concepts for the Blind Check, plus the algorithm itself.

Our algorithm is a simple adaptation of Paterson and Wegman’s, and it relies on the same key ideas in order to be linear. With respect to PW original algorithm, our reformulation does not rely on their notions of dead/alive nodes used to keep track of the nodes already processed; in addition it is not destructive, \ie it does not remove edges and nodes from the graph, hence it is more suitable for use in computer tools where the \lats to be checked for equality need not be destroyed. Another contribution in this part is a formal proof of correctness and completeness, obtained via the isolation of properties of program runs.

Intuitions for the Blind Check.

Paterson and Wegman’s algorithm is based on a tricky, linear time visit of the \ladag. It addresses two main efficiency issues:

1. (1)

The spreaded query is quadratic: the number of pairs in the spreaded query $\DownEquivClos\Que$ can be quadratic in the size of the \ladag. An equivalence class of cardinality $n$ has indeed $\Omega(n^{2})$ pairs for the relation—this is true for every equivalence relation. This point is addressed by rather computing a linear relation $=_{\texttt{c}}$ generating $\DownEquivClos\Que$, based on keeping a canonical element for every sharing equivalence class. 2. (2)

Merging equivalence classes: merging equivalence classes is an operation that, for as efficient as it may be, it is not a costant time operation. The trickiness of the visit of the \ladag is indeed meant to guarantee that, if the query is satisfiable, one never needs to merge two equivalence classes, but only to add single elements to classes.

More specifically, the ideas behind Algorithm 1 are:

• •

Top-down recursive exploration: the algorithm can start on any node, not necessarily a root. However, when processing a node $\node$ the algorithm first makes a recursive call on the parents of $\node$ that have not been visited yet. This is done to avoid the risk of reprocessing $\node$ later because of some new equality requests on $\node$ coming from a parent processed after $\node$.

• •

Query edges: the query is represented through additional undirected query edges between nodes, and it is propagated on child nodes by adding further query edges. The query is propagated carefully, on-demand. The fully propagated query is never computed, because, as explained, in general its size is quadratic in the number of nodes.

• •

Canonic edges: when a node is visited, it is assigned a canonic node that is a representative of its sharing equivalence class. This is represented via a directed canonic edge, which is implemented as a pointer.

• •

Building flag: each node has a boolean “building” flag that is used only by canonic representatives and notes the state of construction of their equivalence class. When undefined, it means that that node is not currently designated as canonic; when true, it means that the equivalence class of that canonic is still being computed; when false, it signals that the equivalence class has been completely computed.

• •

Failures and cycles: the algorithm fails in three cases. First, when it finds two nodes in the same class that are not homogeneous (Algorithm 1), because then the approximation of $\DownEquivClos\Que$ that it is computing cannot be a blind sharing equivalence. The two other cases (on Algorithm 1 and Algorithm 1) the algorithm uses the fact that the canonic edge is already present to infer that it found a cycle up to $\DownEquivClos\Que$, and so, again $\DownEquivClos\Que$ cannot be a blind sharing equivalence (please read again the paragraph after Proposition 4.5).

• •

Building a class: calling $\textnormal{{BuildEquivalenceClass}}(\node)$ boils down to

1. (1)

collect without duplicates all the nodes in the intended sharing equivalence class of $\node$, that is, the nodes related to $\node$ by a sequence of query edges. This is done by the while loop at Algorithm 1, that first collects the nodes queried with $\node$ and then iterates on the nodes queried with them. These nodes are inserted in a queue; 2. (2)

set $\node$ as the canonical element of its class, by setting the canonical edge of every node in the class (including $\node$) to $\node$; 3. (3)

propagate the query on the children (in case $\node$ is a $\mathtt{Lam}$ or a $\mathtt{App}$ node), by adding query edges between the corresponding children of every node in the class and their canonic. 4. (4)

Pushing a node in the queue, setting its canonic, and propagating the query on its children is done by the procedure EnqueueAndPropagate.

• •

Linearity: let us now come back to the two efficiency issues we mentioned before:

• –

Merging classes: the recursive calls are done in order to guarantee that when a node is processed all the query edges for its sharing class are already available, so that the class shall not be extended nor merged with other classes later on during the visit of the \ladag.

• –

Propagating the query: the query is propagated only after having set the canonics of the current sharing equivalence class. To explain, consider a class of $k$ nodes, which in general can be defined by $\Omega(k^{2})$ query edges. Note that after canonization, the class is represented using only $k-1$ canonic edges, and thus the algorithm propagates only $O(k)$ query edges—this is why the number of query edges is kept linear in the number of the nodes (assuming that the original query itself was linear). If instead one would propagate query edges before canonizing the class, then the number of query edges may grow quadratically.

States.

As explained, the algorithm needs to enrich \ladags with a few additional concepts, namely canonic edges, query edges, building flags, queues, and execution stack, all grouped under the notion of program state.

A state $\mathcal{S}$ of the algorithm is either $\mathcal{F}\!\!\mathit{ail}$ or a tuple

[TABLE]

where $G$ is a \ladag, and the remaining data structures have the following properties:

• •

Undirected query edges ($\sim$): undir is a multiset of undirected query edges, pairing nodes that are expected to be placed by the algorithm in the same sharing equivalence class. Undirected loops are admitted and there may be multiple occurrences of an undirected edge between two nodes. More precisely, for every undirected edge between $\node$ and $\nodetwo$ with multiplicty $k$ in the state, both $(\node,\nodetwo)$ and $(\nodetwo,\node)$ belong with multiplicity $k$ to undir. We denote by $\sim$ the binary relation over $G$ such that $\node\mathrel{\sim}\nodetwo$ iff the edge $(\node,\nodetwo)$ belongs to undir.

• •

Canonic edges (c): nodes may have one additional $\mathtt{canonic}$ directed edge pointing to the computed canonical representative of that node. The partial function mapping each node to its canonical representative (if defined) is noted c. We then write ${{\texttt{c}}}(\node)=\nodetwo$ if the canonical of $\node$ is $\nodetwo$, and ${{\texttt{c}}}(\node)=\mathtt{undefined}$ otherwise. By abuse of notation, we also consider c a binary relation on $G$, where $\node\mathrel{{{\texttt{c}}}}\nodetwo$ iff ${{\texttt{c}}}(\node)=\nodetwo$.

• •

Building flags (${\tt b}$): nodes may have an additional boolean flag building that signals whether an equivalence class has or has not been constructed yet. The partial function mapping each node to its building flag (if defined) is noted ${\tt b}$. We then write ${\tt b}(\node)={\tt true}\mid{\tt false}$ if the building flag of $\node$ is defined, and ${\tt b}(\node)=\mathtt{undefined}$ otherwise.

• •

Queues (${\tt q}$): nodes have a queue data structure that is used only on canonic representatives, and contains the nodes of the class that are going to be processed next. The partial function mapping each node to its queue (if defined) is noted ${\tt q}$.

• •

Active Calls (${{\tt active}}$): a program state contains information on the execution stack of the algorithm, including the active procedures, local variables, and current execution line. We leave the concept of execution stack informal; we only define more formally ${{\tt active}}$, which records the order of visit of equivalence classes that are under construction, and that is essential in the proof of completeness of the algorithm. ${{\tt active}}$ is an abstraction of the implicit execution stack of active calls to the procedure BuildEquivalenceClass where only (part of) the activation frames for BuildEquivalenceClass(c) are represented. Formally, ${\tt active}$ is simply a sequence of nodes of the \ladag, and ${\tt active}=[c_{1},\ldots,c_{K}]$ if and only if:

• –

Active: BuildEquivalenceClass($c_{1}$), …, BuildEquivalenceClass($c_{K}$) are exactly the calls to BuildEquivalenceClass that are currently active, \ie have been called before $\State$, but have not yet returned;

• –

Call Order: for every $0<i<j\leq K$,

BuildEquivalenceClass($c_{i}$) was called before BuildEquivalenceClass($c_{j}$).

Moreover we introduce the following concepts:

• •

Program transition: the change of state caused by the execution of a piece of code. For the sake of readability, we avoid a technical definition of transitions; roughly, a transition is the execution of a line of code, as they appear numbered in the algorithm itself. When the line is a while loop, a transition is an iteration of the body, or the exit from the loop; when the line is a if-then-else, a transition is entering one of the branches according to the condition; and so on.

• •

Fail state: $\mathcal{F}\!\!\mathit{ail}$ is the state reached after executing a fail instruction; it has no attributes and no transitions.

• •

Initial state $\State_{0}$: a non-$\mathcal{F}\!\!\mathit{ail}$ state with the following attributes:

• –

Initial $\sim$edges: simply the initial query, \ie ${\sim}\defeq{\Que}$.

• –

Initial assignments: ${{\texttt{c}}}(\node)$, ${\tt b}(\node)$, and ${\tt q}(\node)$ are undefined for every node $\node$ of $G$.

• –

Initial transition: the first transition is a call to BlindCheck(**).

• •

Program run: a sequence of program states starting from $\State_{0}$ obtained by consecutive transitions.

• •

Reachable: a state which is the last state of a program run.

• •

Failing: a reachable state that transitions to $\mathcal{F}\!\!\mathit{ail}$.

• •

Final: a non-$\mathcal{F}\!\!\mathit{ail}$ reachable state that has no further transitions.

Details about how the additional structures of enriched \ladags are implemented are given in Sect. 6.2, where the complexity of the algorithm is analysed.

6.1. Correctness and Completeness

Here we prove that Algorithm 1 correctly and completely solves the blind sharing equivalence problem, that is, it checks whether the spreaded query is a blind sharing equivalence.

The proofs rely on a number of general properties of program runs and reachable states. The full statements and proofs are in Appendix D, grouped according to the concepts that they analyze.

Correctness.

We prove that whenever Algorithm 1 terminates successfully with final state $\State_{f}$ from an initial query $\Que$, then $\DownEquivClos\Que$ is homogeneous, and therefore a blind sharing equivalence. Additionally, we show that the canonic assignment is a succint representation of $\DownEquivClos\Que$, \ie that for all nodes $\node,\nodetwo$: $\node\DownEquivClos\Que\nodetwo$ if and only if $\node$ and $\nodetwo$ have the same canonic assigned in $\State_{f}$. The following are the most important properties to prove correctness:

• •

Blind bisimulation upto: in all reachable states, $\mathrel{{{\texttt{c}}}}$ is a blind bisimulation upto $({\sim}\cup{=})$.

• •

Undirected query edges approximate the spreaded query: in all reachable states, ${\Que}\subseteq{\mathrel{\sim}}\subseteq{\DownEquivClos\Que}$.

• •

The canonic assignment respects the $\sim$ constraints: in all reachable states, ${\mathrel{{{\texttt{c}}}}}\subseteq{\mathrel{\sim}^{*}}$

• •

Eventually, all query edges are visited: in all final states, all query edges are subsumed by the canonic assignment, \ie ${\sim}\subseteq{{\texttt{c}}^{*}}$.

In every reachable state, we define $=_{\texttt{c}}$ as the equivalence relation over the \ladag that equates two nodes whenever their canonic representatives are both defined and coincide. The lemmas above basically state that during the execution of the algorithm, $=_{\texttt{c}}$ is a blind sharing equivalence up to the query edges, and that $\sim$ can indeed be seen as an approximation of the spreaded query $\DownEquivClos\Que$. At the end of the algorithm, $\sim$ and c actually represent the same (up to the $(\cdot)^{*}$ closure) relation $=_{\texttt{c}}$, which is then exactly the spreaded query:

Proposition 6.1 (Correctness).

In every final state $\State_{f}$:

• •

Succint representation:* $(=_{\texttt{c}})=(\DownEquivClos\Que)$,*

• •

Blind check:* $\DownEquivClos\Que$ is homogeneous, and therefore a blind sharing equivalence.*

Completeness.

Completeness is the fact that whenever Algorithm 1 fails, $\DownEquivClos\Que$ is not a blind sharing equivalence. Recall that the algorithm can fail only while executing the following three lines of code:

• •

On Algorithm 1 during BuildEquivalenceClass, when a node $\node$ is being processed and it has a parent whose equivalence class is still being built;

• •

On Algorithm 1 during BuildEquivalenceClass, when a node $\node$ is being processed and it has a ${\mathrel{\sim}}$neighbour belonging to a difference equivalence class;

• •

On Algorithm 1 during EnqueueAndPropagate(\nodetwo,c), when the algorithm is trying two relate the nodes $\nodetwo$ and $c$ which are not homogeneous.

While in the latter case (Algorithm 1) the failure of the homogeneous condition is more evident, in the first two cases it is more subtle. In fact, when the homogeneous condition fails on Algorithm 1 and Algorithm 1 it is not because we explicitly found two related nodes that are not homogeneous, but because $\DownEquivClos\Que$ does not satisfy an indirect property that is necessary for $\DownEquivClos\Que$ to be homogenous (see below). In these cases the algorithm fails early, even though it has not visited yet the actual pair of nodes that are not homogeneous.

To justify the early failures we use ${\tt active}$, which basically records the equivalence classes that the algorithm is building in a given state, sorted according to the order of calls to BuildEquivalenceClass. Nodes in ${\tt active}$ respect a certain strict order: if ${\tt active}=[c_{1},\ldots,c_{K}]$, then $c_{1}\prec c_{2}\prec\ldots\prec c_{K}$ (Proposition D.27 in the Appendix), where $\node\prec\nodex$ implies that the equivalence class of $\node$ is a child of the one of $\nodex$ in the quotient graph. The algorithm fails on Algorithm 1 and Algorithm 1 because it found a cyclic chain of nodes related by $\prec$, therefore finding a cycle in the quotient graph. By Section 4, there cannot exist any blind sharing equivalence containing the initial query in this case.

Proposition 6.2 (Completeness).

If Algorithm 1 fails, then $\DownEquivClos\Que$ is not a blind sharing equivalence, and therefore by the blind universality of $\DownEquivClos\Que$ (Proposition 4.5), there does not exist any blind sharing equivalence containing the initial query $\Que$.

6.2. Linearity

In this section we show that Algorithm 1 always terminates, and it does so in time linear in the size of the \ladag and the initial query.

Low-level assumptions.

In order to analyse the complexity of the algorithm we have to spell out some details about an hypothetical implementation on a RAM of the data structures used by the Blind check.

• •

Nodes: since Algorithm 1 of the algorithm needs to iterate on all nodes of the \ladag, we assume an array of pointers to all the nodes of the graph.

• •

Directed edges: these edges—despite being directed—have to be traversed in both directions, typically to recurse over the parents of a node. We then assume that every node has an array of pointers to its parents.

• •

Undirected query edges: query edges are undirected and are dynamically created; in addition, the algorithm needs to iterate on all ${\mathrel{\sim}}$neighbours of a node. In order to obtain the right complexity, every node simply maintains a linked list of its ${\mathrel{\sim}}$neighbours, in such a way that when a new undirected edge $(\node,\nodetwo)$ is created, then $\node$ is pushed on the list of ${\mathrel{\sim}}$neighbours of $\nodetwo$, and $\nodetwo$ on the one of $\node$.

• •

Canonical assignment is obtained by a pointer to a node (possibly $\mathtt{undefined}$) in the data structure for nodes.

• •

Building flags are just implemented via a boolean on each node.

• •

Queues do not need to be recorded in the data structure for nodes, as they can be equivalently coded as local variables.

Let us call atomic the following operations performed by the check: finding the first node, finding the next node given the previous node, finding the first parent of a node, finding the next parent of a node given the previous parent, checking and setting canonics, checking and setting building flags, getting the next query edge on a given node, traversing a query edge, adding a query edge between two nodes, pushing to a queue, and popping an element off of a queue.

Lemma 6.3 (Atomic operations are constant).

The atomic operations of the Blind check are all implementable in constant time on a RAM.

Termination and linearity of the algorithm are proved via a global estimation of the number of transitions in a program run. The difficult part is to estimate the number of transitions executing lines of BuildEquivalenceClass, since it contains multiple nested loops. First of all, we prove that in every program run BuildEquivalenceClass is called at most once for each node. Then, also the body of the while loop on Algorithm 1 is executed in total at most once for each node, because we prove that in a program run each node is enqueued at most once. Since the parents of a node do not change during a program run, the loop on Algorithm 1 is not problematic. As for the loop on Algorithm 1 on the $\sim$neighbours of a node $\node$, we prove that the $\sim$neighbours of $\node$ do not change after the parents of $\node$ are visited. Finally, recall that the algorithm parsimoniously propagates query edges only between a node and its canonic: as a consequence, in every reachable state $|{\texttt{undir}}|$ is linear in the size of $\Que$ and the number of nodes in the \ladag.

Let $|G|$ denote the size of a \ladag $G$, \ie the number of nodes and edges of $G$. Then:

Proposition 6.4 (Linear termination).

Let $\State_{0}$ be an initial state of the algorithm, with a query $\Que$ over a \ladag $G$. Then the Blind check terminates in a number of transitions linear in $|G|$ and $|{\Que}|$.

7. The Variables Check

Our second algorithm (Algorithm 2) takes in input the output of the Blind check, that is, a blind sharing equivalence on a \ladag $G$ represented via canonic edges, and checks whether the $\mathtt{Var}$-nodes of $G$ satisfy the variables conditions for a sharing equivalence—free variable nodes at line 7, and bound variable nodes at line 9.

The Variables check is based on the fact that to compare a node with all those in its class it is enough to compare it with the canonical representative of the class—note that this fact is used twice, for the $\mathtt{Var}$-nodes and for their binders. The check fails in two cases, either when checking a free variable node (in this case $\DownEquivClos\Que$ is not an open relation) or when checking a bound variable node (in this case $\DownEquivClos\Que$ is not closed under \RuleBV).

Theorem 7.1 (Correctness & completeness of the Variables check).

Let $\Que$ be a query over a \ladag $G$ passing the Blind check, and let c be the canonic assignment produced by that check.

• •

(Completeness)* If the Variables check fails then there are no sharing equivalences containing $\Que$,*

• •

(Correctness)* otherwise $=_{\texttt{c}}$ is the smallest sharing equivalence containing $\Que$.*

Moreover, the Variables check clearly terminates in time linear in the size of $G$.

Composing Proposition 6.1, Proposition 6.2, Proposition 6.4, and Theorem 7.1, we obtain the second main result of the paper.

Theorem 7.2 (Sharing equality is linear).

Let $\Que$ be a query over a \ladag $G$. The sharing equality algorithm obtained by combining Algorithm 1 and Algorithm 2 runs in time linear in the sizes of $G$ and $\Que$, and it succeeds if and only if there exists a sharing equivalence containing $\Que$. Moreover, if it succeeds, it outputs a concrete (and linear) representation of the smallest such sharing equivalence.

Finally, composing with the sharing equality theorem (Theorem 4.7) one obtains that the algorithm indeed tests the equality of the readbacks of the query, as expected.

8. Conclusions

We presented the first linear-time algorithm to check the sharing equivalence of \ladags. Following our development of the theory of sharing equality, we split the algorithm in two parts: a first part performing a check on the DAG structure of \ladags, and the second part checking the additional requirements on variables and scopes. The paper is accompanied by a technical report with formal proofs of correctness, completeness, and termination in linear time.

The motivation for this work stemmed from our previous works on the evaluation of \lats: abstract machines can reduce a \lat to normal form in time bilinear in the size of the term and the number of evaluation steps, if \lats are represented in memory as \ladags. When combining bilinear evaluation through abstract machines and the sharing equality algorithm presented here, one obtains a bilinear algorithm for conversion. As a consequence, $\alpha\beta$-conversion can be implemented with only bilinear overhead.

Acknowledgements.

This work has been partially funded by the ANR JCJC grant COCA HOLA (ANR-16-CE40-004-01) and the Sponsor COST Action EUTypes CA15123 https://eutypes.cs.ru.nl/ STSM#Grant #43345.

Appendix A Relations on Graphs

In this section we are going to introduce several kinds of binary relations on nodes of the \ladag. Some are standard (like bisimulations, Definition A.2); others (like propagated relations, Definition A.4) are auxiliary concepts that we will later connect to the readback from \ladags to \lats (Definition 3.9).

A.1. Bisimulations

Definition A.1 (Blind Bisimulation).

Let $G$ be a \ladag, and $\Rel$ be a binary relation over the nodes of $G$. $\Rel$ is a blind bisimulation if and only if it is homogeneous and closed under the rules \RuleAppl  \RuleAbs  \RuleAppr of Figure 3.

Definition A.2 (Bisimulation).

Let $G$ be a \ladag, and $\Rel$ be a binary relation over the nodes of $G$. $\Rel$ is a bisimulation if and only if it is homogeneous and closed under the rules \RuleAppl  \RuleAbs  \RuleAppr  \RuleBV of Figure 3.

Notation A.3.

We denote by $\Bis$ a generic bisimulation.

A.2. Propagation $\Downarrow$

Definition A.4 (Propagated Relation).

We call propagated a relation that is closed under the rules \RuleAppl  \RuleAbs  \RuleAppr  of Figure 3.

The following auxiliary propositions (Proposition A.5 and Proposition A.6) connect propagated relations and paths on graphs.

Proposition A.5 (Trace Propagation).

Let $\Rel$ be a propagated relation over the nodes of a \ladag $G$. Let $\node,\nodex$ be nodes such that $\node\Rel\nodex$, and let $\tra$ be a trace such that $\Path\tra\node\node^{\prime}$ and $\Path\tra\nodex\nodex^{\prime}$. Then $\node^{\prime}\Rel\nodex^{\prime}$.

Proof.

We prove $\node^{\prime}\Rel\nodex^{\prime}$ by structural induction on the trace $\tra$:

• •

Case $\tra=\pempty$. Clearly $\node^{\prime}=\node$ and $\nodex^{\prime}=\nodex$, and we use the hypothesis $\node\Rel\nodex$.

• •

Case $(\pcons\pleft\tra)$. Assume $\Pathp{\pcons\pleft\tra}\node{\node^{\prime}}$ and $\Pathp{\pcons\pleft\tra}\nodex{\nodex^{\prime}}$. By inversion, there exist $\node^{\prime\prime},\nodex^{\prime\prime}$ such that $\Path\tra\node{\napp{\node^{\prime}}{\node^{\prime\prime}}}$ and $\Path\tra\nodex{\napp{\nodex^{\prime}}{\nodex^{\prime\prime}}}$. By \ih $\napp{\node^{\prime}}{\node^{\prime\prime}}\Rel\napp{\nodex^{\prime}}{\nodex^{\prime\prime}}$, which implies $\node^{\prime}\Rel\nodex^{\prime}$ by \RuleAppl.

• •

Case $(\pcons\pright\tra)$. Symmetric to the case above.

• •

Case $(\pcons\pdown\tra)$. Assume $\Path{\pcons\pdown\tra}\node{\node^{\prime}}$ and $\Path{\pcons\pdown\tra}\nodex{\nodex^{\prime}}$. By inversion, $\Path\tra\node{\nabs{\node^{\prime}}}$ and $\Path\tra\nodex{\nabs{\nodex^{\prime}}}$. By \ih $\nabs{\node^{\prime}}\Rel\nabs{\nodex^{\prime}}$, which implies $\node^{\prime}\Rel\nodex^{\prime}$ by \RuleAbs. ∎

Proposition A.6 (Trace Equivalence).

Let $\Rel$ be a blind bisimulation over the nodes of a \ladag $G$. Let $\node,\nodex$ be nodes such that $\node\Rel\nodex$. Then for every trace $\tra$, $\Path\tra\node{}$ if and only if $\Path\tra\nodex{}$.

Proof.

Assume that $\node\Rel\nodex$ holds. We proceed by structural induction on $\tra$:

• •

Empty Trace: Clearly $\Path\pempty\node$ and $\Path\pempty\nodex$.

• •

Trace Cons. Let $\tra\defeq\pcons d\trax$, and assume without loss of generality that $\Path\tra\node{}$. We need to prove that $\Path\tra\nodex{}$.

By inversion, $\Path\trax\node{\node^{\prime}}$ for some $\node^{\prime}$, and by \ih $\Path\trax\nodex{\nodex^{\prime}}$ for some $\nodex^{\prime}$. From Proposition A.5 we obtain $\node^{\prime}\Rel\nodex^{\prime}$, where $\node^{\prime}$ and $\nodex^{\prime}$ are homogenous because by hypothesis $\Rel$ is homogeneous. We proceed by cases on $d$:

• –

Case $d=\pdown$. Then $\nodex^{\prime}=\nabs{\nodex^{\prime\prime}}$ for some $\nodex^{\prime\prime}$. Clearly $\Pathp{\pcons\pdown\trax}{\nodex}{\nodex^{\prime\prime}}$.

• –

Cases $d=\pleft$ or $d=\pright$. Then $\nodex^{\prime}=\napp{\nodex_{1}^{\prime},\nodex_{2}^{\prime}}$ for some $\nodex_{1}^{\prime},\nodex_{2}^{\prime}$. Clearly $\Pathp{\pcons\pleft\trax}{\nodex}{\nodex_{1}^{\prime}}$ and $\Pathp{\pcons\pright\trax}{\nodex}{\nodex_{2}^{\prime}}$. ∎

Given a relation $\Rel$, we define its propagation $\DownClos\Rel$ as the smallest propagated relation containing $\Rel$:

Definition A.7 (Propagation $\DownClos\Rel$).

Let $\Rel$ be a binary relation over the nodes of a \ladag $G$. The propagation $\DownClos\Rel$ of $\Rel$ is obtained by closing $\Rel$ under the rules \RuleAppl  \RuleAbs  \RuleAppr  of Figure 3.

Proposition A.8 (Inversion).

Let $\Rel$ be a relation over the nodes of a \ladag $G$, and $\node,\nodex$ be nodes of $G$. $\node\DownClos\Rel\nodex$ if and only there exists a trace $\tra$ and nodes $\node^{\prime}$, $\nodex^{\prime}$ such that $\node^{\prime}\Rel\nodex^{\prime}$, $\Path\tra{\node^{\prime}}\node$, and $\Path\tra{\nodex^{\prime}}\nodex$.

Proof.

• ($\Rightarrow$)

Assume $\node\DownClos\Rel\nodex$. We proceed by induction on the inductive definition of $\DownClos\Rel$:

• –

Base case: $\node\DownClos\Rel\nodex$ because $\node\Rel\nodex$. Conclude by considering $\node^{\prime}=\node$, $\nodex=\nodex^{\prime}$, and $\trax=\pempty$.

• –

Cases \RuleAppl: assume that $\node\DownClos\Rel\nodex$ because $\napp{\node}{\node^{\prime\prime}}\DownClos\Rel\napp{\nodex}{\nodex^{\prime\prime}}$ for some $\node^{\prime\prime},\nodex^{\prime\prime}$. By \ih there exists $\tra$ such that $\Path\tra{\node^{\prime}}{\napp{\node}{\node^{\prime\prime}}}$ and $\Path\tra{\nodex^{\prime}}{\napp{\nodex}{\nodex^{\prime\prime}}}$. Clearly $\Pathp{\pcons\pleft\tra}{\node^{\prime}}\node$ and $\Pathp{\pcons\pleft\tra}{\nodex^{\prime}}\nodex$.

• –

Case \RuleAppr. Symmetric to the case above.

• –

Case \RuleAbs: assume that $\node\DownClos\Rel\nodex$ because $\nabs\node\DownClos\Rel\nabs\nodex$. By \ih there exists $\tra$ such that $\Path\tra{\node^{\prime}}{\nabs\node}$ and $\Path\tra{\nodex^{\prime}}{\nabs\nodex}$. Clearly $\Pathp{\pcons\pdown\tra}{\node^{\prime}}\node$, and $\Pathp{\pcons\pdown\tra}{\nodex^{\prime}}\nodex$.

• ($\Leftarrow$)

Note that $\node\Rel\nodex$ implies $\node\DownClos\Rel\nodex$, and conclude by Proposition A.5.

∎

A.2.1. Propagation vs. Bisimulation

The main theorem of this section is the universality of the propagation $\DownClos\Rel$ (Theorem A.13), which states that in order to look for a bisimulation containing a given relation $\Rel$ over a \ladag, it suffices to check its propagation $\DownClos\Rel$: whenever a bisimulation containing $\Rel$ exists at all, then $\DownClos\Rel$ is also a bisimulation (as we will see, one actually needs an additional condition on $\Rel$).

Before proving Theorem A.13 we need some additional propositions and definitions. Many of the following results depends on the following proposition, which shows that well-behaved propagated relations cannot relate both a node and their children:

Proposition A.9 (No Triangles).

Let $\Rel$ be a blind bisimulation over the nodes of a \ladag $G$. Let $\node,\nodex,\nodex^{\prime}$ nodes of $G$ and $\tra$ a non-empty trace. If $\node\Rel\nodex$ and $\Path\tra\nodex{\nodex^{\prime}}$, then $\node\Rel\nodex^{\prime}$ can not hold.

Proof.

Assume that $\node\Rel\nodex^{\prime}$, and obtain a contradiction. Intuitively, we are going to show that the trace $\tra$ can be iterated arbitrarily many times starting from $\nodex$, contradicting the hypothesis that the \ladag is finite and acyclic.

The contradiction will follow by iterating the following construction:

• •

From the hypotheses that $\node\Rel\nodex$ and $\Path\tra\nodex{\nodex^{\prime}}$ it follows from Proposition A.6 that $\Path\tra\node{\node^{\prime}}$ for some $\node^{\prime}$. From the hypothesis that $\node\Rel\nodex$ together with $\Path\tra\node{\node^{\prime}}$ and $\Path\tra\nodex{\nodex^{\prime}}$, it follows that $\node^{\prime}\Rel\nodex^{\prime}$ by Proposition A.5.

• •

From the hypothesis that $\node\Rel\nodex^{\prime}$ and $\Path\tra\node{\node^{\prime}}$ it follows from Proposition A.6 that $\Path\tra{\nodex^{\prime}}{\nodex^{\prime\prime}}$ for some $\nodex^{\prime\prime}$. From the hypothesis that $\node\Rel\nodex^{\prime}$ together with $\Path\tra\node{\node^{\prime}}$ and $\Path\tra{\nodex^{\prime}}{\nodex^{\prime\prime}}$, it follows that $\node^{\prime}\Rel\nodex^{\prime\prime}$ by Proposition A.5.

The construction above can be repeated by using the new hypotheses $\node^{\prime}\Rel\nodex^{\prime}$, $\Path\tra{\nodex^{\prime}}{\nodex^{\prime\prime}}$, and $\node^{\prime}\Rel\nodex^{\prime\prime}$. Iterating the construction arbitrarily many times yields a sequence of nodes $\nodex$, $\nodex^{\prime}$, $\nodex^{\prime\prime}$, …such that $\Path\tra\nodex{\nodex^{\prime}}$, $\Path\tra{\nodex^{\prime}}{\nodex^{\prime\prime}}$, …

This contradicts the property of \ladags to be finite and acyclic. ∎

The universality of $\DownClos\Rel$ (Theorem A.13) does not hold for every relation $\Rel$, but an additional requirement for $\Rel$ is necessary: we will require $\Rel$ to be a query (Definition 4.3), \ie relating only root nodes.

The following is a simple property of every path crossing a node:

Proposition A.10.

Let $\node,\nodex,\nodexx$ be nodes of a \ladag $G$, and $\tra$ a trace such that $\Path\tra\node\nodex$ crosses $\nodexx$. Then there exists a trace $\trax$ such that $\Path\trax\nodexx\nodex$.

Proof.

By induction on the definition of “$\Path\tra\node\nodex$ crosses $\nodexx$”:

• •

If $\nodex=\nodexx$, conclude with $\trax\defeq\pempty$.

• •

If $\tra=(\pcons d\traxx)$ such that $\Path\traxx\node$ crosses $\nodexx$, use the \ih to obtain $\trax$, and conclude with $(\pcons d\trax)$. ∎

The following technical proposition is the inductive variant necessary to prove Proposition A.12.

Proposition A.11.

Let $\Rel$ be a blind bisimulation over the nodes of a \ladag $G$, and let $\Que$ a relation such that ${\Que}\subseteq{\Rel}$. Let $\node,\nodex$ be nodes such that $\node\Que\nodex$, and $\tra$ a trace such that $\Path\tra\node$ crosses $\nodel$ and $\Path\tra\nodex$ crosses $\nodelx$. Then $\nodel\Rel\nodelx$ implies $\nodel\DownClos\Que\nodelx$.

Proof.

Assume $\nodel\Rel\nodelx$. We proceed by structural induction on the predicates “$\Path\tra\node$ crosses $\nodel$” and “$\Path\tra\nodex$ crosses $\nodelx$”:

• •

Case $\Path\tra\node\nodel$ and $\Path\tra\nodex\nodelx$. By Proposition A.8 $\nodel\DownClos\Que\nodelx$, and we conclude.

• •

Case $\Path\tra\node\nodel$ and $\Path\tra\nodex{\nodex^{\prime}}\neq\nodelx$: this case is not possible, \ie we derive a contradiction. Since $\Path\tra\nodex{\nodex^{\prime}}$ crosses $\nodelx$, we obtain by Proposition A.10 a trace $\trax$ such that $\Path\trax\nodelx{\nodex^{\prime}}$, that is non-empty because $\nodelx\neq\nodex^{\prime}$. Note that by Proposition A.8 it holds that $\nodel\DownClos\Que\nodex^{\prime}$, that implies $\nodel\Rel\nodex^{\prime}$ (because $\Rel$ contains $\Que$, and $\Rel$ is propagated). Obtain a contradiction by Proposition A.9, using $\nodel\Rel\nodelx$, $\Path\trax\nodelx{\nodex^{\prime}}$, and $\nodel\Rel\nodex^{\prime}$.

• •

Case $\Path\tra\node{\node^{\prime}}\neq\nodel$ and $\Path\tra\nodex\nodelx$: symmetric to the case above.

• •

Case $\tra=(\pcons d\trax)$, $\Pathp{\pcons d\trax}\node{\node^{\prime}}\neq\nodel$ and $\Pathp{\pcons d\trax}\nodex{\nodex^{\prime}}\neq\nodelx$. It holds that $\Path\trax\node$ crosses $\nodel$ and $\Path\trax\nodex$ crosses $\nodelx$, and use the \ih to conclude. ∎

The previous result implies that whenever a query $\Que$ is contained in any bisimulation, then $\DownClos\Que$ is itself a bisimulation:

Proposition A.12.

Let $\Bis$ be a bisimulation over the nodes of a \ladag $G$, and let $\Que$ be a query such that ${\Que}\subseteq{\Bis}$. Then $\DownClos\Que$ is a bisimulation.

Proof.

Let $\Bis$ be a bisimulation, and let $\Que$ such that ${\Que}\subseteq{\Bis}$. In order to prove that $\DownClos\Que$ is a bisimulation, it suffices to show that $\DownClos\Que$ is homogeneous and closed under \RuleBV.

• •

Homogeneous. $\DownClos\Que$ is homogeneous because $\DownClos\Que$ is contained in $\Bis$ (since ${\Que}\subseteq{\Bis}$ and $\Bis$ is propagated), and $\Bis$ is homogeneous.

• •

Closed under \RuleBV. Let $\nbvar\nodel\DownClos\Que\nbvar\nodelx$: we need to show that $\nodel\DownClos\Que\nodelx$. Since $\DownClos\Que$ is contained in $\Bis$, $\nbvar\nodel\DownClos\Que\nbvar\nodelx$ implies $\nbvar\nodel\Bis\nbvar\nodelx$, and since $\Bis$ is closed under \RuleBV we obtain $\nodel\Bis\nodelx$.

By $\nbvar\nodel\DownClos\Que\nbvar\nodelx$ and Proposition A.8, there exists a trace $\tra$ and nodes $\node\Que\nodex$ such that $\Path\tra\node{\nbvar\nodel}$ and $\Path\tra\nodex{\nbvar\nodelx}$. Since $\Que$ is a query, $\Path\tra\node{\nbvar\nodel}$ crosses $\nodel$ and $\Path\tra\nodex{\nbvar\nodelx}$ crosses $\nodelx$. We conclude with $\nodel\DownClos\Que\nodelx$ by Proposition A.11. ∎

We can finally prove:

Theorem A.13 (Universality of $\DownClos\Que$).

Let $\Que$ be a query over the nodes of a \ladag $G$. $\DownClos\Que$ is a bisimulation if and only if there exists a bisimulation containing $\Que$.

Proof.

Clearly if $\DownClos\Que$ is a bisimulation, then $\DownClos\Que$ is the required bisimulation containing $\Que$. To prove the other implication, just use Proposition A.12. ∎

A.3. Equivalence Relations

In this section, we are going to define the spreading $\DownEquivClos\Que$ of $\Que$ (Definition A.17), which is similar to the propagation $\DownClos\Que$ but also an equivalence relation. The main result will be Theorem A.20, in which we prove that $\DownEquivClos\Que$ is a bisimulation if and only if $\DownClos\Que$ is.

We first introduce the reflexive symmetric transitive closure ${(\cdot)}^{*}$:

Definition A.14 (Reflexive Symmetric Transitive Closure).

We denote with $\Rel^{*}$ the reflexitive symmetric transitive (rst) closure of a relation $\Rel$, \ie the relation obtained by closing $\Rel$ under the rules \RuleRefl  \RuleSym  \RuleTrans  of Figure 3.

We now lift some previously defined notions to the rst closure. The rst closure preserves homogeneity:

Proposition A.15.

Let $\Rel$ be a relation. $\Rel$ is homogeneous if and only if $\Rel^{*}$ is homogeneous.

Proof.

Clearly if $\Rel^{*}$ is homogeneous, then also $\Rel$ is homogeneous because ${\Rel}\subseteq{\Rel}^{*}$. For the other direction, it suffices to note that the equivalence rules \RuleRefl  \RuleSym  \RuleTrans  preserve homogeneity. ∎

For homogeneous relations, closure under structural rules is preserved by equivalence rules:

Proposition A.16.

Let $\Rel$ be an homogeneous relation, and $r\in\{\RuleAppl,\RuleAbs,\RuleAppr,\RuleBV\}$. If $\Rel$ is closed under $r$, then $\Rel^{*}$ is closed under $r$.

Proof.

We only consider the case when $r$ is \RuleBV; the proofs for the other rules are similar.

Assume that $\Rel$ is closed under $r$, and let $\nbvar\nodel\Rel^{*}\nbvar\nodelx$: we need to show that $\nodel\Rel^{*}\nodelx$. We proceed by induction on the inductive definition of $\Rel^{*}$:

• •

Base case: $\nbvar\nodel\Rel^{*}\nbvar\nodelx$ because $\nbvar\nodel\Rel\nbvar\nodelx$. By the hypothesis that $\Rel$ is closed under \RuleBV it follows that $\nodel\Rel\nodelx$, which implies $\nodel\Rel^{*}\nodelx$.

• •

Case \RuleRefl: $\nbvar\nodel\Rel^{*}\nbvar\nodelx$ because $\nbvar\nodel=\nbvar\nodelx$. Then $\nodel=\nodelx$, and we conclude with $\nodel\Rel^{*}\nodelx$ by the rule \RuleRefl.

• •

Case \RuleSym: $\nbvar\nodel\Rel^{*}\nbvar\nodelx$ because $\nbvar\nodelx\Rel^{*}\nbvar\nodel$. By \ih $\nodelx\Rel^{*}\nodel$, and we obtain $\nodel\Rel^{*}\nodelx$ by the rule \RuleSym.

• •

Case \RuleTrans: $\nbvar\nodel\Rel^{*}\nbvar\nodelx$ because $\nbvar\nodel\Rel^{*}\node$ and $\node\Rel^{*}\nbvar\nodelx$ for some node $\node$. Since $\Rel$ is homogeneous, by Proposition A.15 $\Rel^{*}$ is homogeneous too, and therefore $\node=\nbvar\nodelxx$ for some $\nodelxx$. By \ih we obtain $\nodel\Rel^{*}\nodelxx$ and $\nodelxx\Rel^{*}\nodelx$, and we conclude with $\nodel\Rel^{*}\nodelx$ by the rule \RuleTrans. ∎

We introduce the spreading $\DownEquivClos\Rel$ of a relation $\Rel$:

Definition A.17 ($\DownEquivClos\Rel$).

Let $\Rel$ be a binary relation over the nodes of a \ladag. $\DownEquivClos\Rel$ is obtained by closing $\Rel$ under the rules \RuleRefl  \RuleSym  \RuleTrans  \RuleAppl  \RuleAbs  \RuleAppr  of Figure 3.

Clearly ${({\DownClos\Rel})^{*}}\subseteq(\DownEquivClos\Rel)$ for every relation $\Rel$. The converse may in principle not hold, as the equivalence rules may not commute with the rules of the spreading: for example, the rst closure of a spreaded relation may not be spreaded. But surprisingly this is not the case, under the hypothesis that $\DownClos\Rel$ is homogeneous:

Proposition A.18.

Let $\Rel$ be a binary relation over the nodes of a \ladag. If $\DownClos\Rel$ is homogeneous, then ${\DownEquivClos\Rel}=(\DownClos\Rel)^{*}$.

Proof.

Note that ${({\DownClos\Rel})^{*}}\subseteq(\DownEquivClos\Rel)$, and that $({\DownClos\Rel})^{*}$ is closed under the rules \RuleRefl  \RuleSym  \RuleTrans  by the definition of $(\cdot)^{*}$. It remains to show that $({\DownClos\Rel})^{*}$ is also closed under the rules \RuleAppl \RuleAppr \RuleAbs  which follows from Proposition A.16. ∎

We lift Proposition A.15 to $\DownEquivClos\Rel$:

Proposition A.19.

Let $\Rel$ be a binary relation over the nodes of a \ladag. $\DownEquivClos\Rel$ is homogeneous if and only if $\DownClos\Rel$ is homogeneous.

Proof.

Clearly if $\DownEquivClos\Rel$ is homogeneous, then also $\DownClos\Rel$ is homogeneous because $(\DownClos\Rel)\subseteq(\DownEquivClos\Rel)$. For the other direction, assume that $\DownClos\Rel$ is homogeneous: by Proposition A.15 it follows that $(\DownClos\Rel)^{*}$ is homogeneous, and we can conclude by Proposition A.18. ∎

We finally prove:

Theorem A.20.

Let $\Que$ be a query over a \ladag $G$. Then $\DownClos\Que$ is a bisimulation if and only if $\DownEquivClos\Que$ is a bisimulation.

Proof.

• ($\Rightarrow$)

Assume that $\DownClos\Que$ is a bisimulation; in order to prove that $\DownEquivClos\Que$ is a bisimulation, it suffices to show that $\DownEquivClos\Que$ is homogeneous and closed under \RuleBV. The former follows from Proposition A.18 and Proposition A.19. The latter follows from Proposition A.18 and Proposition A.16.

• ($\Leftarrow$)

Assume that $\DownEquivClos\Que$ is a bisimulation. Then $\DownClos\Que$ is a bisimulation by the universality of $\DownClos\Que$ (Theorem A.13). ∎

A.4. Sharing Equivalences

In this section we introduce sharing equivalences (Definition A.22), which are binary relations on the \ladag that capture the equivalence of different sharings of subgraphs. They require the new concept of open relations, relations that do not identify distict free variable nodes:

Definition A.21 (Open).

We call a relation $\Rel$ open when $\node\Rel\nodex$ implies $\node=\nodex$ for every free variable nodes $\node$ and $\nodex$.

Definition A.22 (Sharing Equivalence).

A sharing equivalence is an open bisimulation that is also an equivalence relation.

The main result of the section is the universality of $\DownEquivClos\Que$ (Theorem A.26), stating that $\DownEquivClos\Que$ is a sharing equivalence whenever there exists a sharing equivalence containing $\Que$. Some auxiliary propositions follow.

We first lift the open property to the rst closure:

Proposition A.23.

Let $\Rel$ be an homogeneous relation over the nodes of a \ladag. $\Rel$ is open if and only if $\Rel^{*}$ is open.

Proof.

If $\Rel^{*}$ is open, then also $\Rel$ is open because ${\Rel}\subseteq{\Rel^{*}}$.

Assume now that $\Rel$ is open, and that $\node\Rel^{*}\nodex$ for $\node,\nodex$ free variable nodes. We proceed by induction on the inductive definition of $\Rel^{*}$. The base case and the cases \RuleRefl \RuleSym  are easy; let us discuss the case \RuleTrans. Assume that $\node\Rel^{*}\nodex$ because $\node\Rel^{*}\nodexx$ and $\nodexx\Rel^{*}\nodex$ for some node $\nodexx$. Since $\Rel$ is homogeneous, by Proposition A.15 $\Rel^{*}$ is homogeneous too, and therefore $\nodexx$ is a free variable node as well. By \ih we obtain $\node=\nodexx$ and $\nodexx=\nodex$, and we conclude with $\node=\nodex$. ∎

Corollary A.24.

Let $\Que$ be a query such that $\DownClos\Que$ is homogeneous. $\DownClos\Que$ is open if and only if $\DownEquivClos\Que$ is open.

Theorem A.25.

Let $\Que$ be a query over a \ladag $G$. $\DownClos\Que$ is an open bisimulation if and only if $\DownEquivClos\Que$ is a sharing equivalence.

Proof.

By Theorem A.20 and Corollary A.24. ∎

Theorem A.26.

Let $\Que$ be a query over a \ladag. $\DownEquivClos\Que$ is a sharing equivalence if and only if there exists a sharing equivalence containing $\Que$.

Proof.

The implication from left to right is trivial. The other implication follows from Theorem A.25 and Theorem A.13. ∎

Proof of 0 (Proposition 4.5).

“??”

Proof.

1. (1)

By the definition of spreading and blind sharing equivalence. 2. (2)

$\DownEquivClos\Que$ is a blind sharing equivalence because it is contained by hypothesis in a blind sharing equivalence, and therefore it is homogeneous. $\DownEquivClos\Que$ is the smallest blind sharing equivalence by the definition of spreading.

∎

Proof of 0 (Proposition 4.6).

“??”

Proof.

By Theorem A.26 and the definition of the propagation. ∎

Appendix B $\boldsymbol{\lambda}$-Calculus

In this section, we are going to the define the relationship between the equality of \lats and bisimulations on a \ladag. First, we decompose the equality of readbacks into the equality of their subterms (result similar to Proposition A.5 and Proposition A.6 for relations):

Proposition B.1.

Let $\noder,\noderx$ be roots of a \ladag $G$. $\trxnp\noder=\trxnp\noderx$ holds if and only if, for every trace $\tra$:

1. (1)

Trace Equivalence:* $\Path\tra\noder$ if and only if $\Path\tra\noderx$;* 2. (2)

Trace Propagation:* if $\Path\tra\noder$ and $\Path\tra\noderx$, then $\trx{\Path\tra\noder}=\trx{\Path\tra\noderx}$.*

Proof.

• $(\Rightarrow)$

We assume that $\trxnp\noder=\trxnp\noderx$, and proceed by structural induction on $\tra$:

• –

Empty Trace. Clearly $\Path\pempty\noder$ and $\Path\pempty\noderx$. The fact that $\trx{\Path\pempty\noder}=\trx{\Path\pempty\noderx}$ follows from the hypothesis, since $\trx{\Path\pempty\noder}=\trxnp\noder$ and $\trx{\Path\pempty\noderx}=\trxnp\noderx$.

• –

Trace Cons. Let $\tra\defeq\pcons d\trax$, and assume without loss of generality that $\Path\tra\noder$. We need to prove that $\Path\tra\noderx$ and that $\trx{\Path\tra\noder}=\trx{\Path\tra\noderx}$.

By inversion $\Path\trax\noder{}$, and by \ih $\Path\trax\noderx{}$ and $\trx{\Path\trax\noder}=\trx{\Path\trax\noderx}$. We proceed by cases on $d$:

Case $d=\pdown$. Necessarily $\Path\trax\noder{\nabs{\node}}$ and $\Path\trax\noderx{\nabs{\nodex}}$ for some $\node,\nodex$. By the definition of readback to \lats, $\trx{\Path\trax\noder{}}=\lambda{\trx{\Path\tra\noder{\node}}}$ and $\trx{\Path\trax\noderx{}}=\lambda{\trx{\Path\tra\noderx{\nodex}}}$, which imply $\trx{\Path\tra\noder{\node}}=\trx{\Path\tra\noderx{\nodex}}$ by the definition of equality.

• *

Case $d=\pleft$. Necessarily $\Path\trax\noder{\napp{\node_{1}}{\node_{2}}}$ and $\Path\trax\noder{\napp{\nodex_{1}}{\nodex_{2}}}$ for some $\node_{1},\node_{2},\nodex_{1},\nodex_{2}$. By the definition of readback to \lats, $\trx{\Path\trax\noder{}}=\trx{\Path\tra\noder{\node_{1}}}\,{\trx{\Pathp{\pcons\pright\trax}{\noder}{\node_{2}}}}$ and $\trx{\Path\trax\noderx{}}=\trx{\Path\tra\noderx{\nodex_{1}}}\,{\trx{\Pathp{\pcons\pright\trax}{\noderx}{\nodex_{2}}}}$, which imply $\trx{\Path\tra\noder{\node_{1}}}=\trx{\Path\tra\noderx{\nodex_{1}}}$ by the definition of equality.

• *

Case $d=\pright$. Similar to the case above.

• $(\Leftarrow)$

The statement follows from the hypothesis Trace Propagation by taking $\tra\defeq\pempty$. ∎

In order to prove Theorem B.3, we need the following auxiliary proposition, similar to Proposition A.11 for relations.

Proposition B.2.

Let $\Rel$ be a blind bisimulation. Let $\node,\nodex$ nodes such that $\node\Rel\nodex$, and $\tra$ a trace such that $\Path\tra\node$ crosses $\nodel$ and $\Path\tra\nodex$ crosses $\nodelx$. Then $\nodel\Rel\nodelx$ if and only if ${\tt index}(\nodel\mid\Path\tra\node)={\tt index}(\nodelx\mid\Path\tra\nodex)$.

Proof.

Let $\Path\tra\node{\node^{\prime}}$ and $\Path\tra\nodex{\nodex^{\prime}}$. Note that by Proposition A.5 it follows that $\node^{\prime}\Rel\nodex^{\prime}$, which implies that $\node^{\prime}$ and $\nodex^{\prime}$ have the same label since $\Rel$ is homogeneous. We proceed by structural induction on the trace $\tra$, and following the cases of the definition of ${\tt index}(\nodel\mid\Path\tra\node)$ and ${\tt index}(\nodelx\mid\Path\tra\nodex)$.

1. (1)

Case ${\tt index}(\nodel\mid\Path\tra\node\nodel)=0={\tt index}(\nodelx\mid\Path\tra\nodex\nodelx)$. From Proposition A.5 we obtaine $\nodel\DownClos\Rel\nodelx$, and we can conclude. 2. (2)

Case ${\tt index}(\nodel\mid\Pathp{\pcons d\tra}\node\nodel)=0\neq 1+{\tt index}(\nodelx\mid\Path\tra\nodex)={\tt index}(\nodelx\mid\Pathp{\pcons d\tra}\nodex)$ with $\nodelx\neq\nodex^{\prime}$. It holds that $\nodel\DownClos\Rel\nodex$, and from the fact that $\Path\tra\nodex{\nodex^{\prime}}$ crosses $\nodelx$ we obtain by Proposition A.10 a trace $\trax$ such that $\Pathp{\pcons d\trax}\nodelx{\nodex^{\prime}}$. From Proposition A.9 (using $\nodel\Rel\nodex^{\prime}$ and $\Pathp{\pcons d\trax}\nodelx{\nodex^{\prime}}$) we obtain $\nodel\not\Rel\nodelx$ and conclude. 3. (3)

Case ${\tt index}(\nodel\mid\Pathp{\pcons d\tra}\node)=1+{\tt index}(\nodel\mid\Path\tra\node)\neq 0={\tt index}(\nodel\mid\Path\tra\nodex\nodelx)$ with $\nodel\neq\node^{\prime}$. Symmetric to the case above. 4. (4)

Case ${\tt index}(\nodel\mid\Pathp{\pcons d\tra}\node)=1+{\tt index}(\nodelx\mid\Path\tra\node)$ and ${\tt index}(\nodelx\mid\Pathp{\pcons d\tra}\nodex)=1+{\tt index}(\nodelx\mid\Path\tra\nodex)$ with $\nodel\neq\node^{\prime}$ and $\nodelx\neq\nodex^{\prime}$. Use the \ih to conclude. 5. (5)

Case ${\tt index}(\nodel\mid\Pathp{\pcons d\tra}\node)={\tt index}(\nodel\mid\Path\tra\node)$ and ${\tt index}(\nodelx\mid\Pathp{\pcons d\tra}\nodex)={\tt index}(\nodelx\mid\Path\tra\nodex)$: use the \ih to conclude.

∎

We can now prove:

Theorem B.3.

Let $\Que$ a query over a \ladag $G$. $\DownClos\Que$ is an open bisimulation if and only if $\trxnp\node=\trxnp\nodex$ for every nodes $\node,\nodex$ such that $\node\Que\nodex$.

Proof.

First note that $\DownClos\Que$ is an open bisimulation if and only if $\DownClos\Que$ is open, homogeneous, and closed under \RuleBV. We now prove separately the two implications of the statement of the theorem:

• ($\Leftarrow$)

Assume $\trxnp\node=\trxnp\nodex$ for every $\node\Que\nodex$; we prove that $\DownClos\Que$ is open, homogeneous, and closed under \RuleBV:

• –

Open. Let $\node\DownClos\Que\nodex$ where $\node$ and $\nodex$ are free variable nodes. By Proposition A.8, $\Path\tra{\node^{\prime}}\node$ and $\Path\tra{\nodex^{\prime}}\nodex$ for some $\tra$ and $\node^{\prime}\Que\nodex^{\prime}$. By Proposition B.1 $\trx{\Path\tra{\node^{\prime}}}=\trx{\Path\tra{\nodex^{\prime}}}$. By the definition of readback to \lats $\overline{\texttt{name}(\node)}=\overline{\texttt{name}(\nodex)}$, which implies $\texttt{name}(\node)=\texttt{name}(\nodex)$ and therefore $\node=\nodex$.

• –

Homogeneous. Let $\node\DownClos\Que\nodex$. By Proposition A.8, $\Path\tra{\node^{\prime}}\node$ and $\Path\tra{\nodex^{\prime}}\nodex$ for some $\tra$ and $\node^{\prime}\Que\nodex^{\prime}$. By Proposition B.1 $\trx{\Path\tra{\node^{\prime}}}=\trx{\Path\tra{\nodex^{\prime}}}$. Conclude by the definition of readback to \lats.

• –

Closed under \RuleBV. Let $\nbvar\nodel\DownClos\Que\nbvar\nodelx$: we need to prove that $\nodel\DownClos\Que\nodelx$. By Proposition A.8, $\Path\tra\node{\nbvar\nodel}$ and $\Path\tra\nodex{\nbvar\nodelx}$ for some $\tra$ and $\node\Que\nodex$, and by Proposition B.1 $\trx{\Path\tra\node{\nbvar\nodel}}=\trx{\Path\tra\nodex{\nbvar\nodelx}}$. By the definition of the readback to \lats, ${\tt index}(\nodel\mid\Path\tra\node)={\tt index}(\nodelx\mid\Path\tra\nodex)$. Conclude by Proposition B.2.

• ($\Rightarrow$)

Assume that $\DownClos\Que$ is open, homogeneous, and closed under \RuleBV, and let $\node\Que\nodex$. In order to prove that $\trxnp\node=\trxnp\nodex$, by Proposition B.1 it suffices to prove that for every trace $\tra$ the conditions Trace Equivalence and Trace Propagation hold:

• –

Trace Equivalence. Note that $\node\Que\nodex$ implies $\node\DownClos\Que\nodex$, and conclude by Proposition A.6.

• –

Trace Propagation. Assume $\Path\tra\node{\node^{\prime}}$ and $\Path\tra\nodex{\nodex^{\prime}}$. By Proposition A.8, $\node^{\prime}\DownClos\Que\nodex^{\prime}$. Note that $\node^{\prime}$ and $\nodex^{\prime}$ have the same label because $\DownClos\Que$ is homogeneous by hypothesis. By the property that the \ladag is finite and acyclic, there exists a bound on the length of traces in the \ladag, say $B$. The proof that $\trx{\node^{\prime}}=\trx{\nodex^{\prime}}$ proceeds by (course of value) induction on $B-|\tra|$, and by cases on the label of the nodes:

The cases $\nfvar\DownClos\Que\nbvar\nodel$ and $\nbvar\nodel\DownClos\Que\nfvar$ are impossible because $\DownClos\Que$ is homogeneous.

• *

Case $\nfvar\DownClos\Que\nfvar$. From the hypothesis that $\DownClos\Que$ is open it follows that $\node^{\prime}=\nodex^{\prime}$, and we conclude.

• *

Case $\nbvar\nodel\DownClos\Que\nbvar\nodelx$. From the hypothesis that $\DownClos\Que$ is closed under \RuleBV it follows that $\nodel\DownClos\Que\nodelx$. We need to show that $\trx{\Path\tra\node{\nbvar\nodel}}=\trx{\Path\tra\nodex{\nbvar\nodelx}}$, \ie ${\tt index}(\nodel\mid\Path\tra\node{\nbvar\nodel})={\tt index}(\nodelx\mid\Path\tra\nodex{\nbvar\nodelx})$. Since $\Que$ is a query, $\Path\tra\node$ crosses $\nodel$ and $\Path\tra\nodex$ crosses $\nodelx$. The thesis ${\tt index}(\nodel\mid\Path\tra\node{\nbvar\nodel})={\tt index}(\nodelx\mid\Path\tra\nodex{\nbvar\nodelx})$ follows from Proposition B.2.

• *

Case $\LabelAbs$. By \ih $\trx{\Pathp{\pcons\pdown\tra}{\node}}=\trx{\Pathp{\pcons\pdown\tra}{\nodex}}$. We conclude by the definition of readback, since $\trx{\Path\tra\node}=\lambda{\trx{\Pathp{\pcons\pdown\tra}{\node}}}$ and $\trx{\Pathp{\pcons\pdown\tra}{\nodex}}=\lambda{\trx{\Pathp{\pcons\pdown\tra}{\nodex}}}$.

• *

Case $\LabelApp$. By \ih $\trx{\Pathp{\pcons\pleft\tra}{\node}}=\trx{\Pathp{\pcons\pleft\tra}{\nodex}}$ and $\trx{\Pathp{\pcons\pright\tra}{\node}}=\trx{\Pathp{\pcons\pright\tra}{\nodex}}$. We conclude by the definition of readback, since $\trx{\Path\tra\node}=\trx{\Pathp{\pcons\pleft\tra}{\node}}\,{\trx{\Pathp{\pcons\pright\tra}{\node}}}$ and $\trx{\Path\tra\nodex}=\trx{\Pathp{\pcons\pleft\tra}{\nodex}}\,{\trx{\Pathp{\pcons\pright\tra}{\nodex}}}$. ∎

Proof of 0 (Theorem 4.7).

“??”

Proof.

By Theorem A.25 and Theorem B.3. ∎

Appendix C “Up To” Relations

We introduce the notion of relations that are propagated up to another relation. This new concept will be necessary when formulating the invariants of the algorithm, which need to capture properties of incomplete relations since the algorithm progressively constructs the required relations.

Definition C.1 (Propagated Up To).

Let $\Rel,\Relx$ be binary relations over the nodes of a \ladag $G$. We say that $\Rel$ is propagated up to $\Relx$ when $\Rel$ is closed under the following rules (which are variants of the rules \RuleAppl \RuleAppr \RuleAbs  in Figure 3):

1. (1)

$\napp{\node_{1}}{\node_{2}}\Rel\napp{\nodex_{1}}{\nodex_{2}}$

$\node_{1}\Relx\nodex_{1}$ 2. (2)

$\napp{\node_{1}}{\node_{2}}\Rel\napp{\nodex_{1}}{\nodex_{2}}$

$\node_{2}\Relx\nodex_{2}$ 3. (3)

$\nabs\node\Rel\nabs\nodex$

$\node\Relx\nodex$

Note that when the relations $\Rel$ and $\Relx$ are the same, the concept of propagated up to coincides with the usual concept of propagated:

Fact C.2.

If a relation $\Rel$ is propagated upto $\Rel$, then $\Rel$ is simply propagated.

Two properties of up to relations follow. The first proposition shows that the property of being propagated upto $\Relx$ is monotonous on $\Relx$.

Proposition C.3 (Monotonicity).

Let $\Rel,\Relx,\Relxx$ be binary relations over the nodes of a \ladag $G$. If $\Rel$ is propagated upto $\Relx$, and ${\Relx}\subseteq{\Relxx}$, then $\Rel$ is propagated upto $\Relxx$.

Proof.

Let $\Rel$ be propagated upto $\Relx$, and let $\Relxx$ be a relation such that ${\Relx}\subseteq{\Relxx}$. In order to show that $\Rel$ is propagated upto $\Relxx$, it suffices to check that it is closed under the rules of Definition C.1. We show that it is closed under the first rule, the proof for the other rules is similar. Let $\napp{\node_{1}}{\node_{2}}\Rel\napp{\nodex_{1}}{\nodex_{2}}$; since $\Rel$ is propagated upto $\Relx$, it follows that $\node_{1}\Relx\nodex_{1}$. Since ${\Relx}\subseteq{\Relxx}$, we conclude with $\node_{1}\Relxx\nodex_{1}$. ∎

The second proposition shows that the property of being propagated upto commutes with the rst-closure.

Proposition C.4.

Let $\Rel$ be a binary relation over the nodes of a \ladag $G$, and assume $\Rel$ to be homogeneous. If $\Rel$ is propagated upto $\Rel^{*}$, then $\Rel^{*}$ is propagated.

Proof.

Let $\Rel$ be propagated upto $\Rel^{*}$. In order to prove that $\Rel^{*}$ is propagated, by C.2 it suffices to prove that $\Rel^{*}$ is propagated upto $\Rel^{*}$. The rest of the proof is similar to the proof of Proposition A.16. ∎

Definition C.5 (Blind Bisimulation Upto).

Let $\Rel,\Relx$ be binary relations over the nodes of a \ladag $G$. We say that $\Rel$ is a blind bisimulation upto $\Relx$ when $\Rel$ is homogeneous and propagated upto $\Relx$.

Appendix D The Blind Check

D.1. General Properties

In this section, we are going to prove general properties of program runs. The properties are grouped according to the concepts that they analyse, \ie canonic assignment, BuildEquivalenceClass, EnqueueAndPropagate, enqueuing, dequeuing, parents, ${\mathrel{\sim}}$neighbours.

Canonic Assignment.

The algorithm assigns a canonic to each node $\node$: intuitively, ${{\texttt{c}}}(\node)$ is the canonic representative of the equivalence class to which $\node$ belongs.

The following lemma is a key property required by many of the next results: it shows that nodes cannot change class during a program run, \ie once a node is assigned to an equivalence class, it is never re-assigned.

Proposition D.1 (Canonic Assignment is Definitive).

Let $\node$ be a node. In every program run:

• •

${{\texttt{c}}}(\node)$* is never assigned to undefined;*

• •

${{\texttt{c}}}(\node)$* is assigned at most once.*

Proof.

No line of the algorithm assigns a canonic to undefined, \ie after ${{\texttt{c}}}(\node)$ is defined, it remains defined throughout the program run.

In order to show that ${{\texttt{c}}}(\node)$ is never assigned twice, it suffices to show that, whenever a canonic is assigned, it was previously undefined. A canonic is assigned only during the execution of two lines of the algorithm:

• •

Algorithm 1, during the execution of BuildEquivalenceClass(c) that assigns ${{\texttt{c}}}(c)\defeq c$. Note that only Algorithm 1 and Algorithm 1 can call BuildEquivalenceClass, and both lines check beforehand whether the canonic of $c$ is undefined.

• •

Algorithm 1, during the execution of EnqueueAndPropagate(\nodetwo, c) that assigns ${{\texttt{c}}}(\nodetwo)$ to $c$. Only Algorithm 1 can call EnqueueAndPropagate, and that line checks beforehand whether the canonic of $\nodetwo$ is undefined. ∎

The following lemma shows that the mechanism of canonic representatives is correct, \ie if $c$ is assigned as canonic of an equivalence class, then $c$ is itself a representative of that class:

Proposition D.2 (${{\texttt{c}}}(\cdot)$ is Idempotent).

Let $c,\node$ be nodes, and $\State$ be a reachable state such that ${{\texttt{c}}}(\node)=c$. Then ${{\texttt{c}}}(c)$ is defined and ${{\texttt{c}}}(c)=c$.

Proof.

Let $\node$ be a node. It suffices to show that whenever ${{\texttt{c}}}(\node)$ is assigned to $c$, it holds that ${{\texttt{c}}}(c)=c$; once true, this assertion cannot be later falsified because the canonic assignment is definitive (Proposition D.1).

A canonic is assigned only during the execution of two lines of the algorithm:

• •

Algorithm 1, during the execution of BuildEquivalenceClass(c). In this case $\node=c$ and we conclude.

• •

Algorithm 1, during the execution of EnqueueAndPropagate(\nodetwo,c) that assigns ${{\texttt{c}}}(\nodetwo)$ to $c$. Only Algorithm 1 of BuildEquivalenceClass(c) can call EnqueueAndPropagate(\nodetwo, c), and that line comes after Algorithm 1 which sets ${{\texttt{c}}}(c)$ to $c$. Therefore ${{\texttt{c}}}(c)=c$ in $\State$ as well, because the canonic assignment is definitive (Proposition D.1). ∎

During a program run nodes are assigned a canonic, \ie temporary equivalence classes are extended with new nodes. If the algorithm terminates successfully, the equivalence classes cover the whole set of nodes, as the following lemma shows:

Proposition D.3 (Canonic Assignment Completed).

In a final state $\State_{f}$, every node has a canonic assigned.

Proof.

Let $\node$ be a node, and let us show that ${{\texttt{c}}}(\node)$ is defined in $\State_{f}$. Since the algorithm terminated, execution exited the main loop on Algorithm 1. That loop iterates on every node $\node$ of the \ladag, therefore for every $\node$ there must exist a state $\State$ prior to $\State_{f}$ such that the next transition is the execution of Algorithm 1 with local variable $\node$. Algorithm 1 first checks whether ${{\texttt{c}}}(\node)$ is defined. If it is, it does nothing, and we can conclude because ${{\texttt{c}}}(\node)$ must be defined in $\State_{f}$ too since the canonic assignment is definitive (Proposition D.1). If instead ${{\texttt{c}}}(\node)$ is not defined in $\State$, then BuildEquivalenceClass(\node) is called; when BuildEquivalenceClass(\node) is executed, $\node$ is assigned a canonic (Algorithm 1), and again the canonic is still assigned in $\State_{f}$ since the canonic assignment is definitive (Proposition D.1). ∎

BuildEquivalenceClass.

The procedure BuildEquivalenceClass(c) has the effect of constructing the equivalence class of a node $c$, where $c$ is chosen as canonic representative of that class.

Proposition D.4 (No Multiple Calls to BuildEquivalenceClass(\node)).

In every program run, BuildEquivalenceClass(\node*) is called at most once for every node $\node$.*

Proof.

Only Algorithm 1 and Algorithm 1 can call $\textnormal{{BuildEquivalenceClass}}(\node)$, and only if the canonic of $\node$ is undefined. Right after BuildEquivalenceClass(\node) is called, Algorithm 1 is executed, and a canonic is assigned to $\node$. Therefore another call to BuildEquivalenceClass(\node) is not possible in the future, because ${{\texttt{c}}}(\node)$ cannot be ever assigned again to undefined (Proposition D.1). ∎

A node $c$ can be assigned as a canonic representative only if BuildEquivalenceClass(c) has been called:

Proposition D.5 (Only BuildEquivalenceClass(c) Designates Canonics).

Let $c,\node$ be nodes, and $\State$ be a reachable state such that ${{\texttt{c}}}(\node)=c$. Then BuildEquivalenceClass(c) has been called before $\State$.

Proof.

$c$ is assigned as a canonic only during the execution of two lines of the algorithm:

• •

Algorithm 1, during the execution of BuildEquivalenceClass(c).

• •

Algorithm 1, during the execution of EnqueueAndPropagate(\nodetwo,c) that sets ${{\texttt{c}}}(\nodetwo)$ to $c$. Only Algorithm 1 of BuildEquivalenceClass(c) can call EnqueueAndPropagate(\nodetwo,c). ∎

EnqueueAndPropagate.

The function EnqueueAndPropagate(\nodetwo,c) adds the node $\nodetwo$ to the equivalence class represented by $c$, and delays the processing of $\nodetwo$ by pushing it into ${\tt q}(c)$.

Proposition D.6 (No Multiple Calls to EnqueueAndPropagate(\node,–)).

In every program run, EnqueueAndPropagate(\node,–) is called at most once for every node $\node$.

Proof.

Only Algorithm 1 can call $\textnormal{{EnqueueAndPropagate}}(\nodetwo,c)$, and only if the canonic of $\nodetwo$ is undefined. After EnqueueAndPropagate(\nodetwo,c) is called, Algorithm 1 is executed, and a canonic is assigned to $\nodetwo$. Therefore another call to BuildEquivalenceClass(\nodetwo,–) is not possible in the future, because ${{\texttt{c}}}(\nodetwo)$ cannot be ever assigned again to undefined (Proposition D.1). ∎

Enqueuing.

Two lines of the algorithm push a node to a queue: Algorithm 1, when ${\tt q}(c)$ is created and $c$ pushed to it; Algorithm 1, when $\nodetwo$ is pushed to ${\tt q}(c)$. Intuitively, pushing a node to ${\tt q}(c)$ results in delaying its processing by the algorithm; the node will be fully processed only later, after being popped from the queue (Lines 1–1).

Proposition D.7 (Enqueue Once).

In a program run, every node $\node$ is enqueued at most once.

Proof.

The algorithm enqueues a node only shortly after setting its canonic:

• •

on Algorithm 1, after assigning a canonic on Algorithm 1;

• •

on Algorithm 1, right after assigning a canonic on Algorithm 1.

Since the canonic of a node can be assigned at most once (Proposition D.1), it follows that a node can be enqueued at most once. ∎

The following lemma shows that ${\tt q}(c)$ is a subset of the equivalence class with canonic representative $c$:

Proposition D.8 (Queue $\subseteq$ Equivalence Class).

Let $\State$ be a reachable state, and $\node$ a node. If $\node\in{\tt q}(c)$, then ${{\texttt{c}}}(\node)$ is defined and ${{\texttt{c}}}(\node)=c$.

Proof.

Let $\node$ be a node. Since the canonic assignment is definitive (Proposition D.1), it suffices to check that ${{\texttt{c}}}(\node)=c$ whenever $\node$ is enqueued to ${\tt q}(c)$. A node is enqueued only during the execution of two lines of the algorithm:

• •

Algorithm 1 during the execution of BuildEquivalenceClass(c). In this case $\node=c$, and the canonic of $c$ was just assigned to $c$ itself on Algorithm 1.

• •

Algorithm 1 during the execution of EnqueueAndPropagate(\nodetwo, c). Algorithm 1 is executed right after Algorithm 1, which sets ${{\texttt{c}}}(\nodetwo)\defeq c$. ∎

Dequeuing.

Nodes are popped from a queue only on Algorithm 1. Once a node is dequeued, the algorithm proceeds by first visiting its parents (Algorithm 1) and then its ${\mathrel{\sim}}$neighbours (Algorithm 1).

Proposition D.9 (Dequeued Nodes Have Correct Canonic).

Let $\State$ be a state reached after the execution of Algorithm 1 with locals $c,\node$. Then ${{\texttt{c}}}(\node)$ is defined and ${{\texttt{c}}}(\node)=c$.

Proof.

Let $\node$ be a node. $\node\in{\tt q}(c)$ in the state $\State^{\prime}$ right before the execution of Algorithm 1 with locals $c,\node$. Therefore ${{\texttt{c}}}(\node)=c$ in $\State^{\prime}$ by Proposition D.8. Conclude with ${{\texttt{c}}}(\node)=c$ in $\State$ because the canonic assignment is definitive (Proposition D.1). ∎

Definition D.10 (Processed Node).

In a reachable state $\State$, we say that a node $\node$ has already been processed if Lines 1–1 with locals $c,\node$ have already been executed (for some $c$).

In other words, a node $\node$ is processed after it is dequeued and its parents and ${\mathrel{\sim}}$neighbours visited.

After BuildEquivalenceClass(c) returns, all the nodes in the equivalence class of $c$ are processed:

Proposition D.11 (Equivalence Class Processed).

Let $c,\node$ be nodes, and $\State$ a reachable state such that BuildEquivalenceClass(c) has already returned. If ${{\texttt{c}}}(\node)=c$, then $\node$ is processed.

Proof.

${{\texttt{c}}}(\node)$ is assigned to $c$ only during the execution of BuildEquivalenceClass(c) (Proposition D.5). First, note that shortly after ${{\texttt{c}}}(\node)$ is assigned to $c$ (Algorithm 1 or Algorithm 1), $\node$ is enqueued to ${\tt q}(c)$ (resp. Algorithm 1 and Algorithm 1).

In both cases, $\node$ is enqueued to ${\tt q}(c)$ when the execution of the while loop on Algorithm 1 has not terminated yet: on Algorithm 1 before the beginning of the loop, on Algorithm 1 during the execution of the loop, since EnqueueAndPropagate is called from Algorithm 1 which is inside the while loop.

Note also that a node $\node$ is dequeued from ${\tt q}(c)$ only on Algorithm 1 during the execution of BuildEquivalenceClass(c), and that BuildEquivalenceClass(c) can be called at most once (Proposition D.4).

In conclusion, $\node$ was enqueued to ${\tt q}(c)$ before the completion of the while loop on ${\tt q}(c)$ on Algorithm 1, and since BuildEquivalenceClass(c) has already returned and the while loop terminated, at some point $\node$ was dequeued from ${\tt q}(c)$ on Algorithm 1, and the body of the loop executed with locals $c,\node$. ∎

Proposition D.12 (Dequeue Once).

In each program run, Algorithm 1 is executed with local $\node$ at most once for every node $\node$.

Proof.

Executing Algorithm 1 with local $\node$ dequeues $\node$, which cannot be enqueued twice by Proposition D.7. ∎

Parents.

The loop on Algorithm 1 iterates on all the parents of a node, building their equivalence classes:

Proposition D.13 (Parent Classes Built).

Let $c,\node$ be nodes, and let $\State$ be a state reachable after the execution of the loop on Algorithm 1 of BuildEquivalenceClass(c) with local variables $c,\node$. Then for every parent $\nodetwo$ of $\node$:

• •

${{\texttt{c}}}(\nodetwo)$* is defined, say ${{\texttt{c}}}(\nodetwo)=c^{\prime}$;*

• •

BuildEquivalenceClass($c^{\prime}$)* has been called and has already returned.*

Proof.

The loop on Algorithm 1 iterates on all parents of $\node$. For every parent $\nodetwo$:

• •

If $\nodetwo$ has no canonic assigned, BuildEquivalenceClass(\nodetwo) is called (Algorithm 1). Since $\State$ is reached after the execution of the loop, the call to BuildEquivalenceClass(\nodetwo) has already returned. Note that $\nodetwo$ was assigned itself as a canonic on Algorithm 1 of BuildEquivalenceClass(\nodetwo), and ${{\texttt{c}}}(\nodetwo)=\nodetwo$ still in $\State$ (Proposition D.1).

• •

If $\nodetwo$ has some $c^{\prime}$ assigned as a canonic node, then Algorithm 1 enforces that $\texttt{building}(c^{\prime})={\tt false}$. This means that Algorithm 1 of BuildEquivalenceClass($c^{\prime}$) has already been executed, and therefore BuildEquivalenceClass($c^{\prime}$) has already returned. ∎

${\mathrel{\sim}}$neighbours.

The loop on Algorithm 1 iterates on all the ${\mathrel{\sim}}$neighbours of a node. Note that the loop does not remove $\mathrel{\sim}$edges after iterating on them: in fact, the algorithm simply ignores $\mathrel{\sim}$edges that have already been encountered, as it calls EnqueueAndPropagate only on ${\mathrel{\sim}}$neighbours that have not been enqueued yet (Algorithm 1).

Proposition D.14 ($\mathrel{\sim}$ Grows).

During a program run, $\mathrel{\sim}$ monotonically grows.

Proof.

Just note that no line of the algorithm removes $\mathrel{\sim}$edges. ∎

After the parent classes of a node are built, the set of its ${\mathrel{\sim}}$neighbours is not going to change during the program run:

Proposition D.15 (Finalization of ${\mathrel{\sim}}$neighbours).

Let $c,\node$ be nodes. No $\mathrel{\sim}$edge with endnode $\node$ can be created in any state $\State$ reached after the execution of the loop on Algorithm 1 with local variables $c,\node$.

Proof.

Assume by contradiction that $\State$ is a state reached after the execution of the loop on Algorithm 1 with locals $c,\node$, and that the next transition creates a new $\mathrel{\sim}$edge with endnode $\node$. New $\mathrel{\sim}$edges may be created only on Algorithm 1 and Algorithm 1 during the execution of EnqueueAndPropagate($\nodetwo,c^{\prime}$) for some nodes $\nodetwo,c^{\prime}$. Note that a $\mathrel{\sim}$edge with endpoint $\node$ may be created by these lines only if $\node$ has either $\nodetwo$ or $c^{\prime}$ as a parent. We show that these cases are both not possible:

• •

$\nodetwo$ cannot be a parent of $\node$ since ${{\texttt{c}}}(\nodetwo)$ is undefined because of the check on Algorithm 1 (the only line that may call EnqueueAndPropagate), while by Proposition D.13 all parents of $\node$ have a canonic assigned.

• •

In order to show that $c^{\prime}$ cannot be a parent of $\node$, note first that BuildEquivalenceClass(c’) has not returned yet, since EnqueueAndPropagate(\nodetwo,c’) is called only on Algorithm 1 of BuildEquivalenceClass(c’). Note also that ${{\texttt{c}}}(c^{\prime})=c^{\prime}$ because Algorithm 1 of BuildEquivalenceClass(c’) has already been executed.

Therefore $c^{\prime}$ cannot be a parent of $\node$ by Proposition D.13. ∎

The following lemma proves that, after the ${\mathrel{\sim}}$neighbours of a node $\node$ are handled by the loop on Algorithm 1, the canonic assignment subsumes the relation $\mathrel{\sim}$ on $\node$:

Proposition D.16 (All ${\mathrel{\sim}}$neighbours Visited).

Let $\State$ be a state reachable after the execution of the loop on Algorithm 1 with local variables $c,\node$. Then for every $\mathrel{\sim}$edge with endnodes $\node$ and $\nodetwo$, $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$.

Proof.

Let $\State^{\prime}$ be the state prior to $\State$ in which execution is just entering the loop on Algorithm 1. Note that both $\State^{\prime}$ and $\State$ are reached only after the execution of the loop on Algorithm 1 (with locals $c,\node$), and therefore in $\State^{\prime}$ and $\State$ are present the same $\mathrel{\sim}$edges with endnode $\node$ (by Proposition D.14 and Proposition D.15). The loop on Algorithm 1 iterates on all such $\mathrel{\sim}$edges with endnodes $\node$ and $\nodetwo$, and for each $\nodetwo$ it either:

• •

Algorithm 1: calls EnqueueAndPropagate(\nodetwo,c), which sets ${{\texttt{c}}}(\nodetwo)\defeq c$ before returning (Algorithm 1);

• •

Algorithm 1: explicitly enforces that ${{\texttt{c}}}(\nodetwo)=c$.

In both cases, we obtain that ${{\texttt{c}}}(\nodetwo)=c$ holds also in $\State$ (because $\State$ is reached after the execution of the loop on Algorithm 1, and the canonic assignment is immutable by Proposition D.1). Note also that ${{\texttt{c}}}(\node)=c$ in $\State$ by Proposition D.9, since $\State$ is reached after the execution of Algorithm 1 which dequeues $\node$ from ${\tt q}(c)$.

We thus obtain ${{\texttt{c}}}(\node)={{\texttt{c}}}(\nodetwo)=c$ in $\State$, \ie $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$. ∎

In the following sections, we are going to prove that Algorithm 1 is sound (Section D.2), complete (Section D.3), and that it runs in linear time (Section D.4).

D.2. Correctness

Definition D.17 (Same Canonic, $=_{\texttt{c}}$).

In every reachable state $\State$ we define $=_{\texttt{c}}$, a binary relation on the nodes of the \ladag such that, for all nodes $\node$,$\nodetwo$: $\node=_{\texttt{c}}\nodetwo$ iff ${{\texttt{c}}}(\node)$ and ${{\texttt{c}}}(\nodetwo)$ are both defined and ${{\texttt{c}}}(\node)={{\texttt{c}}}(\nodetwo)$.

First of all, let us show that $=_{\texttt{c}}$ is identical to $\mathrel{{{\texttt{c}}}}^{*}$ in all final states: this allows to simplify the following proofs, using the more familiar relation $\mathrel{{{\texttt{c}}}}$ instead of the the new $=_{\texttt{c}}$.

Proposition D.18.

Let $\State_{f}$ be a final state. Then for all nodes $\node,\nodetwo$: $\node=_{\texttt{c}}\nodetwo$ if and only if $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$.

Proof.

First note that in $\State_{f}$ all nodes have a canonic assigned by Proposition D.3.

• $(\Rightarrow)$

Let $\node=_{\texttt{c}}\nodetwo$, and let us prove that $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$. By the definition of $=_{\texttt{c}}$, there exists $c$ such that ${{\texttt{c}}}(\node)={{\texttt{c}}}(\nodetwo)=c$. By the definition of $\mathrel{{{\texttt{c}}}}$, it holds that $\node\mathrel{{{\texttt{c}}}}c$ and $\nodetwo\mathrel{{{\texttt{c}}}}c$, and therefore clearly $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$.

• $(\Leftarrow)$

Let $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$, and let us prove that $\node=_{\texttt{c}}\nodetwo$. We proceed by induction on the definition of $\mathrel{{{\texttt{c}}}}^{*}$:

• –

Base case. Assume that $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$ because $\node\mathrel{{{\texttt{c}}}}\nodetwo$, \ie because ${{\texttt{c}}}(\node)=\nodetwo$. By Proposition D.2, ${{\texttt{c}}}(\nodetwo)=\nodetwo$, and therefore $\node=_{\texttt{c}}\nodetwo$.

• –

Rule \RuleRefl. Assume that $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$ and $\node=\nodetwo$. From the hypothesis it follows that $\node$ has a canonic assigned, and therefore clearly $\node=_{\texttt{c}}\node$.

• –

Rule \RuleSym. Assume that $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$ because $\nodetwo\mathrel{{{\texttt{c}}}}^{*}\node$. By \ih $\nodetwo=_{\texttt{c}}\node$, and we conclude because $=_{\texttt{c}}$ is symmetric.

• –

Rule \RuleTrans. Assume that $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$ because $\node\mathrel{{{\texttt{c}}}}^{*}\nodethree$ and $\nodethree\mathrel{{{\texttt{c}}}}^{*}\nodetwo$ for some node $\nodethree$. By \ih $\node=_{\texttt{c}}\nodethree$ and $\nodethree=_{\texttt{c}}\nodetwo$, and we conclude because $=_{\texttt{c}}$ is transitive. ∎

In order to prove that $=_{\texttt{c}}$ equals $\DownEquivClos\Que$ in $\State_{f}$ (Proposition D.25), we are going to prove that $\mathrel{{{\texttt{c}}}}^{*}$ is homogeneous and propagated (Proposition D.24). The following lemma is a relaxed variant of that statement which holds for all reachable states: it collapses to the desired statement in the final state because $({\mathrel{\sim}}\cup{=})=(\mathrel{{{\texttt{c}}}}^{*})$.

Proposition D.19 ($\mathrel{{{\texttt{c}}}}$ is Upto).

Let $\State$ be a reachable state. Then $\mathrel{{{\texttt{c}}}}$ is a blind bisimulation upto $({\mathrel{\sim}}\cup{=})$.

Proof.

We prove the statement by induction on the length of the program run leading to $\State$:

• •

In the initial state ${\mathrel{{{\texttt{c}}}}}=\emptyset$, and therefore the statement holds trivially.

• •

As for the inductive step, we only need to discuss the program transitions that alter $\mathrel{\sim}$ and $\mathrel{{{\texttt{c}}}}$. But first of all, note that $\mathrel{\sim}$ can only grow (Proposition D.14), and that creating new $\mathrel{\sim}$edges (while keeping $\mathrel{{{\texttt{c}}}}$ unchanged) does not falsify the statement if it was true before the addition. Therefore we actually need to discuss only the transitions that alter the canonical assignment, \ie Algorithm 1 and Algorithm 1:

• –

Algorithm 1: by \ih, $\mathrel{{{\texttt{c}}}}$ was homogeneous and propagated upto $({\mathrel{\sim}}\cup{=})$ before the execution of the assignment ${{\texttt{c}}}(c)=c$. After the execution of that assignment, $\mathrel{{{\texttt{c}}}}$ differs only for the new entry $(c,c)$. Clearly the new entry satisfies the homogeneous condition, and it satisfies the property of being propagated upto $=$.

• –

Algorithm 1, during the execution of EnqueueAndPropagate(\nodetwo, c): by \ih, $\mathrel{{{\texttt{c}}}}$ was homogeneous and propagated upto $({\mathrel{\sim}}\cup{=})$ before the execution of the assignment ${{\texttt{c}}}(\nodetwo)\defeq c$. After the execution of that assignment, $\mathrel{{{\texttt{c}}}}$ differs only for the new entry $(\nodetwo,c)$. The new entry satisfies the homogeneous condition and the property of being propagated upto $\mathrel{\sim}$ because of the code executed in Lines 1–1, which checked the labels of the nodes and created $\mathrel{\sim}$edges on the corresponding children of $\nodetwo,c$ if any. ∎

The following Proposition D.20 and Proposition D.21 state properties that connect the relations $\mathrel{{{\texttt{c}}}}$, $\Que$, and $\mathrel{\sim}$. In a final state $\mathrel{{{\texttt{c}}}}^{*}$ is exactly $\mathrel{\sim}^{*}$, but in intermediate states the following weaker property holds:

Proposition D.20.

In every reachable state $\State$: ${\mathrel{{{\texttt{c}}}}}\subseteq{\mathrel{\sim}^{*}}$.

Proof.

We prove the statement by induction on the length of the program run leading to $\State$:

• •

In the initial state, ${\mathrel{{{\texttt{c}}}}}=\emptyset$ and therefore the statement holds trivially.

• •

As for the inductive step, we only need to discuss the program transitions that alter $\mathrel{\sim}$ and $\mathrel{{{\texttt{c}}}}$. But first of all, note that during the execution of the algorithm $\mathrel{\sim}$ can only grow (Proposition D.14), and that creating new $\mathrel{\sim}$edges (while keeping $\mathrel{{{\texttt{c}}}}$ unchanged) does not falsify the statement if it was true before the addition. Therefore we actually need to discuss only the transitions that alter the canonical assignment, \ie Algorithm 1 and Algorithm 1:

• –

Algorithm 1: by \ih, ${\mathrel{{{\texttt{c}}}}}\subseteq{\mathrel{\sim}^{*}}$ before the execution of the assignment ${{\texttt{c}}}(c)=c$. After the execution of that assignment, $\mathrel{{{\texttt{c}}}}$ differs only for the new entry $(c,c)$. Clearly $c\mathrel{\sim}^{*}c$ because $\mathrel{\sim}^{*}$ is reflexive by definition.

• –

Algorithm 1, during the execution of EnqueueAndPropagate(\nodetwo, c): by \ih, ${\mathrel{{{\texttt{c}}}}}\subseteq{\mathrel{\sim}^{*}}$ before the execution of the assignment ${{\texttt{c}}}(\nodetwo)\defeq c$. After the execution of that assignment, $\mathrel{{{\texttt{c}}}}$ differs only for the new entry $(\nodetwo,c)$. Note that EnqueueAndPropagate(\nodetwo, c) is called from Algorithm 1 during the execution of BuildEquivalenceClass(c). Because of the loop on Algorithm 1, $\nodetwo$ was a ${\mathrel{\sim}}$neighbour of $\node$ for some node $\node$, and it still is because $\mathrel{\sim}$ can only grow (Proposition D.14). We are now going to prove that $\node\mathrel{\sim}^{*}c$, which together with the fact that $\nodetwo$ is a ${\mathrel{\sim}}$neighbour of $\node$, will allow us to conclude with $\nodetwo\mathrel{\sim}^{*}c$.

Algorithm 1 is executed after Algorithm 1, therefore ${{\texttt{c}}}(\node)=c$ (\ie $\node\mathrel{{{\texttt{c}}}}c$) by Proposition D.9. By \ih $\node\mathrel{{{\texttt{c}}}}c$ implies $\node\mathrel{\sim}^{*}c$, and we are done. ∎

During a program run, the relation $\mathrel{\sim}$ progressively approximates the relation $\DownEquivClos\Que$:

Proposition D.21 ($\mathrel{\sim}$ Approximates $\DownEquivClos\Que$).

In every reachable state $\State$: ${\Que}\subseteq{\mathrel{\sim}}\subseteq{\DownEquivClos\Que}$.

Proof.

We prove the statement by induction on the length of the execution trace leading to $\State$:

• •

Base case. In the initial state $({\mathrel{\sim}})={\Que}$ and the statement clearly holds.

• •

Inductive step. First note that during the execution of the algorithm $\mathrel{\sim}$ can only grow (Proposition D.14), therefore the requirement ${\Que}\subseteq{\mathrel{\sim}}$ follows from the \ih In order to prove that ${\mathrel{\sim}}\subseteq{\DownEquivClos\Que}$, we only need to discuss the program transitions that alter $\mathrel{\sim}$, \ie those occurring on Algorithm 1 and Algorithm 1:

• –

Algorithm 1 during the execution of EnqueueAndPropagate(\nodetwo,c). Because of the check on the same line, $\nodetwo=\nabs{\nodetwo^{\prime}}$ and $c=\nabs{c^{\prime}}$ for some $\nodetwo^{\prime},c^{\prime}$. Executing Algorithm 1 creates the new edge $\nodetwo^{\prime}\mathrel{\sim}c^{\prime}$. Since $\DownEquivClos\Que$ is propagated, in order to show the new requirement $\nodetwo^{\prime}\DownEquivClos\Que c^{\prime}$ it suffices to show that $\nodetwo\DownEquivClos\Que c$. We are going to show that $\nodetwo\mathrel{\sim}^{*}c$ in the state prior to $\State$: then by using the \ih we obtain $\nodetwo\DownEquivClos\Que c$, and we can conclude.

Note that EnqueueAndPropagate(\nodetwo, c) is called from Algorithm 1 during the execution of BuildEquivalenceClass(c). Because of the loop on Algorithm 1, $\nodetwo$ was a ${\mathrel{\sim}}$neighbour of $\node$ for some node $\node$, and it still is because $\mathrel{\sim}$ can only grow (Proposition D.14). In order to prove $\nodetwo\mathrel{\sim}^{*}c$, it thus suffices to prove $\node\mathrel{\sim}^{*}c$. The latter follows from Proposition D.20, by using the fact that Algorithm 1 is executed after Algorithm 1, therefore ${{\texttt{c}}}(\node)=c$

• –

Algorithm 1 is similar to the previous case. ∎

Corollary D.22.

In every reachable state, ${\mathrel{{{\texttt{c}}}}^{*}}\subseteq{\DownEquivClos\Que}$.

Proposition D.23 (All $\mathrel{\sim}$edges Visited).

In every final state, $({\mathrel{\sim}})\subseteq(\mathrel{{{\texttt{c}}}}^{*})$.

Proof.

Let $\State_{f}$ be a final state. By Proposition D.3, in $\State_{f}$ every node has a canonic assigned. Let $\node$ be a node, and $c\defeq{{\texttt{c}}}(\node)$; we are going to prove that $\node\mathrel{{{\texttt{c}}}}^{*}\nodetwo$ for every ${\mathrel{\sim}}$neighbour $\nodetwo$ of $\node$.

By Proposition D.5, BuildEquivalenceClass(c) was called before $\State_{f}$. Since $\State_{f}$ is final, BuildEquivalenceClass(c) must have returned, and therefore $\node$ has already been processed (Proposition D.11). After the loop on Algorithm 1, the ${\mathrel{\sim}}$neighbours of $\node$ are finalized (Proposition D.15), and after the loop on Algorithm 1, the ${\mathrel{\sim}}$neighbours of $\node$ are all visited (Proposition D.16). ∎

Proposition D.24.

Let $\State_{f}$ a final state. Then $\mathrel{{{\texttt{c}}}}^{*}$ is a blind bisimulation.

Proof.

By Proposition D.19, $\mathrel{{{\texttt{c}}}}$ is homogeneous and propagated up to $({\mathrel{\sim}}\cup{=})$. We need to show that $\mathrel{{{\texttt{c}}}}^{*}$ is homogeneous and propagated.

• •

Homogeneous. It follows from Proposition A.15.

• •

Propagated. By Proposition D.23 and Proposition D.18, $({\mathrel{\sim}})\subseteq({\mathrel{{{\texttt{c}}}}^{*}})$, which implies that $({\mathrel{\sim}}\cup{=})\subseteq({\mathrel{{{\texttt{c}}}}^{*}})$ because $\mathrel{{{\texttt{c}}}}^{*}$ is reflexive. Therefore $\mathrel{{{\texttt{c}}}}$ is propagated up to $\mathrel{{{\texttt{c}}}}^{*}$ by Proposition C.3, and $\mathrel{{{\texttt{c}}}}^{*}$ is propagated by Proposition C.4. ∎

Proposition D.25.

Let $\State_{f}$ a final state. Then $(\mathrel{{{\texttt{c}}}}^{*})=(\DownEquivClos\Que)$.

Proof.

By Corollary D.22, $(\mathrel{{{\texttt{c}}}}^{*})\subseteq(\DownEquivClos\Que)$. In order to prove $(\DownEquivClos\Que)\subseteq(\mathrel{{{\texttt{c}}}}^{*})$, it suffices to note that ${\Que}\subseteq(\mathrel{{{\texttt{c}}}}^{*})$ (because ${\Que}\subseteq(\mathrel{\sim})$ by Proposition D.21, and $(\mathrel{\sim})\subseteq(\mathrel{{{\texttt{c}}}}^{*})$ by Proposition D.23), that $\mathrel{{{\texttt{c}}}}^{*}$ is an equivalence relation (by definition), and that $\mathrel{{{\texttt{c}}}}^{*}$ is propagated (Proposition D.24). ∎

Proof of 0 (Proposition 6.1).

“??”

Proof.

By Proposition D.24 and Proposition D.25. ∎

D.3. Completeness

Definition D.26 (Staircase Order $\prec$).

Let $\State$ be a reachable state, and $\node,\nodetwo$ be nodes of the \ladag $G$. We say that $\node\prec\nodetwo$ iff there exist a direction $d$ and a node $\nodethree$ such that $\Path d\nodetwo\nodethree$ (riser) and $\nodethree\mathrel{{{\texttt{c}}}}\node$ (tread).

Proposition D.27 (Order of Active Classes).

Let $\State$ be a reachable state such that ${\tt active}=[c_{1},\ldots,c_{K}]$. Then $c_{i}\prec c_{i+1}$ for every $0<i<K$.

Proof.

We proceed by induction on the length of the program run. In the base case, \ie in the initial state, the callstack is empty and therefore the property holds trivially.

As for the inductive step, we only need to discuss the program transitions that actually alter the callstack, \ie when BuildEquivalenceClass is called or when it returns:

• •

BuildEquivalenceClass returns. In this case, the last entry of the callstack is removed, and the statement follows from the \ih

• •

BuildEquivalenceClass($\node$) is called (Algorithm 1). Right before the call to BuildEquivalenceClass(\node) the callstack is empty, and right after the call ${\tt active}=[\node]$, \ie there is nothing to prove.

• •

BuildEquivalenceClass($\nodetwo$) is called (Algorithm 1). In this case $\nodetwo$ is a parent of $\node$ (\ie there exists a direction $d$ such that $\Path d\nodetwo\node$), and $c=c_{K}$ before the call to BuildEquivalenceClass(\nodetwo). Note that Algorithm 1 is executed after Algorithm 1 with locals $c,\node$, and therefore ${{\texttt{c}}}(\node)=c$ (Proposition D.9).

After the call to BuildEquivalenceClass(\nodetwo), ${\tt active}=[c_{1},\ldots,c_{K},\nodetwo]$. The statement for $i<K$ follows from the \ih, and for the case $i=K$ we just proved that $\Path d\nodetwo\node$ and $\node\mathrel{{{\texttt{c}}}}c_{K}$. ∎

The intuition is that recursive calls to BuildEquivalenceClass climb a stair of nodes in the \ladag. The algorithm fails when it encounters a step that was already climbed: this is because the staircase order is strict when $\DownEquivClos\Que$ is homogeneous and propagated.

Proposition D.28 ($\DownEquivClos\Que$ Respects Staircase Order).

Let $\State$ be a reachable state, and let $c_{1},\ldots,c_{K}$ be nodes such that $c_{1}\prec\ldots\prec c_{K}$. If $\DownEquivClos\Que$ is homogeneous, then $c_{i}\DownEquivClos\Que c_{j}$ if and only if $i=j$.

Proof.

If $i=j$, then clearly $c_{i}\DownEquivClos\Que c_{j}$ because $\DownEquivClos\Que$ is reflexive.

For the other direction, assume by contradiction and without loss of generality that $i<j$ (since $\DownEquivClos\Que$ is symmetric). We are going to prove that there exist a non-empty trace $\tra$ and a node $\nodetwo$ such that $\Path\tra{c_{j}}\nodetwo$ and $c_{i}\DownEquivClos\Que\nodetwo$: this, together with $c_{i}\DownEquivClos\Que c_{j}$, will yield a contradiction by Proposition A.9.

We proceed by induction on $j-i-1$:

• •

Case $i+1=j$. Obtain from Proposition D.27 a node $\node$ and a direction $d$ such that $c_{i+1}=\Path d{c_{j}}\node$ and $\node\mathrel{{{\texttt{c}}}}c_{i}$, and conclude because $c_{i}\DownEquivClos\Que\nodetwo$ by Corollary D.22.

• •

Case $i+1<j$. By \ih there exist a non-empty trace $\tra$ and a node $\node$ such that $\Path\tra{c_{j}}\node$ and $c_{i+1}\DownEquivClos\Que\node$. By Proposition D.27, there exist a direction $d$ and a node $\nodetwo$ such that $\Path d{c_{i+1}}\nodetwo$ and $\nodetwo\mathrel{{{\texttt{c}}}}c_{i}$ (and therefore $c_{i}\DownEquivClos\Que\nodetwo$ by Corollary D.22). From $c_{i+1}\DownEquivClos\Que\node$ and $\Path d{c_{i+1}}\nodetwo$, by Proposition A.6 there exists a node $\nodetwo^{\prime}$ such that $\Path d\node{\nodetwo^{\prime}}$ and $\nodetwo\DownEquivClos\Que\nodetwo^{\prime}$. We can conclude, since $\Path{\pcons d\tra}{c_{j}}{\nodetwo^{\prime}}$ and $c_{i}\DownEquivClos\Que\nodetwo^{\prime}$. ∎

We are now ready to prove that the algorithm is complete:

Theorem D.29 (Completeness).

If the algorithm fails, then $\DownEquivClos\Que$ is not homogeneous.

Proof.

Let $\State$ be a failing state, \ie a reachable state that transitions to $\mathcal{F}\!\!\mathit{ail}$. Let ${\tt active}=[c_{1},\ldots,c_{K}]$ in $\State$. There are three lines of the algorithm in which failure may occur: Algorithm 1, Algorithm 1, and Algorithm 1. We discuss these cases separately; in all cases, in order to prove that $\DownEquivClos\Que$ is not homogeneous, we assume $\DownEquivClos\Que$ to be homogeneous, and derive a contradiction.

• •

Algorithm 1. Let $\nodetwo$ be a parent of $\node$ such that ${{\texttt{c}}}(\nodetwo)=c^{\prime}$ and $\texttt{building}(c^{\prime})={\tt true}$. Since $\texttt{building}(c^{\prime})={\tt true}$, the call to BuildEquivalenceClass(c’) has not returned before $\State$, and therefore $c^{\prime}=c_{i}$ for some $0<i\leq K$. By Proposition D.27 $c_{1}\prec\ldots\prec c_{K}$, and therefore $c^{\prime}$ was already encountered in the stair of active classes. Note that ${{\texttt{c}}}(\node)=c_{K}=c$ (Proposition D.9), and therefore $c_{K}\prec\nodetwo$. Also, from ${{\texttt{c}}}(\nodetwo)=c_{i}$ it follows that $\nodetwo\DownEquivClos\Que c_{i}$ (Corollary D.22). The contradiction is obtained by noting that by Proposition D.28 it cannot be the case that $\nodetwo\DownEquivClos\Que c_{i}$, since $c_{1}\prec\ldots\prec c_{K}\prec\nodetwo$.

• •

Algorithm 1. Let $\nodetwo$ be a ${\mathrel{\sim}}$neighbour of $\node$ such that ${{\texttt{c}}}(\nodetwo)=c^{\prime}\neq c$. By Proposition D.9, ${{\texttt{c}}}(\node)=c$. Since ${{\texttt{c}}}(\nodetwo)=c^{\prime}$, BuildEquivalenceClass(c’) must have been called (Proposition D.5), and there are two options:

• –

BuildEquivalenceClass(c’) has already returned. We show that this is not possible. In fact, if BuildEquivalenceClass(c’) has returned before $\State$, then $\nodetwo$ has already been processed before $\State$ (Proposition D.11). Therefore $\node=_{c}\nodetwo$ (Proposition D.16), contradicting the hypothesis that $c\neq c^{\prime}$.

• –

BuildEquivalenceClass(c’) has not yet returned. Therefore $c^{\prime}=c_{i}$ for some $0<i<K$. From ${{\texttt{c}}}(\node)=c=c_{K}$ and ${{\texttt{c}}}(\nodetwo)=c_{i}$ obtain $\node\mathrel{\sim}^{*}c_{K}$ and $\nodetwo\mathrel{\sim}^{*}c_{i}$ (Proposition D.20). Since $\nodetwo$ is a ${\mathrel{\sim}}$neighbour of $\node$, $c_{i}\mathrel{\sim}^{*}c_{K}$, and therefore $c_{i}\DownEquivClos\Que c_{K}$ by Proposition D.21. This yields a contradiction by Proposition D.27 and Proposition D.28.

• •

Algorithm 1. Assume that $c$ and $\nodetwo$ do not respect the homogenity condition. We are going to prove that $c\DownEquivClos\Que\nodetwo$, which contradicts the hypothesis that $\DownEquivClos\Que$ is homogeneous. EnqueueAndPropagate(\nodetwo,c) is called from Algorithm 1, and therefore $\nodetwo$ is a ${\mathrel{\sim}}$neighbour of $\node$. Algorithm 1 is executed after Algorithm 1 with locals $c,\node$, and therefore ${{\texttt{c}}}(\node)=c$ by Proposition D.9. By Proposition D.20, $c\mathrel{\sim}^{*}\node$, and therefore $c\mathrel{\sim}^{*}\nodetwo$. By Proposition D.21, we conclude with $c\DownEquivClos\Que\nodetwo$. ∎

Proof of 0 (Proposition 6.2).

“??”

Proof.

By Theorem D.29 and Proposition 4.5. ∎

D.4. Termination & Linearity

In this section, we are going to show that Algorithm 1 always terminates within a number of transitions that is linear on the size of the \ladag and the initial query $\Que$.

First some notations:

Definition D.30.

• •

$N\defeq{\tt nodes}(G)$ is the set of nodes in the \ladag $G$

• •

$E$ is the set of directed ($\pleft,\pdown,\pright$) edges in the \ladag

• •

$|\cdot|$ is the size of a (multi)set.

• •

$\#edges({\mathrel{\sim}},{\node})$ is the number of $\mathrel{\sim}$edges with endnode $\node$. (Recall that $\mathrel{\sim}$ is a multirelation)

• •

$\#parents({\node})$ is the number of directed edges in $E$ with target $\node$.

The following lemma proves that in every reachable state the number of query edges is linear in the size of $\Que$ and $\mathrel{{{\texttt{c}}}}$. The statement of the lemma is actually more complicated, because the proof requires a more precise bound on $|\texttt{undir}|$. In particular, the bound $|\texttt{undir}|\leq 2\times|{\Que}|+4\times|{\mathrel{{{\texttt{c}}}}}|$ holds in almost every state, but breaks temporarily during the execution of EnqueueAndPropagate, just before the execution of Algorithm 1. The problem is that Lines 1–1 may add new $\mathrel{\sim}$edges, while the new canonic that restores the disequality is only assigned slightly later, on Algorithm 1.

Proposition D.31 (Bound on undir).

In every reachable state $\State$, $|\texttt{undir}|\leq 2\times|{\Que}|+4\times|N|$.

Proof.

Proved by induction on the length of the program run leading to $\State$. In the initial state $\State_{0}$, $|\texttt{undir}|=2\times|{\Que}|$ because undir contains the same edges as $\Que$ (but undir is also symmetric and a multirelation, hence each $\mathrel{\sim}$edge counts twice).

During the program run, new $\mathrel{\sim}$edges are created only by the EnqueueAndPropagate procedure, which may create at most two new $\mathrel{\sim}$edges per call (that count as four new entries of the symmetric multirelation undir). By Proposition D.6, EnqueueAndPropagate is called at most $|N|$ times in each program run, hence we conclude with the bound $|\texttt{undir}|\leq 2\times|{\Que}|+4\times|N|$. ∎

Theorem D.32 (Termination & Linearity).

In every program run, the number of transitions is $O(|N|+|E|+|{\Que}|)$.

Proof.

Let us assume a program run with end state $\State$ (not necessarily a final state). We are going to discuss the number of transitions in the program run in a global way. We group the transitions in the program run according to which procedure they are executing a line of, and we discuss the procedures BlindCheck, BuildEquivalenceClass, and EnqueueAndPropagate separately.

1. (1)

Transitions executing lines of BlindCheck. The procedure BlindCheck(**) is called exactly once, in the initial state. The loop on Algorithm 1 simply iterates on all the nodes of the \ladag: hence the loop bound is just $|N|$. Algorithm 1 may call the procedure BuildEquivalenceClass, but here we do not consider the transitions caused by that function, that will be discussed separately below. Therefore, the total number of transitions that execute lines of BlindCheck is simply O($|N|$). 2. (2)

Transitions executing lines of EnqueueAndPropagate. The procedure EnqueueAndPropagate(\node,–) is called at most once for every node $\node$ (Proposition D.6). Since EnqueueAndPropagate contains no loops and no function calls, there is a constant bound on the number of transitions that are executed by EnqueueAndPropagate each time it is called. Therefore, the total number of transitions that execute lines of EnqueueAndPropagate is O($|N|$). 3. (3)

Transitions executing lines of BuildEquivalenceClass. The discussion of the complexity of BuildEquivalenceClass is more involved, because it contains multiple nested loops.

As a first approximation, the total number of transitions executing lines of BuildEquivalenceClass is big-O of the number of calls to BuildEquivalenceClass plus the numer of transitions executing lines of the loop on Algorithm 1 (\ie Lines 1–1). The number of calls to BuildEquivalenceClass is $\leq|N|$ (Proposition D.4). As for the loop on Algorithm 1, in every program run the body of the loop is executed at most once for every node $\node$ (Proposition D.12).

The body of the while loop contains two additional loops: one on Algorithm 1, and the other on Algorithm 1:

• •

The loop on Algorithm 1 (with locals $c,\node$) simply iterates on all the parents of a node, which is a fixed number: therefore each time it is executed with local variable $\node$, it is responsible for $O(\#parents({\node}))$ transitions.

• •

The discussion about the loop on Algorithm 1 (with locals $c,\node$) is more involved: it iterates on all ${\mathrel{\sim}}$neighbours of a node $\node$, but $\mathrel{\sim}$ changes during the execution of the loop. In fact, the body of the loop may call EnqueueAndPropagate(\nodetwo,c) on Algorithm 1, which may create new $\mathrel{\sim}$edges. However, note that the loop on Algorithm 1 is executed only after the loop on Algorithm 1, which finalizes the ${\mathrel{\sim}}$neighbours of $\node$ (Proposition D.15). Therefore the loop on Algorithm 1 iterates on a set of $\mathrel{\sim}$edges that does not change afterwards during the program run, and is therefore responsible for $O(\#edges({\mathrel{\sim}},{\node}))$ transitions (where the relation $\mathrel{\sim}$ is the one in $\State$).

Therefore the total number of transitions executing Lines 1–1 is big-O of:

[TABLE]

Note that by Proposition D.31, $|\texttt{undir}|\in O(|{\Que}|+|{|N|}|)$. Therefore the total number of transitions executing lines of BuildEquivalenceClass in a program run is O($|N|+|E|+|{\Que}|$).

In conclusion, we obtain the following asymptotic bound on the number of transitions in a program run:

[TABLE]

∎

Proof of 0 (Proposition 6.4).

“??”

Proof.

By Theorem D.32. ∎

Appendix E The Variables Check

Proof of 0.

Theorem 7.1* “??”*

Proof.

First note that since the Blind Check succeeded, both c and $=_{\texttt{c}}$ are homogeneous relations. We also use the fact that $({=_{\texttt{c}}})=({{\texttt{c}}^{*}})$ (Proposition D.18).

• •

Completeness: If the Variables Check fails on line 8, then c is not an open relation, and therefore also $=_{\texttt{c}}$ is not open by Proposition A.23. If the Variables Check fails on line 9, then c is not a bisimulation upto $=_{\texttt{c}}$, and therefore $=_{\texttt{c}}$ is not a bisimulation, and therefore it is not a sharing equivalence.

• •

Correctness: Since also the Variables Check succeeded, c is an open relation, and closed under \RuleBV upto $=_{\texttt{c}}$. In order to show that $=_{\texttt{c}}$ is a sharing equivalence, it suffices to show that it is open, and closed under \RuleBV. $=_{\texttt{c}}$ is closed under \RuleBV by Proposition A.16. $=_{\texttt{c}}$ is open by Proposition A.23.

• •

Termination in linear time: obvious, since the algorithm simply iterates on all variable nodes of the \ladag. ∎