Myhill-Nerode Theorem for Higher-Dimensional Automata

Higher-dimensional automata (HDAs), introduced by Pratt and van Glabbeek [1, 2, 3], extend standard automata with additional structure that makes it possible to distinguish between interleavings and concurrency. That puts them in a class with other non-interleaving models for concurrency such as Petri nets [4], event structures [5], configuration structures [6, 7], asynchronous transition systems [8, 9], and similar approaches [10, 11, 12, 13], while retaining some of the properties and intuition of automata-like models. As an example, Figure 1 shows Petri net and HDA models for a system with two events, labelled $a$ and $b$. The Petri net and HDA on the left side model the (mutually exclusive) interleaving of $a$ and $b$ as either $a.b$ or $b.a$; those to the right model concurrent execution of $a$ and $b$. In the HDA, this independence is indicated by a filled-in square.

We have recently introduced languages of HDAs [14], which consist of partially ordered multisets with interfaces (ipomsets), and shown a Kleene theorem for them [15, 16]. Here we continue to develop the language theory of HDAs. Our first contribution is a Myhill-Nerode type theorem for HDAs, stating that a language is regular if and only if it has finite prefix quotient. This provides a necessary and sufficient condition for regularity. Our proof is inspired by the standard proofs of the Myhill-Nerode theorem, but the higher-dimensional structure introduces some difficulties. For example, we cannot use the standard prefix quotient relation but need to develop a stronger one which takes concurrency of events into account.

As a second contribution, we give a precise definition of deterministic HDAs and show that there exist regular languages that cannot be recognised by deterministic HDAs. Our Myhill-Nerode construction will produce a deterministic HDA for such deterministic languages, and a non-deterministic HDA otherwise. Our definition of determinism is more subtle than for standard automata as it is not always possible to remove non-accessible parts of HDAs. We develop a language-internal characterisation of deterministic languages.

Thirdly, we develop a variant of the Myhill-Nerode construction and of determinism which uses higher-dimensional automata with interfaces (iHDAs). These were introduced in [15] and allow for some components to be missing which in HDAs would have to exist solely for structural reasons. In iHDAs, non-accessible parts may be removed, which allows for a more principled Myhill-Nerode construction. HDAs and iHDAs are related via mappings called resolution and closure which preserve languages.

We start this paper by introducing languages of ipomsets in Section 2. Section 3 develops important decomposition properties of ipomsets needed in the sequel, and HDAs are introduced in Section 4. Section 5 then states and proves our Myhill-Nerode theorem, and Section 6 introduces deterministic HDAs. HDAs with interfaces are defined in Section 7, the Myhill-Nerode theorem using iHDAs is in Section 8, and deterministic iHDAs are treated in Section 9. This paper is based on [17] which was presented at the 44th International Conference on Application and Theory of Petri Nets and Concurrency. Compared to this conference paper, proofs have been added and errors corrected, and the material in Sections 8 and 9 is new.

HDAs model systems in which labelled events have duration and may happen concurrently. Every event has a time interval during which it is active: it starts at some point, then remains active until its termination and never reappears. Events may be concurrent, that is, their activity intervals may overlap; otherwise, one of the events precedes the other. We also need to consider executions in which some events are already active at the beginning (source events) or are still active at the end (target events).

At any moment of an execution we observe a list of currently active events (such lists are called conclists below). The relative position of any two concurrent events on these lists remains the same, regardless of the point in time. This provides a secondary relation between events, which we call event order.

To make the above precise, let $\Sigma$ be a finite alphabet. A conclist (for “concurrency list”) $(U,{\dashrightarrow},\lambda)$ is a finite set $U$ with a total order $\dashrightarrow$ called the event order and a labelling function $\lambda:U\to\Sigma$. Conclists (or rather their isomorphism classes) are effectively strings but consist of concurrent, not subsequent, events.

A labelled poset with event order (lposet) $(P,{<},{\dashrightarrow},\lambda)$ consists of a finite set $P$ with two relations: precedence $<$ and event order $\dashrightarrow$, together with a labelling function $\lambda:P\to\Sigma$. Note that different events may carry the same label: we do not exclude autoconcurrency. We require that both $<$ and $\dashrightarrow$ are strict partial orders, that is, they are irreflexive and transitive (and thus asymmetric). We also require that for each $x\neq y$ in $P$, at least one of $x<y$ or $y<x$ or $x\dashrightarrow y$ or $y\dashrightarrow x$ must hold; that is, if $x$ and $y$ are concurrent, then they must be related by $\dashrightarrow$.

Conclists may be regarded as lposets with empty precedence relation; the last condition enforces that their elements are totally ordered by $\dashrightarrow$. A temporary state of an execution is described by a conclist, while the whole execution provides an lposet of its events. The precedence order expresses that one event terminates before the other starts. The event order of an lposet is generated by the event orders of temporary conclists. Hence any two events which are active concurrently are unrelated by $<$ but related by $\dashrightarrow$.

In order to accommodate source and target events, we need to introduce lposets with interfaces (iposets). An iposet $(P,{<},{\dashrightarrow},S,T,\lambda)$ consists of an lposet $(P,{<},{\dashrightarrow},\lambda)$ together with subsets $S,T\subseteq P$ of source and target interfaces. Elements of $S$ must be $<$-minimal and those of $T$ $<$-maximal; hence both $S$ and $T$ are conclists. We often denote an iposet as above by ${\vphantom{P}}_{S}P_{T}$ or $(S,P,T)$, ignoring the orders and labelling, or use $S_{P}=S$ and $T_{P}=T$ if convenient. Source and target events will be marked by “ $\bullet$ ” at the left or right side, and if the event order is not shown, we assume that it goes downwards.

Given that the precedence relation $<$ of an iposet represents activity intervals of events, it is an interval order [18]. In other words, any of the iposets we will encounter admits an interval representation: functions $b$ and $e$ from $P$ to real numbers such that $b(x)\leq e(x)$ for all $x\in P$ and $x<_{P}y\iff e(x)<b(y)$ for all $x,y\in P$. We will only consider interval iposets in this paper and hence omit the qualification “interval”. This is not a restriction, but rather induced by the semantics. The following property is trivial, but we will make heavy use of it later.

Iposets may be refined by shortening the activity intervals of events, so that some events stop being concurrent. This corresponds to expanding the precedence relation $<$ (and, potentially, removing event order). The inverse to refinement is called subsumption and defined as follows. For iposets $P$ and $Q$, we say that $Q$ subsumes $P$ (or that $P$ is a refinement of $Q$) and write $P\sqsubseteq Q$ if there exists a bijection $f:P\to Q$ (a subsumption) which

• •

  respects interfaces and labels: $f(S_{P})=S_{Q}$, $f(T_{P})=T_{Q}$, and $\lambda_{Q}\circ f=\lambda_{P}$;

• •

  reflects precedence: $f(x)<_{Q}f(y)$ implies $x<_{P}y$; and

• •

  preserves essential event order: $x\dashrightarrow_{P}y$ implies $f(x)\dashrightarrow_{Q}f(y)$ whenever $x$ and $y$ are concurrent (that is, $x\not<_{P}y$ and $y\not<_{P}x$).

(Event order is essential for concurrent events, but by transitivity, it also appears between non-concurrent events; subsumptions may ignore such non-essential event order.)

Iposets and subsumptions form a category. The isomorphisms in that category are invertible subsumptions, and isomorphism classes of iposets are called ipomsets. Concretely, an isomorphism $f:P\to Q$ of iposets is a bijection which

• •

  respects interfaces and labels: $f(S_{P})=S_{Q}$, $f(T_{P})=T_{Q}$, and $\lambda_{Q}\circ f=\lambda_{P}$;

• •

  respects precedence: $x<_{P}y\iff f(x)<_{Q}f(y)$; and

• •

  respects essential event order: $x\dashrightarrow_{P}y\iff f(x)\dashrightarrow_{Q}f(y)$ whenever $x\not<_{P}y$ and $y\not<_{P}x$.

Isomorphisms between iposets are unique (because of the requirement that all elements be ordered by $<$ or $\dashrightarrow$), hence we may switch freely between ipomsets and concrete representations, see [15] for details. We write $P\cong Q$ if iposets $P$ and $Q$ are isomorphic and let iiPoms denote the set of (interval) ipomsets.

Ipomsets may be glued, using a generalisation of the standard serial composition of pomsets [19]. For ipomsets $P$ and $Q$, their gluing $P*Q$ is defined if the targets of $P$ match the sources of $Q$: $T_{P}\cong S_{Q}$. In that case, its carrier set is the quotient $(P\sqcup Q)_{/x\equiv f(x)}$, where $f:T_{P}\to S_{Q}$ is the unique isomorphism, the interfaces are $S_{P*Q}=S_{P}$ and $T_{P*Q}=T_{Q}$, $\dashrightarrow_{P*Q}$ is the transitive closure of ${\dashrightarrow_{P}}\cup{\dashrightarrow_{Q}}$, and $x<_{P*Q}y$ if and only if $x<_{P}y$, or $x<_{Q}y$, or $x\in P-T_{P}$ and $y\in Q-S_{Q}$. We will often omit the “$*$” in gluing compositions. For ipomsets with empty interfaces, $*$ is serial pomset composition; in the general case, matching interface points are glued, see [14, 20] or below for examples.

A language is, a priori, a set of ipomsets $L\subseteq\text{{{iiPoms}}}$. However, we will assume that languages are closed under refinement (inverse subsumption), so that refinements of any ipomset in $L$ are also in $L$:

Using interval representations, this means that languages are closed under shortening activity intervals of events. The set of all languages is denoted $\mathscr{L}\subseteq 2^{\text{{{iiPoms}}}}$.

For $X\subseteq\text{{{iiPoms}}}$ an arbitrary set of ipomsets, we denote by

its downward subsumption closure, that is, the smallest language which contains $X$. Then

An ipomset $P$ is discrete if $<_{P}$ is empty and $\dashrightarrow_{P}$ total. Conclists are discrete ipomsets with empty interfaces. Discrete ipomsets ${\vphantom{U}}_{U}U_{U}$ are identities for gluing composition and written $\textup{{id}}_{U}$. A starter is an ipomset ${\vphantom{U}}_{U-A}U_{U}$, a terminator is ${\vphantom{U}}_{U}U_{U-A}$; these will be written ${}_{A\!}{\uparrow}{U}$ and ${U}{\downarrow}_{A}$, respectively.

Any ipomset can be presented as a gluing of starters and terminators [20, Proposition 21]. (This is related to the fact that a partial order is interval if and only if its antichain order is total, see [21, 18, 22]). Such a presentation we call a step decomposition; if starters and terminators are alternating, the decomposition is sparse.

We show that sparse step decompositions of ipomsets are unique. For an ipomset $P$, we denote by $P^{m}\subseteq P$ the subset of $<$-minimal elements and

That is, $P^{s}$ contains precisely those minimal elements which have arrows to all non-minimal elements. Clearly, both $P^{m}$ and $P^{s}$ are conclists, and $P^{s}\subseteq P^{m}\supseteq S_{P}$. We need a few technical lemmas.

Consider a presentation $P\cong QR$. From the definition follows that $P^{m}\cong Q^{m}$ and $S_{P}\cong S_{Q}$ This implies:

An HDA is a collection of cells which are connected according to specified face maps. Each cell has an associated list of labelled events which are interpreted as being executed in that cell, and the face maps may terminate some events or, inversely, indicate cells in which some of the current events were not yet started. Additionally, some cells are designated start cells and some others accept cells; computations of an HDA begin in a start cell and proceed by starting and terminating events until they reach an accept cell.