Mining Closed Episodes with Simultaneous Events

TL;DR

This paper introduces a novel method for discovering closed general episodes in sequential data, including simultaneous events, addressing limitations of traditional episode representations and closure definitions.

Contribution

It extends episode definitions to include simultaneous events and proposes an efficient algorithm for discovering closed episodes with reduced redundancy.

Findings

Algorithm is efficient on synthetic datasets.

Closed episodes reduce output redundancy.

Method is effective on real-world data.

Abstract

Sequential pattern discovery is a well-studied field in data mining. Episodes are sequential patterns describing events that often occur in the vicinity of each other. Episodes can impose restrictions to the order of the events, which makes them a versatile technique for describing complex patterns in the sequence. Most of the research on episodes deals with special cases such as serial, parallel, and injective episodes, while discovering general episodes is understudied. In this paper we extend the definition of an episode in order to be able to represent cases where events often occur simultaneously. We present an efficient and novel miner for discovering frequent and closed general episodes. Such a task presents unique challenges. Firstly, we cannot define closure based on frequency. We solve this by computing a more conservative closure that we use to reduce the search space and discover the closed episodes as a postprocessing step. Secondly, episodes are traditionally presented as directed acyclic graphs. We argue that this representation has drawbacks leading to redundancy in the output. We solve these drawbacks by defining a subset relationship in such a way that allows us to remove the redundant episodes. We demonstrate the efficiency of our algorithm and the need for using closed episodes empirically on synthetic and real-world datasets.

Tables

Table 1. Table 1: Results from synthetic sequences with a planted episode P 𝑃 P . The columns show the number of nodes in P 𝑃 P , the support threshold, the size of the final output, the number of instance-closed episodes, the number of subepisodes of P 𝑃 P , and the number of sequence scans, respectively.

$\left|V\left(P\right)\right|$	$\sigma$	$\left|𝒞\right|$	$i$-closed	frequent	scans
1	100	1	3	3	46
2	100	3	15	27	200
3	100	6	63	729	744
4	100	10	255	$\mathrm{59\hspace{0.17em}049}$	$\mathrm{3\hspace{0.17em}964}$
5	100	15	$\mathrm{1\hspace{0.17em}023}$	$\mathrm{14\hspace{0.17em}348\hspace{0.17em}907}$	$\mathrm{11\hspace{0.17em}123}$
6	100	21	$\mathrm{4\hspace{0.17em}095}$	$\approx {10}^{10}$	$\mathrm{48\hspace{0.17em}237}$
7	100	28	$\mathrm{16\hspace{0.17em}383}$	$\approx 2\times {10}^{13}$	$\mathrm{191\hspace{0.17em}277}$
7	50	29	$\mathrm{16\hspace{0.17em}384}$	$>2\times {10}^{13}$	$\mathrm{191\hspace{0.17em}243}$
7	40	32	$\mathrm{16\hspace{0.17em}387}$	$>2\times {10}^{13}$	$\mathrm{191\hspace{0.17em}298}$
7	30	39	$\mathrm{16\hspace{0.17em}394}$	$>2\times {10}^{13}$	$\mathrm{191\hspace{0.17em}463}$
7	20	127	$\mathrm{16\hspace{0.17em}488}$	$>2\times {10}^{13}$	$\mathrm{197\hspace{0.17em}773}$
7	10	684	$\mathrm{52\hspace{0.17em}297}$	$>2\times {10}^{13}$	$\mathrm{480\hspace{0.17em}517}$

Table 2. Table 2: Results from the alarms dataset.

win (s)	$\sigma /{10}^3$	$\left|𝒞\right|$	$i$-closed	freq.(est)	scans
180	$500$	6	6	6	194
180	$400$	8	8	8	220
180	$300$	12	12	12	282
180	$240$	23	26	26	792
600	$\mathrm{2\hspace{0.17em}000}$	4	4	4	128
600	$\mathrm{1\hspace{0.17em}000}$	24	27	$39$	374
600	$500$	90	137	493	$\mathrm{1\hspace{0.17em}196}$
600	$280$	422	698	$\mathrm{2\hspace{0.17em}321}$	$\mathrm{8\hspace{0.17em}758}$
900	$\mathrm{2\hspace{0.17em}000}$	24	26	$40$	350
900	$\mathrm{1\hspace{0.17em}000}$	52	58	$94$	745
900	$500$	280	426	$\mathrm{1\hspace{0.17em}997}$	$\mathrm{4\hspace{0.17em}604}$
900	$350$	$\mathrm{1\hspace{0.17em}845}$	$\mathrm{9\hspace{0.17em}484}$	$\mathrm{190\hspace{0.17em}990}$	$\mathrm{63\hspace{0.17em}735}$

Table 3. Table 3: Results from the trains dataset.

$\sigma$	$\left|𝒞\right|$	$i$-closed	freq.(est)	scans
$\mathrm{30\hspace{0.17em}000}$	141	141	141	$\mathrm{9\hspace{0.17em}575}$
$\mathrm{20\hspace{0.17em}000}$	$\mathrm{1\hspace{0.17em}994}$	$\mathrm{1\hspace{0.17em}995}$	$\mathrm{2\hspace{0.17em}593}$	$\mathrm{219\hspace{0.17em}931}$
$\mathrm{17\hspace{0.17em}000}$	$\mathrm{8\hspace{0.17em}352}$	$\mathrm{8\hspace{0.17em}416}$	$\mathrm{22\hspace{0.17em}542}$	$\mathrm{812\hspace{0.17em}363}$
$\mathrm{15\hspace{0.17em}000}$	$\mathrm{26\hspace{0.17em}170}$	$\mathrm{26\hspace{0.17em}838}$	$\mathrm{172\hspace{0.17em}067}$	$\mathrm{2\hspace{0.17em}231\hspace{0.17em}360}$
$\mathrm{13\hspace{0.17em}000}$	$\mathrm{94\hspace{0.17em}789}$	$\mathrm{101\hspace{0.17em}882}$	$\mathrm{3\hspace{0.17em}552\hspace{0.17em}104}$	$\mathrm{6\hspace{0.17em}865\hspace{0.17em}877}$
$\mathrm{12\hspace{0.17em}000}$	$\mathrm{189\hspace{0.17em}280}$	$\mathrm{211\hspace{0.17em}636}$	$\mathrm{33\hspace{0.17em}660\hspace{0.17em}094}$	$\mathrm{12\hspace{0.17em}966\hspace{0.17em}895}$

Equations

$$((1,s_1,1),\dots ,(i,s_i,i),(i+1,s_{i+1},i),\dots ,(N,s_N,N-1)).$$

$$s[i,j]=\left\{e\in s\mid i\le ts\left(e\right)\le j\right\}$$

$$fr\left(G;s\right)=\left|\left\{s[i,i+\rho -1]\mid s[i,i+\rho -1]\text{ covers }G\right\}\right|.$$

$$\begin{array}{rl}PE\left(H\right)& =\left\{(a,b)\mid ts\left(i(a)\right)<ts\left(i(b)\right)\forall i\in I\right\}\text{ and}\\ WE\left(H\right)& =\left\{(a,b)\mid ts\left(i(a)\right)\le ts\left(i(b)\right)\forall i\in I\right\}-PE\left(H\right).\end{array}$$

$${\alpha }_1\cdots {\alpha }_M{\beta }_1\cdots {\beta }_L{\alpha }_1\cdots {\alpha }_M{\beta }_1\cdots {\beta }_L{\beta }_1\cdots {\beta }_L.$$

$$V=\left\{n\in V(G)\mid ts\left(m(n)\right)=t\right\}.$$

Full text

In this paper we extend the definition of an episode in order to be able to represent cases where events often occur simultaneously. We present an efficient and novel miner for discovering frequent and closed general episodes. Such a task presents unique challenges. Firstly, we cannot define closure based on frequency. We solve this by computing a more conservative closure that we use to reduce the search space and discover the closed episodes as a postprocessing step. Secondly, episodes are traditionally presented as directed acyclic graphs. We argue that this representation has drawbacks leading to redundancy in the output. We solve these drawbacks by defining a subset relationship in such a way that allows us to remove the redundant episodes. We demonstrate the efficiency of our algorithm and the need for using closed episodes empirically on synthetic and real-world datasets.

††terms: Algorithms, Theory

1 Introduction

Discovering interesting patterns in data sequences is a popular aspect of data mining. An episode is a sequential pattern representing a set of events that reoccur in a sequence [14]. In its most general form, an episode also imposes a partial order on the events. This allows great flexibility in describing complex interactions between the events in the sequence.

Existing research in episode mining is dominated by two special cases: parallel episodes, patterns where the order of the events does not matter, and serial episodes, requiring that the events must occur in one given order. Proposals have been made (see Section 2) for discovering episodes with partial orders, but these approaches impose various limitations on the events. In fact, to our knowledge, there is no published work giving an explicit description of a miner for general episodes.

We believe that there are two main reasons why general episodes have attracted less interest: Firstly, implementing a miner is surprisingly difficult: testing whether an episode occurs in the sequence is an NP-complete problem. Secondly, the fact that episodes are such a rich pattern type leads to a severe pattern explosion.

Another limitation of episodes is that they do not properly address simultaneous events. However, sequences containing such events are frequently encountered, in cases such as, for example, sequential data generated by multiple sensors and then collected into one stream. In such a setting, if two events, say $a$ and $b$, often occur simultaneously, existing approaches will depict this pattern as a parallel episode $\{a,b\}$, which will only tell the user that these two events often occur near each other, in no particular order. This is a major limitation, since the actual pattern contains much more information.

In this paper we propose a novel and practical algorithm for mining frequent closed episodes that properly handles simultaneous events. Such a task poses several challenges.

Firstly, we can impose four different relationships between two events $a$ and $b$: (1) the order of $a$ and $b$ does not matter, (2) events $a$ and $b$ should occur at the same time, (3) $b$ should occur after $a$, and (4) $b$ should occur after or at the same time as $a$. We extend the definition of an episode to handle all these cases. In further text, we consider events simultaneous only if they occur exactly at the same time. However, we can easily adjust our framework to consider events simultaneous if they occur within a chosen time interval.

Secondly, a standard approach for representing a partial order of the events is by using a directed acyclic graph (DAG). The mining algorithm would then discover episodes by adding nodes and edges. However, we point out that such a representation has drawbacks. One episode may be represented by several graphs and the subset relationship based on the graphs is not optimal. This ultimately leads to outputting redundant patterns. We will address this problem.

Thirdly, we attack the problem of pattern explosion by using closed patterns. There are two particular challenges with closed episodes. Firstly, we point out that we cannot define a unique closure for an episode, that is, an episode may have several maximal episodes with the same frequency. Secondly, the definition of a closure requires a subset relationship, and computing the subset relationship between episodes is NP-hard.

We mine patterns using a depth-first search. An episode is represented by a DAG and we explore the patterns by adding nodes and edges. To reduce the search space we use the instance-closure of episodes. While it is not guaranteed that an instance-closed episode is actually closed, using such episodes will greatly trim the pattern space. Finally, the actual filtering for closed episodes is done in a post-processing step. We introduce techniques for computing the subset relationship, distinguishing the cases where we can do a simple test from the cases where we have to resort to recursive enumeration. This filtering will remove all redundancies resulting from using DAGs for representing episodes.

The rest of the paper is organised as follows: In Section 2, we discuss the most relevant related work. In Section 3, we present the main notations and concepts. Section 4 introduces the notion of closure in the context of episodes. Our algorithm is presented in detail in Sections 5, 6 and 7. In Section 8 we present the results of our experiments, before presenting our conclusions in Section 9. The proofs of the theorems can be found in the Appendix and the code of the algorithm is available online111http://adrem.ua.ac.be/implementations.

2 Related Work

The first attempt at discovering frequent subsequences, or serial episodes, was made by Wang et al. [22]. The dataset consisted of a number of sequences, and a pattern was considered interesting if it was long enough and could be found in a sufficient number of sequences. A complete solution to a more general problem was later provided by Agrawal and Srikant [2] using an Apriori-style algorithm [1].

Looking for frequent general episodes in a single event sequence was first proposed by Mannila et al. [14]. The Winepi algorithm finds all episodes that occur in a sufficient number of windows of fixed length. Specific algorithms were given for the case of parallel and serial episodes. However, no algorithm for detecting general episodes was provided.

Some research has gone into outputting only closed subsequences, where a sequence is considered closed if it is not properly contained in any other sequence which has the same frequency. Yan et al. [23], Tzvetkov et al. [20], and Wang and Han [21] proposed methods for mining such closed patterns, while Garriga [5] further reduced the output by post-processing it and representing the patterns using partial orders.222Despite their name, the partial orders discovered by Garriga are different from general episodes. Harms et al. [12], meanwhile, experiment with closed serial episodes. In another attempt to trim the output, Garofalakis et al. [8] proposed a family of algorithms called Spirit which allow the user to define regular expressions that specify the language that the discovered patterns must belong to.

Pei et al. [17], and Tatti and Cule [19] considered restricted versions of our problem setup. The former approach assumes a dataset of sequences where the same label can occur only once. Hence, an episode can contain only unique labels. The latter pointed out the problem of defining a proper subset relationship between general episodes and tackled it by considering only episodes where two nodes having the same label had to be connected. In our work, we impose no restrictions on the labels of events making up the episodes.

In this paper we use frequency based on a sliding window as it is defined for Winepi. However, we can easily adopt our approach for other monotonically decreasing measures, as well as to a setup where the data consists of many (short) sequences instead of a single long one. Mannila et al. propose Minepi [14], an alternative interestingness measure for an episode, where the support is defined as the number of minimal windows. Unfortunately, this measure is not monotonically decreasing. However, the issue can be fixed by defining support as the maximal number of non-overlapping minimal windows [18, 13]. Zhou et al. [24] proposed mining closed serial episodes based on the Minepi method. However, the paper did not address the non-monotonicity issue of Minepi.

Alternative interestingness measures, either statistically motivated or aimed to remove bias towards smaller episodes, were made by Garriga [4], Méger and Rigotti [15], Gwadera et al. [10, 9], Calders et al. [3], Cule et al. [7], and Tatti [18].

Using episodes to discover simultaneous events has, to our knowledge, not been done yet. However, this work is somewhat related to efforts made in discovering sequential patterns in multiple streams [16, 6, 11]. Here, it is possible to discover a pattern wherein two events occur simultaneously, as long as they occur in separate streams.

3 Episodes with Simultaneous

Events

We begin this section by introducing the basic concepts that we will use throughout the paper. First we will describe our dataset.

Definition 1.

A sequence event $e=({\mathit{id}\mathopen{}\left(e\right)},{\mathit{lab}\mathopen{}\left(e\right)},{\mathit{ts}\mathopen{}\left(e\right)})$ is a tuple consisting of three entries, a unique id number ${\mathit{id}\mathopen{}\left(e\right)}$, a label ${\mathit{lab}\mathopen{}\left(e\right)}$, and a time stamp integer ${\mathit{ts}\mathopen{}\left(e\right)}$. We will assume that if ${\mathit{id}\mathopen{}\left(e\right)}>{\mathit{id}\mathopen{}\left(f\right)}$, then ${\mathit{ts}\mathopen{}\left(e\right)}\geq{\mathit{ts}\mathopen{}\left(f\right)}$. A sequence is a collection of sequence events ordered by their ids.

Note that we are allowing multiple events to have the same time stamp even when their labels are equivalent. For the sake of simplicity, we will use the notation $s_{1}\cdots s_{N}$ to mean a sequence $\left((1,s_{1},1),\ldots,(N,s_{N},N)\right)$. We will also write $s_{1}\cdots(s_{i}s_{i+1})\cdots s_{N}$ to mean the sequence

[TABLE]

This means that $s_{i}$ and $s_{i+1}$ have equal time stamps.

Our next step is to define patterns we are interested in.

Definition 2.

An episode event $e$ is a tuple consisting of two entries, a unique id number ${\mathit{id}\mathopen{}\left(e\right)}$ and a label ${\mathit{lab}\mathopen{}\left(e\right)}$. An episode graph $G$ is a directed acyclic graph (DAG). The graph may have two types of edges: weak edges ${\mathit{WE}\mathopen{}\left(G\right)}$ and proper edges ${\mathit{PE}\mathopen{}\left(G\right)}$.

An episode consists of a collection of episode events, an episode graph, and a surjective mapping from episode events to the nodes of the graph which we will denote by ${\mathit{nd}\mathopen{}\left(e\right)}$. A proper edge from node $v$ to node $w$ in the episode graph implies that the events of $v$ must occur before the events of $w$, while a weak edge from $v$ to $w$ implies that the events of $w$ may occur either at the same time as those of $v$ or later.

We will assume that the nodes of $G$ are indexed and we will use the notation ${\mathit{nd}\mathopen{}\left(G,i\right)}$ to refer to the $i$th node in $G$.

When there is no danger of confusion, we will use the same letter to denote an episode and its graph. Note that we are allowing multiple episode events to share the same node even if these events have the same labels.

Definition 3.

Given an episode $G$ and a node $n$, we define ${\mathit{lab}\mathopen{}\left(n\right)}=\left\{{\mathit{lab}\mathopen{}\left(e\right)}\mid{\mathit{nd}\mathopen{}\left(e\right)}=n\right\}$ to be the multiset of labels associated with the node. Given two multisets of labels $X$ and $Y$ we write $X\leq_{\mathit{lex}}Y$ if $X$ is lexicographically smaller than or equal to $Y$. We also define ${\mathit{lab}\mathopen{}\left(G\right)}$ to be the multiset of all labels in $G$.

Definition 4.

A node $n$ in an episode graph is a descendant of a node $m$ if there is a path from $m$ to $n$. If there is a path containing a proper edge we will call $n$ a proper descendant of $m$. We similarly define a (proper) ancestor. A node $n$ is a source if it has no ancestors. A node $n$ is a proper source if it has no proper ancestors. We denote all sources of an episode $G$ by ${\mathit{src}\mathopen{}\left(G\right)}$.

We are now ready to give a precise definition of an occurrence of a pattern in a sequence.

Definition 5.

Given a sequence $s$ and an episode $G$, we say that $s$ covers $G$ if there exists an injective mapping $m$ from the episode events to the sequence events such that {enumerate*}

labels are respected, ${\mathit{lab}\mathopen{}\left(m(e)\right)}={\mathit{lab}\mathopen{}\left(e\right)}$,

events sharing a same node map to events with the same time stamp, in other words, ${\mathit{nd}\mathopen{}\left(e\right)}={\mathit{nd}\mathopen{}\left(f\right)}$ implies ${\mathit{ts}\mathopen{}\left(m(e)\right)}={\mathit{ts}\mathopen{}\left(m(f)\right)}$,

weak edges are respected, if ${\mathit{nd}\mathopen{}\left(e\right)}$ is a descendant of ${\mathit{nd}\mathopen{}\left(f\right)}$, then ${\mathit{ts}\mathopen{}\left(m(e)\right)}\geq{\mathit{ts}\mathopen{}\left(m(f)\right)}$,

proper edges are respected, if ${\mathit{nd}\mathopen{}\left(e\right)}$ is a proper descendant of ${\mathit{nd}\mathopen{}\left(f\right)}$, then ${\mathit{ts}\mathopen{}\left(m(e)\right)}>{\mathit{ts}\mathopen{}\left(m(f)\right)}$.

Note that this definition allows us to abuse notation and map graph nodes directly to time stamps, that is, given a graph node $n$ we define ${\mathit{ts}\mathopen{}\left(m(n)\right)}={\mathit{ts}\mathopen{}\left(m(e)\right)}$, where ${\mathit{nd}\mathopen{}\left(e\right)}=n$.

Consider the first three episodes in Figure 1. A sequence $ab(cd)$ covers $G_{1}$ and $G_{3}$ but not $G_{2}$ (proper edge $(c,d)$ is violated). A sequence $(ab)cd$ covers $G_{1}$ and $G_{2}$ but not $G_{3}$.

Finally, we are ready to define support of an episode based on fixed windows. This definition corresponds to the definition used in Winepi [14]. The support is monotonically decreasing which allows us to do effective pruning while discovering frequent episodes.

Definition 6.

Given a sequence $s$ and two integers $i$ and $j$ we define a subsequence

[TABLE]

containing all events occurring between $i$ and $j$.

Definition 7.

Given a window size $\rho$ and an episode $s$, we define the support of an episode $G$ in $s$, denoted ${\mathit{fr}\mathopen{}\left(G;s\right)}$, to be the number of windows of size $\rho$ in $s$ covering the episode,

[TABLE]

We will use ${\mathit{fr}\mathopen{}\left(G\right)}$ whenever $s$ is clear from the context. An episode is $\sigma$-frequent (or simply frequent) if its support is higher or equal than some given threshold $\sigma$.

Consider a sequence $abcdacbd$ and set the window size $\rho=4$. There are $2$ windows covering episode $G_{1}$ (given in Figure 1), namely $s[1,4]$ and $s[5,8]$. Hence ${\mathit{fr}\mathopen{}\left(G_{1}\right)}=2$.

Theorem 8.

*Testing whether a sequence $s$ covers an episode $G$ is an NP-complete problem, even if $s$ does not contain simultaneous events. *

4 Subepisode Relationship

In practice, episodes are represented by DAGs and are mined by adding nodes and edges. However, such a representation has drawbacks [19]. To see this, consider episodes $H_{1}$ and $H_{2}$ in Figure 1. Even though these episodes have different graphs, they are essentially the same — both episodes are covered by exactly the same sequences, namely all sequences containing $abab$, $a(ab)b$, $(aa)(bb)$, $aa(bb)$, $(aa)bb$, or $aabb$. In other words, essentially the same episode may be represented by several graphs. Moreover, using the graph subset relationship to determine subset relationships between episodes will ultimately lead to less efficient algorithms and redundancy in the final output. To counter these problems we introduce a subset relationship based on coverage.

Definition 9.

Given two episodes $G$ and $H$, we say that $G$ is a subepisode of $H$, denoted $G\preceq H$, if any sequence covering $H$ also covers $G$. If $G\preceq H$ and $H\preceq G$, we say that $G$ and $H$ are similar in which case we will write $G\sim H$.

This definition gives us the optimal definition for a subset relationship in the following sense: if $G\npreceq H$, then there exists a sequence $s$ such that ${\mathit{fr}\mathopen{}\left(G;s\right)}<{\mathit{fr}\mathopen{}\left(H;s\right)}$.

Consider the episodes given in Figure 1. It follows from the definition that $H_{1}\sim H_{2}$, $G_{1}\preceq G_{2}$, and $G_{1}\preceq G_{3}$. Episodes $G_{2}$ and $G_{3}$ are not comparable.

Theorem 10.

*Testing $G\preceq H$ is an NP-hard problem. *

Proof.

The hardness follows immediately from Theorem 8 as we can represent sequence $s$ as a serial episode $H$. Then $s$ covers $G$ if and only if $G\preceq H$.

As mentioned in the introduction, pattern explosion is the problem with discovering general episodes. We tackle this by mining only closed episodes.

Definition 11.

An episode $G$ is closed if there is no $H\succ G$ with ${\mathit{fr}\mathopen{}\left(G\right)}={\mathit{fr}\mathopen{}\left(H\right)}$.

We should point out that, unlike with itemsets, an episode may have several maximal superepisodes having the same frequency. Consider $G_{1}$, $G_{3}$, and $G_{4}$ in Figure 2, sequence $abcbdacbcd$ and window size $\rho=5$. The support of episodes $G_{1}$, $G_{3}$ and $G_{4}$ is $2$. Moreover, there is no superepisode of $G_{3}$ or $G_{4}$ that has the same support. Hence, $G_{3}$ and $G_{4}$ are both maximal superepisodes having the same support as $G_{1}$. This implies that we cannot define a closure operator based on frequency. However, we will see in the next section that we can define a closure based on instances. This closure, while not removing all redundant episodes, will prune the search space dramatically. The final pruning will then be done in a post-processing step.

Our final step is to define transitively closed episodes that we will use along with the instance-closure (defined in the next section) in order to reduce the pattern space.

Definition 12.

Let $G$ be an episode. A transitive closure, ${\mathit{tcl}\mathopen{}\left(G\right)}$, is obtained by adding edges from a node to each of its descendants making the edge proper if the descendant is proper, and weak otherwise. If $G={\mathit{tcl}\mathopen{}\left(G\right)}$ we say that $G$ is transitively closed.

It is trivial to see that given an episode $G$, we have $G\sim{\mathit{tcl}\mathopen{}\left(G\right)}$. Thus we can safely ignore all episodes that are not transitively closed. From now on, unless we state otherwise, all episodes are assumed to be transitively closed.

5 Handling Episode Instances

The reason why depth-first search is efficient for itemsets is that at each step we only need to handle the current projected dataset. In our setup we have only one sequence so we need to transport the sequence into a more efficient structure.

Definition 13.

Given an input sequence $s$ and an episode $G$, an instance $i$ is a valid mapping from $G$ to $s$ such that for each $e\in{\mathit{range}\mathopen{}\left(i\right)}$ there is no $f\in s-{\mathit{range}\mathopen{}\left(i\right)}$ such that ${\mathit{lab}\mathopen{}\left(e\right)}={\mathit{lab}\mathopen{}\left(f\right)}$, ${\mathit{ts}\mathopen{}\left(e\right)}={\mathit{ts}\mathopen{}\left(f\right)}$ and ${\mathit{id}\mathopen{}\left(f\right)}<{\mathit{id}\mathopen{}\left(e\right)}$. We define ${\mathit{first}\mathopen{}\left(i\right)}=\min{\mathit{ts}\mathopen{}\left(i(n)\right)}$ to be the smallest time stamp and ${\mathit{last}\mathopen{}\left(i\right)}=\max{\mathit{ts}\mathopen{}\left(i(n)\right)}$ to be the largest time stamp in $i$. We require that ${\mathit{last}\mathopen{}\left(i\right)}-{\mathit{first}\mathopen{}\left(i\right)}\leq\rho-1$, where $\rho$ is the size of the sliding window. An instance set of an episode $G$, defined as is a set of all instances ordered by ${\mathit{first}\mathopen{}\left(i\right)}$.

The condition in the definition allows us to ignore some redundant mappings whenever we have two sequence events, say $e$ and $f$, with ${\mathit{lab}\mathopen{}\left(e\right)}={\mathit{lab}\mathopen{}\left(f\right)}$ and ${\mathit{ts}\mathopen{}\left(e\right)}={\mathit{ts}\mathopen{}\left(f\right)}$. If an instance $i$ uses only $e$, then we can obtain $i^{\prime}$ from $i$ by replacing $e$ with $f$. However, $i$ and $i^{\prime}$ are essentially the same for our purposes, so we can ignore either $i$ or $i^{\prime}$. We require the instance set to be ordered so that we can compute the support efficiently. This order is not necessarily unique.

Consider sequence $abcbdacbcd$ and $G_{1}$ in Figure 2. Then $=((1,2,3,5),(1,4,3,5),(6,7,8,10),(6,9,8,10))$333For simplicity, we write mappings as tuples.

Using instances gives us several advantages. Adding new events and edges to episodes becomes easy. For example, adding a proper edge $(n,m)$ is equivalent to keeping instances with ${\mathit{ts}\mathopen{}\left(i(n)\right)}<{\mathit{ts}\mathopen{}\left(i(m)\right)}$. We will also compute support and closure efficiently. We should point out that may contain an exponential number of instances, otherwise Theorem 8 would imply that $\textbf{P}=\textbf{NP}$. However, this is not a problem in practice.

The depth-first search described in Section 6 adds events to the episodes. Our next goal is to define algorithms for computing the resulting instance set whenever we add an episode event, say $f$, to an episode $G$. Given an instance $i$ of $G$ and a sequence event $e$ we will write $i+e$ to mean an expanded instance by setting $i(f)=e$.

Let $G$ be an episode and let $I=$ be the instance set. Assume a node $n\in V(G)$ and a label $l$. Let $H$ be the episode obtained from $G$ by adding an episode event with label $l$ to node $n$. We can compute from using the AugmentEqual algorithm given in Alg. 1.

The second augmentation algorithm deals with the case where we are adding a new node with an single event labelled as $l$ to a parallel episode. Algorithm Augment, given in Alg. 2, computes the new instance set. The algorithm can be further optimised by doing augmentation with a type of merge sort so that post-sorting is not needed.

Our next step is to compute the support of an episode $G$ from . We do this with the Support algorithm, given in Alg. 3. The algorithm is based on the observation that there are $\rho-({\mathit{last}\mathopen{}\left(i\right)}-{\mathit{first}\mathopen{}\left(i\right)})$ windows that contain the instance $i$. However, some windows may contain more than one instance and we need to compensate for this.

Theorem 14.

$\textsc{Support}()$* computes ${\mathit{fr}\mathopen{}\left(G\right)}$. *

Proof.

Since $I$ is ordered by ${\mathit{first}\mathopen{}\left(i\right)}$, the first for loop of the algorithm removes any instance for which there is an instance $j$ such that ${\mathit{first}\mathopen{}\left(i\right)}\leq{\mathit{first}\mathopen{}\left(j\right)}\leq{\mathit{last}\mathopen{}\left(j\right)}\leq{\mathit{last}\mathopen{}\left(i\right)}$. In other words, any window that contains $i$ will also contain $j$. We will show that the next for loop counts the number of windows containing at least one instance from $W$, this will imply the theorem.

To that end, let $i_{n}\in J$ be the $n$th instance in $J$ and define $S_{n}$ to be the set of windows of size $\rho$ containing $i_{n}$. It follows that ${\left|S_{n}\right|}=\rho-({\mathit{last}\mathopen{}\left(i_{n}\right)}-{\mathit{first}\mathopen{}\left(i_{n}\right)})$ and that the first window of $S_{n}$ starts at $a_{n}=1+{\mathit{last}\mathopen{}\left(i_{n}\right)}-\rho$. Let $C_{n}=\bigcup_{m=1}^{n}S_{m}$. Note that because of the pruning we have $a_{n-1}<a_{n}$, this implies that $C_{n-1}\cap S_{n}=S_{n-1}\cap S_{n}$. We know that ${\left|S_{n-1}\cap S_{n}\right|}=\max\mathopen{}\left(0,1+{\mathit{first}\mathopen{}\left(i_{n-1}\right)}-a_{n}\right)$. This implies that on Line 3 we have $d={\left|S_{n}-S_{n-1}\right|}$ and since ${\left|C_{n}\right|}={\left|C_{n-1}\right|}+d$, this proves the theorem.

Finally, we define a closure episode of an instance set.

Definition 15.

Let $I=$ be a set of instances. We define an instance-closure, $H={\mathit{icl}\mathopen{}\left(I\right)}$ to be the episode having the same nodes and events as $G$. We define the edges

[TABLE]

If $G={\mathit{icl}\mathopen{}\left(I\right)}$ we say that $G$ is $i$-closed.

Consider sequence $abcbdacbcd$ and episodes given in Figure 2. Since events $b$ and $c$ always occur between $a$ and $d$ in , the instance closure is ${\mathit{icl}\mathopen{}\left(\right)}=G_{2}$. Note that $G_{2}$ is not closed because $G_{3}$ and $G_{4}$ are both superepisodes of $G_{2}$ with the same support. However, instance-closure reduces the search space dramatically because we do not have to iterate the edges implied by the closure. Note that the closure may produce cycles with weak edges. However, we will later show that we can ignore such episodes.

6 Discovering Episodes

We are now ready to describe the mining algorithm. Our approach is a straightforward depth-first search. The algorithm works on three different levels.

The first level, consisting of Mine (Alg. 4), and MineParallel (Alg. 5), adds episode events. Mine is only used for creating singleton episodes while MineParallel provides the actual search. The algorithm adds events so that the labels of the nodes are decreasing, ${\mathit{lab}\mathopen{}\left({\mathit{nd}\mathopen{}\left(G,i+1\right)}\right)}\leq_{\mathit{lex}}{\mathit{lab}\mathopen{}\left({\mathit{nd}\mathopen{}\left(G,i\right)}\right)}$. The search space is traversed by either adding an event to the last node or by creating a node with a single event. Episodes $G_{1},\ldots,G_{5}$ in Figure 3 are created by the first level. The edge in $G_{5}$ is augmented by the closure.

The second level, MineWeak, given in Alg. 6, adds weak edges to the episode, while the third level, MineProper, given in Alg. 7, turns weak edges into proper edges. Both algorithms add only those edges which keep the episode transitively closed. The algorithms keep a list of forbidden weak edges $W$ and forbidden proper edges $P$. These lists guarantee that each episode is visited only once.

$G_{6}$ and $G_{7}$ in Figure 3 are discovered by MineWeak, however, the weak edges are converted into proper edges by the instance-closure.

At each step, we call TestEpisode. This routine, given a set of instances $I$, will compute the instance-closure ${\mathit{icl}\mathopen{}\left(I\right)}$ and test it. If the episode passes all the tests, the algorithm will return the episode and the search is continued, otherwise the branch is terminated. There are four different tests. The first test checks whether the episode is frequent. If we pass this test, we compute the instance-closure $H={\mathit{icl}\mathopen{}\left(I\right)}$. The second test checks whether $H$ contains cycles. Let $G$ be an episode such that $I=$. In order for $H$ to have cycles we must have two nodes, say $n$ and $m$, such that ${\mathit{ts}\mathopen{}\left(i(n)\right)}={\mathit{ts}\mathopen{}\left(i(m)\right)}$ for all $i\in I$. Let $G^{\prime}$ be an episode obtained from $G$ by merging nodes in $n$ and $m$ together. We have $G\preceq G^{\prime}$ and ${\mathit{fr}\mathopen{}\left(G\right)}={\mathit{fr}\mathopen{}\left(G^{\prime}\right)}$. This holds for any subsequent episode discovered in the branch allowing us to ignore the whole branch.

If the closure introduces into $H$ any edge that has been explored in the previous branches, then that implies that $H$ has already been discovered. Hence, we can reject $H$ if any such edge is introduced. The final condition is that during MineProper no weak edges should be added into $H$ by the closure. If a weak edge is added, we can reject $H$ because it can be reached via an alternative route, by letting MineWeak add the additional edges and then calling MineProper.

The algorithm keeps a list $\mathcal{C}$ of all discovered episodes that are closed. If all four tests are passed, the algorithm tests whether there are subepisodes of $G$ in $\mathcal{C}$ having the same frequency, and deletes them. On the other hand, if there is a superepisode of $G$ in $\mathcal{C}$, then $G$ is not added into $\mathcal{C}$.

7 Testing Subepisodes

In this section we will describe the technique for computing $G\preceq H$. In general, this problem is difficult to solve as pointed out by Theorem 10. Fortunately, in practice, a major part of the comparisons are easy to do. The following theorem says that if the labels of $G$ are unique in $H$, then we can easily compare $G$ and $H$.

Theorem 16.

Assume two episodes $G$ and $H$. Assume that ${\mathit{lab}\mathopen{}\left(G\right)}\subset{\mathit{lab}\mathopen{}\left(H\right)}$ and for each event $e$ in $G$ only one event occurs in $H$ with the same label. Let $\pi$ be the unique mapping from episode events in $G$ to episode events in $H$ honouring the labels. Then $G\preceq H$ if and only if

{enumerate*}

${\mathit{nd}\mathopen{}\left(e\right)}={\mathit{nd}\mathopen{}\left(f\right)}$* implies that ${\mathit{nd}\mathopen{}\left(\pi(e)\right)}={\mathit{nd}\mathopen{}\left(\pi(f)\right)}$,*

${\mathit{nd}\mathopen{}\left(e\right)}$* is a proper child of ${\mathit{nd}\mathopen{}\left(f\right)}$ implies that ${\mathit{nd}\mathopen{}\left(\pi(e)\right)}$ is a proper child of ${\mathit{nd}\mathopen{}\left(\pi(f)\right)}$,*

${\mathit{nd}\mathopen{}\left(e\right)}$* is a child of ${\mathit{nd}\mathopen{}\left(f\right)}$ implies that ${\mathit{nd}\mathopen{}\left(\pi(e)\right)}$ is a child of ${\mathit{nd}\mathopen{}\left(\pi(f)\right)}$ or ${\mathit{nd}\mathopen{}\left(\pi(e)\right)}={\mathit{nd}\mathopen{}\left(\pi(f)\right)}$,

for any two events $e$ and $f$ in $G$. *

If the condition in Theorem 16 does not hold we will have to resort to enumerating the sequences covering $H$. In order to do that, we need to extend the definition of coverage and subset relationship to the set of episodes.

Definition 17.

A sequence $s$ covers an episode set $\mathcal{G}$ if there is an episode $G\in\mathcal{G}$ such that $s$ covers $G$. Given two episode sets $\mathcal{G}$ and $\mathcal{H}$ we define $\mathcal{G}\preceq\mathcal{H}$ if every sequence that covers $\mathcal{H}$ also covers $\mathcal{G}$.

We also need a definition of a prefix subgraph.

Definition 18.

Given a graph $G$, a prefix subgraph is a non-empty induced subgraph of $G$ with no proper edges such that if a node $n$ is included then the parents of $n$ are also included. Given a multiset of labels $L$ and an episode $G$ we define ${\rm Phys.\leavevmode\nobreak\ Rev.\leavevmode\nobreak\ E}{G,L}$ to be the set of all maximal prefix subgraphs such that ${\mathit{lab}\mathopen{}\left(V\right)}\subseteq L$ for each $V\in{\rm Phys.\leavevmode\nobreak\ Rev.\leavevmode\nobreak\ E}{G,L}$. We define ${\mathit{tail}\mathopen{}\left(G,L\right)}=\left\{G-V\mid V\in{\rm Phys.\leavevmode\nobreak\ Rev.\leavevmode\nobreak\ E}{G,L}\right\}$ to be the episodes with the remaining nodes. Finally, given an episode set $\mathcal{G}$ we define ${\mathit{tail}\mathopen{}\left(\mathcal{G},L\right)}=\bigcup_{G\in\mathcal{G}}{\mathit{tail}\mathopen{}\left(G,L\right)}$.

Example 19.

Consider episodes given in Figure 4. We have ${\mathit{tail}\mathopen{}\left(G,ab\right)}=\left\{H_{1},H_{2},H_{3}\right\}$ and ${\mathit{tail}\mathopen{}\left(G,a\right)}=\left\{H_{1}\right\}$.

The main motivation for our recursion is given in the following theorem.

Theorem 20.

*Given an episode set $\mathcal{G}$ and an episode $H$, $\mathcal{G}\preceq H$ if and only if for each prefix subgraph $V$ of $H$, we have ${\mathit{tail}\mathopen{}\left(\mathcal{G},{\mathit{lab}\mathopen{}\left(V\right)}\right)}\preceq H-V$. *

We focus for the rest of this section on implementing the recursion in Theorem 20. We begin by an algorithm, Generate, given in Alg. 9, that, given a graph without proper edges, discovers all prefix subgraphs.

Given a prefix subgraph $V$ of $H$, our next step is to discover all maximal prefix subgraphs of $G$ whose label sets are subsets of $L={\mathit{lab}\mathopen{}\left(V\right)}$. The algorithm, Consume, creating this list, is given in Alg. 10. Consume enumerates over all sources. For each source $n$ such that ${\mathit{lab}\mathopen{}\left(n\right)}\subseteq L$, the algorithm tests if there is another node sharing a label with $n$. If so, the algorithm creates an episode without $n$ and its descendants and calls itself. This call produces a list of prefix graphs $\mathcal{W}$ not containing node $n$. The algorithm removes all graphs from $\mathcal{W}$ that can be augmented with $n$ (since in that case they are not maximal). Finally, Consume adds $n$ to the current prefix subgraph, removes $n$ from $G$, and removes ${\mathit{lab}\mathopen{}\left(n\right)}$ from $L$.

We are now ready to describe the recursion step of Theorem 20 for testing the subset relationship. The algorithm, Step, is given in Alg. 11. Given an episode set $\mathcal{G}$ and a graph $H$, the algorithm computes $\mathcal{G}\preceq H$. First, it tests whether we can apply Theorem 16. If this is not possible, then the algorithm first removes all nodes from $H$ not carrying a label from ${\mathit{lab}\mathopen{}\left(G\right)}$ for $G\in\mathcal{G}$. This is allowed because of the following lemma.

Lemma 21.

*Let $G$ and $H$ be two episodes. Let $n\in V(H)$ be a node such that ${\mathit{lab}\mathopen{}\left(n\right)}\cap{\mathit{lab}\mathopen{}\left(G\right)}=\emptyset$. Let $H^{\prime}$ be the episode obtained from $H$ by removing $n$. Then $G\preceq H$ if and only if $G\preceq H^{\prime}$. *

Step continues by creating a subgraph $Y$ of $H$ containing only proper sources. The algorithm generates all prefix subgraphs $\mathcal{V}$ of $Y$ and tests each one. For each subgraph $V\in\mathcal{V}$, Step calls Consume and builds an episode set $\mathcal{T}={\mathit{tail}\mathopen{}\left(\mathcal{G},{\mathit{lab}\mathopen{}\left(V\right)}\right)}$. The algorithm then calls itself recursively with $\textsc{Step}(\mathcal{T},H-V)$. If at least one of these calls fails, then we know that $\mathcal{G}\npreceq H$, otherwise $\mathcal{G}\preceq H$.

Finally, to compute $G\preceq H$, we simply call $\textsc{Step}(\left\{G\right\},H)$.

8 Experiments

We begin our experiments with a synthetic dataset. Our goal is to demonstrate the need for using the closure. In order to do that we created sequences with a planted pattern $(s_{1}s_{2})(s_{3}s_{4})\cdots(s_{2N-1}s_{2N})$. We added this pattern $100$ times 50 time units apart from each other. We added $500$ noise events uniformly spreading over the whole sequence. We sampled the labels for the noise events uniformly from $900$ different labels. The labels for the noise and the labels of the pattern were mutually exclusive. We varied $N$ from $1$ to $7$. We ran our miner using a window size of $\rho=10$ and varied the support threshold $\sigma$. The results are given in Table 1.

When we are using a support threshold of $100$, the only closed frequent patterns are the planted pattern and its subpatterns of form $(s_{i}s_{i+1})\cdots(s_{j}s_{j+1})$, since the frequency of these subpatterns is slightly higher than the frequency of the whole pattern. The number of instance-closed episodes (given in the $4^{\text{th}}$ column of Table 1) grows more rapidly. The reason for this is that the instance-closure focuses on the edges and does not add any new nodes. However, this ratio becomes a bottleneck only when we are dealing with extremely large serial episodes, and for our real-world datasets this ratio is relatively small.

The need for instance-closure becomes apparent when the number of instance-closed episodes is compared to the number of all possible general subepisodes (including those that are not tranistively closed) of a planted pattern, given in the $5^{\text{th}}$ column of Table 1. We see that had we not used instance-closure, a single pattern having 6 nodes and 12 events renders pattern discovery infeasible.

As we lower the threshold, the number of instance-closed episodes and closed episodes increases, however the ratio between instance-closed and closed episodes improves. The reason for this is that the output contains episodes other than our planted episode, and those mostly contain a small number of nodes.

We also measured the number of sequence scans, namely the number of calls made to Support, to demonstrate how fast the negative border is growing. Since our miner is a depth-first search and the computation of frequency is based on instances, a single scan is fast, since we do not have to scan the whole sequence.

Our second set of experiments was conducted on real-world data. The dataset consists of alarms generated in a factory, and contains $514\,502$ events of $9\,595$ different types, stretching over 18 months. An entry in the dataset consists of a time stamp and an event type. Once again, we tested our algorithm at various thresholds, varying the window size from 3 to 15 minutes. Here, too, as shown in Table 2, we can see that the number of $i$-closed episodes does not explode to the level of all frequent episodes, demonstrating the need for using the $i$-closure as an intermediate step. Furthermore, we see that in a realistic setting, the number of $i$-closed episodes stays closer to the number of closed episodes than in the above-mentioned synthetic dataset. This is no surprise, since real datasets tend to have a lot of patterns containing a small number of events.

As the discovery of all frequent episodes is infeasible, we estimated their number as follows. An episode $G$ has $a(G)=3^{{\left|{\mathit{PE}\mathopen{}\left(G\right)}\right|}}2^{\left|{\mathit{WE}\mathopen{}\left(G\right)}\right|}$ subepisodes (including those that are not transitively closed) with the same events and nodes. From the discovered $i$-closed episodes we selected a subset $\mathcal{G}$ such that each $G\in\mathcal{G}$ has a unique set of events and a maximal $a(G)$. Then the lower bound for the total number of frequent episodes is $\sum_{G\in\mathcal{G}}a(G)$. Using such a lower bound is more than enough to confirm that the number of frequent episodes explodes much faster than the number of closed and $i$-closed episodes, as can be seen in Table 2.

Furthermore, our output contained a considerable number of episodes with simultaneous events — patterns that no existing method would have discovered. The runtimes ranged from just under 2 seconds to 90 seconds for the lowest reported thresholds.

Our third dataset consisted of trains delayed at a single railway station in Belgium. The dataset consists of actual departure times of delayed trains, coupled with train numbers, and contains $10\,115$ events involving $1\,280$ different train IDs, stretching over a period of one month. A window of 30 minutes was chosen by a domain expert. The time stamps were expressed in seconds, so a single train being delayed on a particular day would be found in 1800 windows. Therefore, the frequency threshold for interesting patterns had to be set relatively high. The results are shown in Table 3, and were similar to those of the alarm dataset. The runtimes ranged from a few milliseconds to 55 minutes for the lowest reported threshold. The largest discovered pattern was of size 10, and the total number of frequent episodes at the lowest threshold was at least $33$ million, once again demonstrating the need for both outputting only closed episodes and using instance-closure.

9 Conclusions

In this paper we introduce a new type of sequential pattern, a general episode that takes into account simultaneous events, and provide an efficient depth-first search algorithm for mining such patterns.

This problem setup has two major challenges. The first challenge is the pattern explosion which we tackle by discovering only closed episodes. Interestingly enough, we cannot define closure based on frequency, hence we define closure based on instances. While it holds that frequency-closed episodes are instance-closed, the opposite is not true. However, in practice, instance-closure reduces search space dramatically so we can mine all instance-closed episodes and discover frequency-closed episodes as a post-processing step.

The second challenge is to correctly compute the subset relationship between two episodes. We argue that using a subset relationship based on graphs is not optimal and will lead to redundant output. We define a subset relationship based on coverage and argue that this is the correct definition. This definition turns out to be NP-hard. However, this is not a problem since in practice most of the comparisons can be done efficiently.

10 Acknowledgments

Nikolaj Tatti is supported by a Post-doctoral Fellowship of the Research Foundation – Flanders (fwo).

The authors wish to thank Toon Calders for providing the proof that checking whether a sequence covers an episode is NP-hard on a small piece of paper.

Appendix A Proofs of Theorems

of Theorem 8.

If $s$ covers $G$, then the map $f$ mapping the nodes of $G$ to indices of $s$ provides the certificate needed for the verification. Hence, testing the coverage is in NP.

In order to prove the completeness we reduce 3SAT to the coverage. In order to do so, given the formula $F$, we will build an episode $G$ and a sequence such that sequence $s$ covers $G$ if and only if $F$ is satisfiable.

Assume that we are given a formula $F$ with $M$ variables and $L$ clauses. We define the alphabet for the labels to be $\Sigma=\left\{\alpha_{1},\ldots,\alpha_{M}\right\}\cup\left\{\beta_{1},\ldots,\beta_{L}\right\}$, where $\alpha_{i}$ is identified with the $i$th variable and $\beta_{j}$ is identified with $j$th clause.

We will now construct $G$. The nodes in the episode consist of three groups. The first group, $P=\left\{p_{1},\ldots,p_{M}\right\}$, contains $M$ nodes. A node $p_{i}$ is labelled as ${\mathit{lab}\mathopen{}\left(p_{i}\right)}=\alpha_{i}$. These nodes represent the positive instantiation of the variables. The second group of nodes, $N=\left\{n_{1},\ldots,n_{M}\right\}$, also contains $M$ nodes, and the labels are again ${\mathit{lab}\mathopen{}\left(n_{i}\right)}=\alpha_{i}$. These nodes represent the negative instantiation of the variables. Our final group is $C=\left\{c_{1},\ldots,c_{3L}\right\}$, contains $3L$ nodes, $3$ nodes for each clause. The labels for these nodes are ${\mathit{lab}\mathopen{}\left(c_{3j-2}\right)}={\mathit{lab}\mathopen{}\left(c_{3j-1}\right)}={\mathit{lab}\mathopen{}\left(c_{3j}\right)}=\beta_{j}$. The edges of the episode $G$ are as follows: Let $\beta_{j}$ be the $j$th clause in $F$ and let $\alpha_{i}$ be the $k$th variable occurring in that clause. Note that $k=1,2,3$. We connect $p_{i}$ to $c_{3j+k-3}$ if the variable is positive in the clause. Otherwise, we connect $n_{i}$ to $c_{3j+k-3}$.

The sequence $s$ consists of $5$ consecutive subsequences $s=s_{1}s_{2}s_{3}s_{4}s_{5}$. We define $s_{1}=s_{3}=\alpha_{1}\cdots\alpha_{M}$ and $s_{2}=s_{4}=s_{5}=\beta_{1}\cdots\beta_{L}$, that is, $s$ is equal to

[TABLE]

Our final step is to prove that $s$ covers $G$ whenever $F$ is satisfiable. First assume that $F$ is satisfiable and let $t_{i}$ be the truth assignment for the variable $\alpha_{i}$. We need to define a mapping $f$. If $t_{i}$ is true, then we map $p_{i}$ into the first group $s_{1}$ and $n_{i}$ into the third group $s_{3}$. If $t_{i}$ is false, then we map $n_{i}$ into $s_{1}$ and $p_{i}$ into $s_{3}$. Since each clause is now satisfied, among the nodes $c_{3j-2}$, $c_{3j-1}$, and $c_{3j}$ there is at least one node, say $c_{k}$, such that the parent of that node ($p_{i}$ or $n_{i}$) is mapped to the first group $s_{1}$. We can map $c_{k}$ into the second group $s_{2}$. The remaining two nodes are mapped into the fourth and the fifth group, $s_{4}$ and $s_{5}$. Clearly this mapping is valid since all the nodes are mapped and the edges are honoured.

To prove the other direction, let $f$ be a valid mapping of $G$ into $s$. Since the sequence has the same amount of symbols as there are nodes in the graph the mapping $f$ is surjective. Define a truth mapping by setting the $i$th variable to true if $p_{i}$ occurs in $s_{1}$, and false otherwise. Each symbol in the second group $s_{2}$ is covered. Select one symbol, say $\beta_{j}$ from that group. The corresponding node, say $c_{k}$, has a parent (either $p_{i}$ or $n_{i}$) that must be mapped into the first group. This implies that the truth value for the $i$th variable satisfies the $j$th clause. Since all clauses are satisfied, $F$ is satisfied. This completes the proof.

of Theorem 16.

To prove the theorem we will use the following straightforward lemma.

Lemma 22.

*Let $G$ be a transitively closed episode. Let $e$ and $f$ be two nodes. Then there exists a sequence $s$ covering $G$ and a mapping $m$ such that

{enumerate*}*

if ${\mathit{nd}\mathopen{}\left(e\right)}\neq{\mathit{nd}\mathopen{}\left(f\right)}$, then ${\mathit{ts}\mathopen{}\left(m(e)\right)}\neq{\mathit{ts}\mathopen{}\left(m(f)\right)}$,

*if ${\mathit{nd}\mathopen{}\left(e\right)}$ is not a child of ${\mathit{nd}\mathopen{}\left(f\right)}$, then

${\mathit{ts}\mathopen{}\left(m(e)\right)}<{\mathit{ts}\mathopen{}\left(m(f)\right)}$,*

*if ${\mathit{nd}\mathopen{}\left(e\right)}$ is not a proper child of ${\mathit{nd}\mathopen{}\left(f\right)}$, then

${\mathit{ts}\mathopen{}\left(m(e)\right)}\leq{\mathit{ts}\mathopen{}\left(m(f)\right)}$,

The ’if’ part is straightforward so we only prove the ’only if’ part. Assume that $G\preceq H$ and let $e$ and $f$ be two events in $G$ violating one of the conditions. Apply Lemma 22 with $H$, $\pi(e)$, and $\pi(f)$ to obtain a sequence $s$ and a mapping $m$. We can safely assume that $m$ is surjective. Define $m^{\prime}(x)=m(\pi(x))$ for an event $x$ in $G$. Since every label is unique in $s$, $m^{\prime}$ is the only mapping that will honor the labels in $G$. Now Lemma 22 implies that $m^{\prime}$ is not a valid mapping for $G$, hence $G\npreceq H$, which proves the theorem.

of Theorem 20.

Assume that the condition in the theorem holds and let $s$ be a sequence covering $H$ and let $m$ be the corresponding mapping. We can safely assume that $m$ is surjective. Let $t$ be the smallest time stamp in $s$ and $E$ the events in $s$ having the time stamp $t$. Let $V$ be the corresponding prefix subgraph,

[TABLE]

By assumption, we have ${\mathit{tail}\mathopen{}\left(\mathcal{G},{\mathit{lab}\mathopen{}\left(V\right)}\right)}\preceq H-V$, hence there is $G\in\mathcal{G}$ and $W\in{\rm Phys.\leavevmode\nobreak\ Rev.\leavevmode\nobreak\ E}{G,L}$ such that $G-W\preceq H-V$ and ${\mathit{lab}\mathopen{}\left(W\right)}\subseteq{\mathit{lab}\mathopen{}\left(V\right)}$. Let $s^{\prime}$ be the sequence obtained from $s$ by removing $E$. Since $s^{\prime}$ covers $H-V$, there is a map $m^{\prime}$ mapping $G-W$ to $s^{\prime}$. We can extend this map to $G$ by mapping $W$ to $E$. Thus $s$ covers $G$, hence $s$ covers $\mathcal{G}$, and by definition $\mathcal{G}\preceq H$.

To prove the other direction, assume that $\mathcal{G}\preceq H$. Let $V$ be a prefix subgraph of $H$. Let $s^{\prime}$ be a sequence covering $H-V$. We can extend this sequence to $s$ by adding the events with labels ${\mathit{lab}\mathopen{}\left(V\right)}$ in front of $s^{\prime}$. Let us denote these events by $E$. Sequence $s$ covers $H$, hence it covers $\mathcal{G}$.

By assumption, there is a mapping $m^{\prime}$ from $G$ to $s$ for some $G\in\mathcal{G}$. Let $W$ be the (possibly empty) prefix graph of $G$ mapping to $E$. We can assume that $W\in{\rm Phys.\leavevmode\nobreak\ Rev.\leavevmode\nobreak\ E}{G,{\mathit{lab}\mathopen{}\left(V\right)}}$, that is, $W$ is maximal, otherwise let $W^{\prime}\in{\rm Phys.\leavevmode\nobreak\ Rev.\leavevmode\nobreak\ E}{G,{\mathit{lab}\mathopen{}\left(V\right)}}$ such that $W\subset W^{\prime}$. We can modify $m^{\prime}$ by remapping the nodes in $W^{\prime}-W$ to the events in $E$. This will make $W$ equal to $W^{\prime}$. Since $s^{\prime}$ covers $G-W$, it follows that $s^{\prime}$ covers ${\mathit{tail}\mathopen{}\left(\mathcal{G},{\mathit{lab}\mathopen{}\left(V\right)}\right)}$ which proves the theorem.

of Lemma 21.

The ’if’ part is trivial. To prove the ’only if’ part, assume that $G\preceq H$. Let $s^{\prime}$ be a sequence covering $H^{\prime}$ and let $m^{\prime}$ be the mapping. If we can show that $s^{\prime}$ can be extended to $s$ by adding events with the labels ${\mathit{lab}\mathopen{}\left(n\right)}$ such that $s$ covers $G$, then the corresponding mapping $m$ will also be a valid mapping from $G$ to $s^{\prime}$, which will prove the lemma.

If $n$ is a source or a sink (a node without children), then we can extend $s^{\prime}$ by adding the event with the label ${\mathit{lab}\mathopen{}\left(n\right)}$ either at the beginning or at the end of $s^{\prime}$.

Assume that $n$ has parents and children. Let $t_{1}$ be the largest time stamp of the parents of $n$ and let $t_{2}$ be the smallest time stamp of the children of $n$. Extend $s^{\prime}$ to $s$ by adding an event $f$ with the label ${\mathit{lab}\mathopen{}\left(n\right)}$ and the time stamp $t=1/2(t_{1}+t_{2})$. Let $x$ be a child of $n$ and $y$ a parent of $n$. Since $H$ is transitively closed, $x$ is a child of $y$ in $H^{\prime}$. Since this holds for any $x$ and $y$, we have $t_{1}\leq t_{2}$. Hence ${\mathit{ts}\mathopen{}\left(y\right)}\leq t\leq{\mathit{ts}\mathopen{}\left(x\right)}$. If $x$ is proper descendant of $n$, then it is also a proper descendant of any parent of $n$, hence $t_{1}<{\mathit{ts}\mathopen{}\left(x\right)}$ and consequently $t<{\mathit{ts}\mathopen{}\left(x\right)}$. The same holds for $y$. This implies that $s$ covers $G$.