Runtime Verification For Timed Event Streams With Partial Information

TL;DR

This paper introduces a method for applying Stream Runtime Verification to incomplete timed event streams by using abstraction, enabling sound analysis despite missing data in real-world systems.

Contribution

It presents a novel approach to perform SRV on incomplete traces using TeSSLa and abstraction, allowing verification with gaps in data.

Findings

Feasibility demonstrated through empirical evaluation

Soundness achieved despite incomplete traces

Implementation as macros for TeSSLa

Abstract

Runtime Verification (RV) studies how to analyze execution traces of a system under observation. Stream Runtime Verification (SRV) applies stream transformations to obtain information from observed traces. Incomplete traces with information missing in gaps pose a common challenge when applying RV and SRV techniques to real-world systems as RV approaches typically require the complete trace without missing parts. This paper presents a solution to perform SRV on incomplete traces based on abstraction. We use TeSSLa as specification language for non-synchronized timed event streams and define abstract event streams representing the set of all possible traces that could have occurred during gaps in the input trace. We show how to translate a TeSSLa specification to its abstract counterpart that can propagate gaps through the transformation of the input streams and thus generate sound outputs even if the input streams contain gaps and events with imprecise values. The solution has been implemented as a set of macros for the original TeSSLa and an empirical evaluation shows the feasibility of the approach.

Equations

$$z(t)=\{\begin{array}{ll}f(s_1(t),\dots ,s_n(t))& \text{if s1(t)=?,…,sn(t)=?}\\ ?& \text{otherwise}\end{array}$$

$$z(t)=\{\begin{array}{ll}d& t\in ticks(r)\text{ and }{\exists }_{t^{\prime }<t}isLast(t,t^{\prime },v,d)\\ \perp & r(t)=\perp \text{ and }defined(z,t)\text{, or }{\forall }_{t^{\prime }<t}v(t^{\prime })=\perp \\ ?& \text{ otherwise}\end{array}$$

$$=\text{slift}(\le )(\mathbf{time}(\text{resets}),\mathbf{time}(\text{values}))$$

$$=\text{merge}(\mathbf{last}(\text{sum},\text{values}),\text{zero})$$

$$=\text{slift}(f)(\text{cond},\text{lst},\text{values})$$

$$f:\mathbb{B}\times \mathbb{Z}\times \mathbb{Z}\to \mathbb{Z}\text{ with}$$

$$f(c,l,v)=\{\begin{array}{ll}0& \text{if }c=\mathrm{true}\\ l+v& \text{otherwise}\end{array}$$

$$\gamma ((s,\Delta ))=\{s^{\prime }\mid {\forall }_{t\in ticks(s)}s(t)\in \gamma (s^{\prime }(t))\wedge {\forall }_{t\in \Delta \setminus ticks(s)}s(t)=s^{\prime }(t)\}$$

$${\gamma }_{\perp }(d)=\{\begin{array}{ll}\perp & \text{if }d=\perp \\ \mathbb{D}\cup \{\perp \}& \text{if }d=⌣\\ \gamma (d)& \text{if }d\in {\mathbb{D}}^{\#}\end{array}$$

$$z(t)=\{\begin{array}{ll}{f}^{\#}(s_1(t),\dots ,s_n(t))& \text{if s1=?,…,sn=?}\\ ?& \text{otherwise}\end{array}$$

$$z(t)=\left\{\begin{array}[]{l@{\ \ }l@{\ \ }l}d&\color[rgb]{.5,.5,.5}\definecolor[named]{pgfstrokecolor}{rgb}{.5,.5,.5}\pgfsys@color@gray@stroke{.5}\pgfsys@color@gray@fill{.5}t\in\mathit{ticks}(r)\wedge\exists_{t^{\prime}<t}\mathit{isLast}(t,t^{\prime},v,d)\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\wedge\forall_{t^{\prime\prime}|t^{\prime}<t^{\prime\prime}<t}v(t^{\prime\prime})\neq\operatorname{\smallsmile}\\ \top&t\in\mathit{ticks}(r)\wedge\exists_{t^{\prime}<t}\mathit{isLast}(t,t^{\prime},v,\operatorname{\smallsmile})\wedge\exists_{t^{\prime\prime}|t^{\prime}<t^{\prime\prime}<t}v(t^{\prime\prime})=\operatorname{\smallsmile}&(1)\\ \bot&\color[rgb]{.5,.5,.5}\definecolor[named]{pgfstrokecolor}{rgb}{.5,.5,.5}\pgfsys@color@gray@stroke{.5}\pgfsys@color@gray@fill{.5}r(t)=\bot\wedge\mathit{defined}(z,t)\vee\forall_{t^{\prime}<t}v(t^{\prime})=\bot\\ \operatorname{\smallsmile}&\mathit{defined}(z,t)\wedge r(t)=\operatorname{\smallsmile}\wedge\exists_{t^{\prime}<t}v(t^{\prime})\neq\bot&(2)\\ \operatorname{\smallsmile}&\mathit{defined}(z,t)\wedge t\in\mathit{ticks}(r)\wedge\forall_{t^{\prime}<t}t^{\prime}\notin\mathit{ticks}(v)\wedge\exists_{t^{\prime}<t}v(t^{\prime})=\operatorname{\smallsmile}&(3)\\ \textrm{?}&\color[rgb]{.5,.5,.5}\definecolor[named]{pgfstrokecolor}{rgb}{.5,.5,.5}\pgfsys@color@gray@stroke{.5}\pgfsys@color@gray@fill{.5}\text{otherwise}\end{array}\right.$$

$$z_{\perp }(t)=\{\begin{array}{ll}z(t)& \text{if }z(t)\ne ⌣\\ \perp & \text{otherwise}\end{array}{z}_{⌣}(t)=\{\begin{array}{ll}d(t)& \text{if }t\in ticks(d)\\ ⌣& \text{if }t\notin ticks(d)\wedge z(t)=⌣\\ \perp & \text{otherwise}\end{array}$$

$$x^{\prime }={\mathbf{last}}_{\perp }^{\#}(v,r)v^{\prime }=f(x^{\prime },\vec{c})x={\mathbf{last}}_{⌣}^{\#}(v^{\prime },r,x^{\prime })v=f(x,\vec{c})$$

$$=\text{slift}({remOlder}_5)(\mathbf{time}(\text{load}),\text{merge}(\mathbf{last}(\text{queue},\text{load}),⟨⟩)))$$

$$=\mathbf{lift}(enq)(\mathbf{time}(\text{load}),\text{load},\text{stripped})$$

$$=\mathbf{lift}(int)(\text{queue},\mathbf{time}(\text{load}))$$

$$int(q,u)$$

$$y=\mathbf{merge}\big{(}\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)},0\big{)}$$

$$\mathbf{last}(y,x)$$

$$\displaystyle\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)}$$

$$\displaystyle\mathbf{merge}\big{(}\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)},0\big{)}$$

$$\mathbf{last}(y,x)$$

$$\displaystyle\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)}$$

$$\displaystyle\mathbf{merge}\big{(}\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)},0\big{)}$$

$$\mathbf{last}(y,x)$$

$$\displaystyle\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)}$$

$$\displaystyle\mathbf{merge}\big{(}\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)},0\big{)}$$

$$\mathbf{last}(y,x)$$

$$\displaystyle\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)}$$

$$\displaystyle\mathbf{merge}\big{(}\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)},0\big{)}$$

$$\mathbf{last}(y,x)$$

$$\displaystyle\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)}$$

$$\displaystyle\mathbf{merge}\big{(}\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)},0\big{)}$$

$$\mathbf{last}(y,x)$$

$$\displaystyle\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)}$$

$$\displaystyle\mathbf{merge}\big{(}\mathbf{lift}\big{(}{}+1\big{)}\big{(}\mathbf{last}(y,x)\big{)},0\big{)}$$

$$z(t)=\{\begin{array}{ll}\text{boxempty}& {\exists }_{t^{\prime }<t}d(t^{\prime })=t-t^{\prime }\wedge setable(z,r,t^{\prime })\wedge noreset(r,t^{\prime },t)\\ \perp & defined(z,t)\wedge {\forall }_{t^{\prime }<t}d(t^{\prime })\ne t-t^{\prime }\wedge d(t^{\prime })\ne ?\\ \perp & {\forall }_{t^{\prime }<t}unsetable(z,r,t^{\prime })\vee reset(r,t^{\prime },t)\\ ?& \text{otherwise}\end{array}$$

$$setable(z,r,t^{\prime })$$

$$reset(r,t,t^{\prime })$$

$$unsetable(z,r,t^{\prime })$$

Full text

1 Introduction

Runtime verification (RV) is a dynamic formal method for software system reliability. RV studies how to analyze and evaluate traces against formal specifications and how to obtain program traces from the system under observation, e.g., through software instrumentation or utilization of processors’ embedded trace units. Since RV only inspects one execution trace of the system, it is often regarded to be a readily applicable but incomplete approach, that combines formal verification with testing and debugging.

Most early RV languages were based on logics common in static verification, like LTL [21], past LTL adapted for finite paths [19, 12, 4], regular expressions [22] or timed regular expressions [2]. For these logics, the monitoring problem consists on computing a Boolean verdict indicating whether the trace fulfills the specification. In contrast to static analysis, however, considering only a single concrete trace enables the application of more complex analyses: Stream Runtime Verification (SRV) [11, 6, 7] uses stream transformations to derive additional streams as verdicts from the input streams. Using SRV one can still check if the input stream is conformant with a specification, but additionally verify streams in terms of their events’ data: streams in SRV can store data from richer domains than Booleans, including numerical values or user defined data-types, so SRV languages can extract quantitative values and express quantitative properties like “compute the average retransmission time” or “compute the longest duration of a function”. SRV cleanly separates the temporal dependencies that the stream transformation algorithms follow from the concrete operations to be performed on the data, which are specific to each data-type. As an example for SRV consider the trace diagram on the left of Fig. 1. We consider non-synchronized event streams, i.e., sequences of events with increasing timestamps and values from a data domain. Using non-synchronized event streams one can represent events arriving on different streams with different frequencies in a compact way with little computation overhead because there is no need to process additional synchronization events in the stream-transformation process. In this paper we use the TeSSLa specification language [7], an SRV language for non-synchronized, timed event streams. TeSSLa has been defined to be general enough to allow for a natural translation from other common SRV formalisms, e.g., Lola [11] and Striver [17]. Therefore, our results carry over to these languages as well.

Since RV is performed on traces obtained from the system under test in the deployed environment, it is a common practical problem for RV techniques that the traces do not cover the entire run of the system. However, most of the previous RV approaches require the trace to be available without any interruptions in order to obtain a verdict, because this knowledge is assumed in the semantics of the specification logics. Especially in the case of interrupted traces with some data losses applying previous RV techniques can be very challenging. Unfortunately those traces occur very often in practical testing and debugging scenarios, e.g., due to interrupted experiments, buffer overflows, network errors or any other temporary problem with the trace retrieval.

In this paper we present a solution to the problem of evaluating traces with imprecise values and even interrupted traces. Our only assumption is that we have exact knowledge of the imprecision of the trace in the following sense: (1) for events with imprecise values we know the range of values and (2) for data losses we know when we stop getting information and when the trace becomes reliable again. We call such a sequence of uncertainty a gap in the trace. Our solution automatically propagates gaps and imprecisions, and allows to obtain sound verdicts even in the case of missing information in the input trace. The assumption is reasonable in our target application: online non-intrusive monitoring low-level embedded software.

Fig. 1 on the right displays a case where the input stream values has a long gap in the middle. It is not possible to determine the events in the output stream sum during that gap, because we do not even know if and how many events might have happened during that gap. Thus, the intermediate stream cond and the output stream sum simply copy that gap representing any possible combination of events that might occur. The first event after the gap is the one with the value 3 on values. Because no reset happened after the end of the gap, we would add 3 to the latest event’s value on sum, but the gap is the latest on sum. Thus, we only know that this input event on values causes an event on sum independently of what might have happened during the gap, but the value of that event completely depends on possible events occurring during the gap. After the next event on reset the values of the following events on sum are independent of any previous events. The monitor can fully recover from the missing information during the gap and can again produce events with precise values.

In order to realize this propagation of gaps through all the steps of the stream-transformation we need to represent all potentially infinitely many concrete traces (time is dense and values are for arbitrary domains) that might have happened during gaps and imprecise events. An intuitive approach would be a symbolic representation in terms of constraint formulas to describe the set of all possible streams. These formulas would then be updated while evaluating the input trace. While such a symbolic execution might work for shorter traces, the representation can grow quickly with each input event. Consequently the computational cost could grow prohibitively with the trace length for many input traces. Instead, in this paper we introduce a framework based on abstraction [9, 10]. We use abstraction in two ways:

1. (1)

Streams are lifted from concrete domains of data to abstract domains to model possible sets of values. For example, in our solution a stream can store intervals as abstract numerical values. 2. (2)

We define the notion of abstract traces, which extend timed streams with the capabilities of representing gaps. Intuitively, an abstract trace over-approximates the sets of concrete traces that can be obtained by filling the gaps with all possible concrete events.

Our approach allows for both gaps in the input streams as well as events carrying imprecise values. Such imprecise values can be modelled by abstract domains, e.g., intervals of real numbers. Since we rely on abstraction, we can avoid false negatives and false positives in the usual sense: concrete verdicts are guaranteed to hold and imprecise verdicts are clearly distinguished from concrete verdicts. The achievable precision depends on the specification and the input trace.

After reproducing the semantics of the basic TeSSLa operators in Section 2, we introduce abstract semantics of the existing basic operators of TeSSLa in Section 3. Using these abstract TeSSLa operators, we can take a TeSSLa specification on streams and replace every TeSSLa operator with its abstract counterpart and derive an abstraction of the specification on abstract event streams. We show that the abstract specification is a sound abstraction of the concrete specification, i.e., every concrete verdict generated by the original specification on a set $S$ of possible input traces is represented by the abstract verdict applied to an abstraction of $S$. We further show that the abstract TeSSLa operators are a perfect abstraction of their concrete counterparts, i.e., that applying the concrete operator on all individual elements of $S$ doesn’t get you more accurate results. Finally, we show that an abstract TeSSLa specification can be implemented using the existing TeSSLa basic operators by representing an abstract event stream as multiple concrete event streams carrying information about the events and the gaps. Since the perfect accuracy of the individual abstract TeSSLa operators does not guarantee perfect accuracy of their compositions, we discuss the accuracy of composed abstract TeSSLa specifications in Section 4. Next we present in Section 5 an advanced use-case where we apply abstract TeSSLa to streams over a complex data domain of unbounded queues, which are used to compute the average of all events that happened in the sliding window of the last five time units. In the final Section 6 we evaluate the overhead and the accuracy of the abstractions presented in this paper on representative example specifications and corresponding input traces with gaps.

Related Work.

SRV was pioneered by LOLA [11, 14, 15]. TeSSLa [7] generalises to asynchronous streams the original idea of LOLA of recursive equations over stream transformations. Its design is influenced by formalisms like stream programming languages [18, 5, 16] and functional reactive programming [13]. Other approaches to handle data and time constraints include Quantitative Regular Expressions QRE [1] and Signal Temporal Logic [20].

While ubiquitous in practice, the problem of gaps in an observation trace has not been studied extensively. To the best of our knowledge, abstraction techniques have not been applied to the evaluation of stream-based specifications. However, approaches to handle the absence of events or ordering information have been presented for MTL [3] and past-time LTL [24]. State estimation based on Markov models has been applied to replace absent information by a probabilistic estimation [23]. The concept of abstract interpretation used throughout this paper has been introduced in [8].

2 The TeSSLa Specification Language

A time domain is a totally ordered semi-ring $(\mathbb{T},0,1,+,\cdot,\leq)$ that is positive, i.e., $\forall_{t\in\mathbb{T}}\,0\leq t$. We extend the order on time domains to the set $\mathbb{T}_{\infty}=\mathbb{T}\cup\{\infty\}$ with $\forall_{t\in\mathbb{T}}\,t<\infty$. Given a time domain $\mathbb{T}$, an event stream over a data domain $\mathbb{D}$ is a finite or infinite sequence $s=t_{0}d_{0}t_{1}\dots\in\mathcal{S}_{\mathbb{D}}=(\mathbb{T}\cdot\mathbb{D})^{\omega}\cup(\mathbb{T}\cdot\mathbb{D})^{*}\cdot(\mathbb{T}_{\infty}\cup\mathbb{T}\cdot\mathbb{D}_{\bot})$ where $\mathbb{D}_{\bot}:=\mathbb{D}\cup\{\bot\}$ and $t_{i}<t_{i+1}$ for all $i$ with $0<i+1<|s|$ ($|s|$ is $\infty$ for infinite sequences). An infinite event stream is an infinite sequence of timestamps and data values representing the stream’s events. A finite event stream is a finite sequence of timestamped events up to a certain timestamp that indicates the progress of the stream. A stream can end with:

• –

a timestamp without a data value that denotes progress up to but not including that timestamp,

• –

a timestamp followed by $\bot$ (or a data value) which denotes progress up to and including that timestamp (and an event at that timestamp),

• –

$\infty$, which indicates that no additional events will ever arrive on this stream.

We refer to these cases as exclusive, inclusive and infinite progress, resp.

Streams $s\in\mathcal{S}_{\mathbb{D}}$ can be seen as functions $s:\mathbb{T}\to\mathbb{D}\cup\{\bot,\mathrm{?}\}$ such that $s(t)$ is a value $d$ if $s$ has an event with value $d$ at time $t$ or $\bot$ if there is no event at time $t$. For timestamps after the progress of the stream $s(t)$ is ?. Formally, $s(t)=d$ if $s$ contains $td$, $s(t)=\bot$ if $s$ does not contain $t$, but contains a $t^{\prime}>t$ or $s$ ends in $t\bot$, and $s(t)=\mathrm{?}$ otherwise. We use $\mathit{ticks}(s)$ for the set $\{t\in\mathbb{T}\mid s(t)\in\mathbb{D}\}$ of timestamps where $s$ has events. A stream $s$ is a prefix of stream $r$ if $\forall_{t\in\mathbb{T}}s(t)\in\{r(t),\mathrm{?}\}$. We use the unit type $\mathbb{U}=\{\boxempty\}$ for streams carrying only the single value $\boxempty$.

A TeSSLa specification consists of a collection of stream variables and possibly recursive equations over these variables using the operators $\mathbf{nil}$, $\mathbf{unit}$, $\mathbf{time}$, $\mathbf{lift}$, $\mathbf{last}$ and $\mathbf{delay}$. The semantics of recursive equations is given as the least fixed-point of the equations seen as a function of the stream variables and fixed input streams. See [7] for more details and Appendix 0.A for an elaborated example.

$\mathbf{nil}=\infty\in\mathcal{S}_{\emptyset}$ is the stream without any events and infinite progress.

$\mathbf{unit}=0\boxempty\infty\in\mathcal{S}_{\mathbb{U}}$ is the stream with a single unit event at timestamp zero and infinite progress.

$\mathbf{time}:\mathcal{S}_{\mathbb{D}}\to\mathcal{S}_{\mathbb{T}},\mathbf{time}(s):=z$ maps the event’s values to their timestamps:

$z(t)=t$ if $t\in\mathit{ticks}(s)$ and $z(t)=s(t)$ otherwise.

$\mathbf{lift}:({\mathbb{D}_{1}}_{\bot}\times\dots\times{\mathbb{D}_{n}}_{\bot}\to\mathbb{D}_{\bot})\to(\mathcal{S}_{\mathbb{D}_{1}}\times\dots\times\mathcal{S}_{\mathbb{D}_{n}}\to\mathcal{S}_{\mathbb{D}}),\mathbf{lift}(f)(s_{1},\ldots,s_{n}):=z$ lifts a function $f$ on values to a function on streams by applying $f$ to the stream’s values for every timestamp. The function $f$ must not generate new events, i.e., must fulfill $f(\bot,\dots,\bot)=\bot$.

[TABLE]

$\mathbf{last}:\mathcal{S}_{\mathbb{D}}\times\mathcal{S}_{\mathbb{D}^{\prime}}\to\mathcal{S}_{\mathbb{D}},\mathbf{last}(v,r):=z$ takes a stream $v$ of values and a stream $r$ of triggers. It outputs an event with the previous value on $v$ for every event on $r$.

[TABLE]

$\mathit{isLast}(t,t^{\prime},v,d)\operatorname{\stackrel{{\scriptstyle\text{def}}}{{=}}}v(t^{\prime})=d\wedge\forall_{t^{\prime\prime}|t^{\prime}<t^{\prime\prime}<t}v(t^{\prime\prime})=\bot$ holds if $t^{\prime}d$ is the last event on $v$ until $t$, and $\mathit{defined}(z,t)\operatorname{\stackrel{{\scriptstyle\text{def}}}{{=}}}\forall_{t^{\prime}<t}z(t^{\prime})\neq\mathrm{?}$ holds if $z$ is defined until $t$ (exclusive).

Using the basic operators we can now derive the following utility functions:

$\textsf{const}(c)(a):=\mathbf{lift}(f_{c})(a)$ with $f_{c}(d):=c$. This function maps the values of all events of the input stream $a$ to a constant value $c$. Using const we can lift constants into streams representing a constant signal with this value, e.g., $\textsf{true}:=\textsf{const}(\textsf{true})(\mathbf{unit})$ or $\textsf{zero}:=\textsf{const}(0)(\mathbf{unit})$.

$\textsf{merge}(x,y):=\mathbf{lift}(f)(x,y)$ with $f(a\neq\bot,b)=a$ and $f(\bot,b)=b$, which combines events from two streams, prioritizing the first stream.

Event streams in TeSSLa can also be interpreted as a continuous signals. Using $\mathbf{last}$ one can query the last known value of an event stream $s$ and interpret the events on $s$ as points where a piece-wise constant signal changes its value. By combining the $\mathbf{last}$ and $\mathbf{lift}$ operators, we can realize:

signal lift for total functions $f:\mathbb{D}\times\mathbb{D}^{\prime}\to\mathbb{D}^{\prime\prime}$ as $\textsf{slift}(f)(x,y):=\mathbf{lift}(g_{f})(x^{\prime},y^{\prime})$ with $x^{\prime}:=\textsf{merge}(x,\mathbf{last}(x,y))$ and $y^{\prime}:=\textsf{merge}(y,\mathbf{last}(y,x))$, as well as $g_{f}(a\neq\bot,b\neq\bot):=f(a,b)$, $g_{f}(\bot,b):=\bot$, and $g_{f}(a,\bot):=\bot$.

Example 1

We can now specify the stream transformations shown on the left in Figure 1 in TeSSLa. Let $\textsf{resets}\in\mathcal{S}_{\mathbb{U}}$ and $\textsf{values}\in\mathcal{S}_{\mathbb{Z}}$ be two external input event streams. We then derive $\textsf{cond}\in\mathcal{S}_{\mathbb{B}}$ and $\textsf{lst},\textsf{sum}\in\mathcal{S}_{\mathbb{Z}}$ as follows:

[TABLE]

[TABLE]

Using the operators described above one can only derive streams with timestamps that are already present in the input streams. To derive streams with events at computed timestamps one can use the $\mathbf{delay}$ operator, which is described in Appendix 0.B.

3 Abstract TeSSLa

Preliminaries.

Given two partial orders $(A,\preceq)$ and $(B,\preceq)$, a Galois Connection is a pair of monotone functions $\alpha:A\to B$ and $\gamma:B\to A$ such that, for all $a\in A$ and $b\in B$, $\alpha(a)\preceq b$ if and only if $a\preceq\gamma(b)$. Let $(A,\preceq)$ be a partial order, $f:A\to A$ a monotone function and $\gamma:B\to A$ a function. The function $f^{\#}:B\to B$ is an abstraction of $f$ whenever, for all $b\in B$, $f(\gamma(b))\preceq\gamma(f^{\#}(b))$. If $(\alpha,\gamma)$ is a Galois Connection between $A$ and $B$, the function $f^{\#}:B\to B$ such that $f^{\#}(b):=\alpha(f(\gamma(b))$ is a perfect abstraction of $f$.

In this section we define the abstract counterparts of the TeSSLa operators, listed in Section 2. A data abstraction of a data domain $\mathbb{D}$ is an abstract domain $\mathbb{D}^{\#}$ with an element $\top\in\mathbb{D}^{\#}$ and an associated concretisation function $\gamma:\mathbb{D}^{\#}\to 2^{\mathbb{D}}$ with $\gamma(\top)=\mathbb{D}$. The abstract value $\top$ represents any possible value from the data domain and can be used to model an event with known timestamp but unknown value. A gap is a segment of an abstract event stream that represents all combinations of events that could possibly occur in that segment (both in terms of timestamps and values). Hence an abstract event stream consists of an event stream over a data abstraction and an associated set of known timestamps:

Definition 1 (Abstract Event Stream)

Given a time domain $\mathbb{T}$, an abstract event stream over a data domain $\mathbb{D}$ is a pair $(s,\Delta)$ with $s\in\mathcal{S}_{\mathbb{D}^{\#}}$ and $\Delta\subseteq\mathbb{T}$ such that $\Delta$ can be represented as union of intervals whose (inclusive or exclusive) boundaries are indicated by events in an event stream. Further, we require $s(t)\neq\bot\Rightarrow t\in\Delta$. The set of all abstract event streams over $\mathbb{D}$ is denoted as $\mathcal{P}_{\mathbb{D}}$. The concretisation function $\gamma:\mathcal{P}_{\mathbb{D}}\to 2^{\mathcal{S}_{\mathbb{D}}}$ is defined as

[TABLE]

If the data abstraction is defined in terms of a Galois Connection a refinement ordering and abstraction function can be obtained. The refinement ordering $(\mathcal{P}_{\mathbb{D}},\preceq)$ is defined as $(s_{1},\Delta_{1})\preceq(s_{2},\Delta_{2})$ iff $\Delta_{1}\supseteq\Delta_{2}$ and $\forall_{t\in\mathit{ticks}(s_{2})}s_{1}(t)\preceq s_{2}(t)\wedge\forall_{t\in\Delta_{2}\setminus\mathit{ticks}(s_{2})}s_{1}(t)=s_{2}(t)$. The abstraction function $\alpha:2^{\mathcal{S}_{\mathbb{D}}}\to\mathcal{P}_{\mathbb{D}}$ is defined as $\alpha(S)=\mathsf{sup}\{(s,\mathbb{T})\mid s\in S\}$. Note, if the data abstraction is defined in terms of a Galois Connection, $(\alpha,\gamma)$ is a Galois Connection between $2^{\mathcal{S}_{\mathbb{D}}}$ and $\mathcal{P}_{\mathbb{D}}$.

An abstract event stream $s=(s^{\prime},\Delta)\in\mathcal{P}_{\mathbb{D}}$ can also be seen as a function $s:\mathbb{T}\rightarrow\mathbb{D}^{\#}\cup\{\mathrm{?},\bot,\operatorname{\smallsmile}\}$ with $s(t)=s^{\prime}(t)$ if $t\in\Delta$ and $s(t)=\operatorname{\smallsmile}$ otherwise. A particular point $t$ of an abstract event stream $s$ can be either

(a) directly at an event ($s(t)\in\mathbb{D}$),

(b) in a gap ($s(t)=\operatorname{\smallsmile}$),

(c) in a gapless segment without an event at $t$ ($s(t)=\bot$), or

(d) after the known end of the stream ($s(t)=\mathrm{?}$).

We denote $\mathbb{D}^{\#}_{\bot}\operatorname{\stackrel{{\scriptstyle\text{def}}}{{=}}}\mathbb{D}^{\#}\cup\{\bot,\operatorname{\smallsmile}\}$. If $\mathbb{D}^{\#}$ is a data abstraction of a data domain $\mathbb{D}$ with an associated concretisation function $\gamma$, then $\mathbb{D}^{\#}_{\bot}$ is a data abstraction of $\mathbb{D}_{\bot}$ with an associated concretisation function $\gamma_{\bot}:\mathbb{D}_{\bot}^{\#}\to 2^{\mathbb{D}\cup\{\bot\}}$ with

[TABLE]

tt$\top$ff\operatorname{\smallsmile}$$\botttff\bot$$\gamma$$\gamma_{\bot}$$\mathbb{B}^{\#}_{\bot}$$\mathbb{B}^{\#}$$\mathbb{B}_{\bot}$$\mathbb{B}

The above diagram shows a possible data abstraction $\mathbb{B}^{\#}$ of $\mathbb{B}$ and the corresponding data abstraction $\mathbb{B}^{\#}_{\bot}$. Using the functional representation of an abstract event stream we can now define the abstract counterparts of the TeSSLa operators:

$\mathbf{nil}^{\#}=(\infty,\mathbb{T})\in\mathcal{P}_{\emptyset}$ is the empty abstract stream without any gaps.

$\mathbf{unit}^{\#}=(0\boxempty\infty,\mathbb{T})\in\mathcal{P}_{\mathbb{U}}$ is the abstract stream without any gaps and a single event at timestamp 0.

$\mathbf{time}^{\#}:\mathcal{P}_{\mathbb{D}}\rightarrow\mathcal{P}_{\mathbb{T}},\mathbf{time}^{\#}(s):=z$ is equivalent to its concrete counterpart; only the data domain is extended: $z(t)=t$ if $t\in\mathit{ticks}(s)$ and $z(t)=s(t)$ otherwise.

$\mathbf{lift}^{\#}:({\mathbb{D}_{1}}^{\#}_{\bot}\times\dots\times{\mathbb{D}_{n}}^{\#}_{\bot}\rightarrow\mathbb{D}^{\#}_{\bot})\rightarrow(\mathcal{P}_{\mathbb{D}_{1}}\times\dots\times\mathcal{P}_{\mathbb{D}_{n}}\rightarrow\mathcal{P}_{\mathbb{D}}),\mathbf{lift}^{\#}(f^{\#})(s_{1},\ldots,s_{n}):=z$ can be defined similarly to its concrete counterpart, because the abstract function $f^{\#}$ takes care of the gaps:

[TABLE]

The operator $\mathbf{lift}^{\#}$ is restricted to those functions $f^{\#}$ that are an abstraction of functions $f$ that can be used in $\mathbf{lift}$, that is, $f(\bot,\dots,\bot)=\bot$. Using the abstract lift we can derive the abstract counterparts of const and merge:

$\textsf{const}^{\#}(c)(a):=\mathbf{lift}^{\#}(f_{c})(a)$ with $f_{c}(d):=c$ if $d\neq\operatorname{\smallsmile}$ and $f_{c}(\operatorname{\smallsmile}):=\operatorname{\smallsmile}$ otherwise maps all events’ values to a constant while preserving the gaps. Using $\textsf{const}^{\#}$ we can define constant signals without any gaps, e.g., $\textsf{true}^{\#}:=\textsf{const}^{\#}(\textsf{true})(\mathbf{unit}^{\#})$ or $\textsf{zero}^{\#}:=\textsf{const}^{\#}(0)(\mathbf{unit}^{\#})$.

$\textsf{merge}^{\#}(x,y):=\mathbf{lift}^{\#}(f)(x,y)$ with $f(a\not\in\{\operatorname{\smallsmile},\bot\},b)=a$, $f(\bot,b)=b$, $f(\operatorname{\smallsmile},b\in\{\operatorname{\smallsmile},\bot\})=\operatorname{\smallsmile}$, and $f(\operatorname{\smallsmile},b\not\in\{\operatorname{\smallsmile},\bot\})=\top$.

The diagram on the right shows an example trace merging the events of the streams $x$ and $y$. The symbol $\circ$ indicates a point-wise gap. Note how an event on the first stream takes precedence over a gap on the second stream, but not the other way round, similarly to how events from the first stream are prioritized if both streams have an event at the same timestamp.

$\mathbf{last}^{\#}:\mathcal{P}_{\mathbb{D}_{1}}\times\mathcal{P}_{\mathbb{D}_{2}}\rightarrow\mathcal{P}_{\mathbb{D}_{1}},\mathbf{last}^{\#}(v,r):=z$ has three major extensions over its concrete counterpart:

1. (1)

$\top$ is added as an output in case an event on $r$ occurs and there were events on the stream $v$ of values but all followed by a gap. 2. (2)

$\operatorname{\smallsmile}$ is outputted for all gaps on the stream $r$ of trigger events if there have been events on the stream $v$ of values. 3. (3)

$\operatorname{\smallsmile}$ can also be output if an event occurs on $r$ and no event occurred on $v$ before except for a gap.

The parts similar to the concrete operator are typeset in gray:

[TABLE]

The trace diagram on the right shows an example trace covering most edge cases of the abstract last. The output stream $z$ is a point-wise gap if triggered after initial gaps (3); $z$ is $\top$ if triggered after non-initial gaps (1); $z$ is an event if triggered after a gapless sequence (d); and $z$ inherits all gaps from the stream of trigger events (2).

We can now combine the $\mathbf{last}^{\#}$ and the $\mathbf{lift}^{\#}$ operators to realize:

abstract signal lift for total functions $f:\mathbb{D}\times\mathbb{D}^{\prime}\to\mathbb{D}^{\prime\prime}$ as $\textsf{slift}^{\#}(f)(x,y):=\mathbf{lift}^{\#}(g_{f})(x^{\prime},y^{\prime})$ with $x^{\prime}:=\textsf{merge}^{\#}(x,\mathbf{last}^{\#}(x,y))$ and $y^{\prime}:=\textsf{merge}^{\#}(y,\mathbf{last}^{\#}(y,x))$, as well as $g_{f}(a\not\in\{\operatorname{\smallsmile},\bot\},b\not\in\{\operatorname{\smallsmile},\bot\})=f(a,b)$, $g_{f}(\bot,b)=g_{f}(a,\bot)=\bot$, $g_{f}(\operatorname{\smallsmile},\operatorname{\smallsmile})=\operatorname{\smallsmile}$, and $g_{f}(\operatorname{\smallsmile},b\not\in\{\operatorname{\smallsmile},\bot\})=g_{f}(a\not\in\{\operatorname{\smallsmile},\bot\},\operatorname{\smallsmile})=\operatorname{\smallsmile}$.

Example 2.

By replacing every TeSSLa operator in 1 with their abstract counterparts and applying it to the abstract input streams $\textsf{values}\in\mathcal{P}_{\mathbb{Z}}$ and $\textsf{resets}\in\mathcal{P}_{\mathbb{U}}$, we derive the abstract stream $\textsf{cond}\in\mathcal{P}_{\mathbb{B}}$ and the recursively derived abstract stream $\textsf{sum}\in\mathcal{P}_{\mathbb{Z}}$: After the large gap on values, the sum stream eventually recovers completely. The first reset after the point-wise gap does not lead to full recovery, because at that point the last event on values cannot be accessed, because of the prior gap. The next reset falls into the gap, so again cond cannot be evaluated. In a similar fashion one can define an abstract $\mathbf{delay}^{\#}$ operator as counterpart of the concrete $\mathbf{delay}$. See Appendix 0.B for details.

Following from the definitions of the abstract TeSSLa operators we get:

Theorem 3.1

Every abstract TeSSLa operator is an abstraction of its concrete counterpart.

Theorem 3.1 implies that abstract TeSSLa operators are sound in the following way. Let $o$ be a concrete TeSSLa operator with the abstract counterpart $o^{\#}$ and let $s\in\mathcal{P}_{\mathbb{D}}$ be an abstract event stream with a concretization function $\gamma$. Then, $o(\gamma(s))\preceq\gamma(o^{\#}(s)).$ Since abstract interpretation is compositional we can directly follow from the above theorem:

Corollary 1

If a concrete TeSSLa specification $\varphi$ is transformed into a specification $\psi$ by replacing every concrete operator in $\varphi$ with its abstract counterpart, then $\psi$ is an abstraction of $\varphi$.

Theorem 3.1 guarantees that applying abstract TeSSLa operators to the abstract event stream is still sound regarding the underlying set of possible concrete event streams. However, we have established no result so far about the accuracy of the abstract TeSSLa operators. The abstraction returning only the completely unknown stream ($\Delta=\emptyset$) is sound but useless. The following theorem states, that our abstract TeSSLa operators are optimal in terms of accuracy. Using a perfect abstraction guarantees the abstract TeSSLa operators preserve as much information as can possibly be encoded in the resulting abstract event streams.

Theorem 3.2

Every abstract TeSSLa operator is a perfect abstraction of its concrete counterpart.

Given a concrete TeSSLa operator $o$ and its abstract counterpart $o^{\#}$, and any abstract event stream $s\in\mathcal{P}_{\mathbb{D}}$ with the Galois Connection $(\alpha,\gamma)$ between $2^{\mathcal{S}_{\mathbb{D}}}$ and $\mathcal{P}_{\mathbb{D}}$ one can show that $o^{\#}(s)=\alpha(o(\gamma(s)).$ Applying the abstract operator on the abstract event stream is as good as applying the concrete operator on every possible event stream represented by the abstract event stream. Thus $o^{\#}$ is a perfect abstraction of $o$. (The detailed proof can be found in Appendix 0.C.) Note that we assume that $f^{\#}$ is a perfect abstraction of $f$ to conclude that $\mathbf{lift}^{\#}(f^{\#})$ is a perfect abstraction of $\mathbf{lift}(f)$.

In Corollary 1 we have shown that a specification $\psi$ (generated by replacing the concrete TeSSLa operator in $\varphi$ with their abstract counterparts) is an abstraction of $\varphi$. Note that $\psi$ is in general not a perfect abstraction of $\varphi$. We study some special cases of perfect abstractions of compositional specifications in Section 4.

The next result states that the abstract operators can be defined in terms of concrete TeSSLa operators. Realizing the abstract operators in TeSSLa does not require an enhancement in the expressivity of TeSSLa.

Theorem 3.3

The semantics of the abstract TeSSLa operators can be encoded in TeSSLa using only the concrete operators.

Proof

One can observe that the abstract TeSSLa operators are monotone and future independent (the output stream up to $t$ only depends on the input streams up to $t$.) As shown in [7], TeSSLa can express every such function. ∎

3.1 Fixpoint Calculations Ensuring Well-Formedness

A concrete TeSSLa specification consists of stream variables and possibly recursive equations applying concrete TeSSLa operators to the stream variables. Theorem 3.1 and Corollary 1 guarantee that a concrete TeSSLa specification can be transformed into an abstract TeSSLa specification, which is able to handle gaps in the input streams. Additionally, Theorem 3.3 states that the abstract TeSSLa operators can be implemented using concrete TeSSLa operators. Combining these two results, one can transform a given concrete specification $\varphi$ into a corresponding specification $\psi$, which realizes the abstract TeSSLa semantics of the operators in $\varphi$, but only uses concrete TeSSLa operators.

However, using the realization of the abstract TeSSLa operators in TeSSLa adds additional cyclic dependencies in $\psi$ between the stream variables. A TeSSLa specification is well-formed if every cycle of its dependency graph contains at least one edge guarded by a last (or a delay) operator, which is required to guarantee the existence of a unique fixed-point and hence computability (see [7]).

Consider the trace diagram on the right showing $\mathbf{last}^{\#}(v,r)$. If $v$ is used in a recursive manner, i.e., $v$ is defined in terms of $\mathbf{last}^{\#}(v,r)$, then the first event on $v$ could start a gap on $\mathbf{last}^{\#}(v,r)$ that could start a gap on $v$ at the same timestamp. As a result $v$ has an unguarded cyclic dependency and hence the specification is not well-formed. To overcome this issue one can split up the value and gap calculation sequentially, reintroducing guards in the cyclic dependency:

Definition 2 (Unrolled Abstract Last)

We define two variants of the abstract last, $\mathbf{last}^{\#}_{\bot}$ and $\mathbf{last}^{\#}_{\operatorname{\smallsmile}}$ as follows. Let $z=\mathbf{last}^{\#}(v,r)$, then $\mathbf{last}^{\#}_{\bot}(v,r):=z_{\bot}$ and $\mathbf{last}^{\#}_{\operatorname{\smallsmile}}(v,r,d):=z_{\operatorname{\smallsmile}}$.

[TABLE]

Function $\mathbf{last}^{\#}_{\bot}$ executes a normal calculation of the events, in the same way an abstract last would do, but neglecting gaps and outputting $\bot$ as long as there is no event. Function $\mathbf{last}^{\#}_{\operatorname{\smallsmile}}$ takes a third input stream and outputs its events directly, but calculates gaps correctly as $\mathbf{last}^{\#}$ would do.

Since the trigger input of a $\mathbf{last}$ operator cannot be recursive in a well-formed specification, a recursive equation using one last has the form $x=\mathbf{last}^{\#}(v,r)$ and $v=f(x,\vec{c})$, where $\vec{c}$ is a vector of streams not involved in the recursion and $f$ does not introduce further last (or delay) operators. Now, this equation system can be rewritten in the following equivalent form:

[TABLE]

This pattern can be repeated if multiple recursive abstract lasts are used and can also be applied in a similar fashion to mutually recursive equations and the delay operator.

4 Perfection of Compositional Specifications

A concrete TeSSLa specification $\varphi$ can be transformed into an abstract TeSSLa specification $\psi$ by replacing the concrete operators with their abstract counterparts. For two functions $f$ and $g$ with corresponding abstractions $f^{\#}$ and $g^{\#}$ the function composition $f^{\#}\circ g^{\#}$ is an abstraction of $f\circ g$. Unfortunately, even if $f^{\#}$ and $g^{\#}$ are perfect abstractions, $f^{\#}\circ g^{\#}$ is not necessarily a perfect abstraction. Hence, $\psi$ needs not be a perfect abstraction of $\varphi$. In this section we discuss the perfection of two common compositional TeSSLa operators: (1) the $\textsf{slift}^{\#}$ defined in Section 3 is a composition of $\mathbf{last}^{\#}$ in $\mathbf{lift}^{\#}$, which realizes signal semantics; (2) $\mathbf{last}^{\#}(\mathbf{time}^{\#}(v),r)$, which is a common pattern used when comparing timestamps.

The $\textsf{slift}^{\#}$ is defined as the $\mathbf{lift}^{\#}$ applied to the synchronized versions $x^{\prime}$ and $y^{\prime}$ of the input streams $x$ and $y$. The input stream $x$ is synchronized with $y$ by keeping the original events of $x$ and reproducing the last known value of $x$ for every timestamp with an event on $y$, but not on $x$.

Theorem 4.1

If $f^{\#}$ is a perfect abstraction of $f$ then $\textsf{slift}(f^{\#})^{\#}$ is a perfect abstraction of $\textsf{slift}(f)$.

Proof

Since $\textsf{slift}^{\#}$ is defined on abstract event streams we need to consider gaps. The stream $x^{\prime}$ does not have any gap or event until the first gap or event on $x$. After the first gap or event on $x$ the synchronized stream $x^{\prime}$ contains a gap or event at every timestamp where $x$ or $y$ contain a gap or event. Because $\textsf{slift}^{\#}$ is symmetric in terms of the event pattern the same holds for $y^{\prime}$. By definition, $\textsf{slift}^{\#}(f^{\#})(x,y)=z$ contains an event or gap iff $x^{\prime}$ and $y^{\prime}$ contain an event or gap, because $f$ is a total function. The output stream $z$ contains an event iff $x^{\prime}$ and $y^{\prime}$ contain events. The events values are ensured to be as precise as possible, because $f^{\#}$ is a perfect abstraction of $f$. ∎

TeSSLa allows arbitrary computations on the timestamps of events using the $\mathbf{time}$ operator. The specification $z=\mathbf{time}(v)$ derives a stream $z$ from $v$ by replacing all event’s values in $v$ with the event’s timestamps. The stream variable $z$ can now be used in any computation expressible in TeSSLa. Hence, TeSSLa does not distinguish between timestamps and other values, and consequently abstract TeSSLa specifications cannot make use of the monotonicity of time. As an example consider the trace diagram on the right. The stream $\mathbf{last}^{\#}(\mathbf{time}^{\#}(v),r)$ is derived from $v$ by composing $\mathbf{time}^{\#}$ and $\mathbf{last}^{\#}$. Since $\mathbf{time}^{\#}$ changes the events values with their timestamps, the $\mathbf{last}^{\#}$ does not know any longer that we are interested in the last timestamp of $v$ and can only produce an event with the value $\top$ representing all possible values. To overcome this issue we define $\mathbf{lastTime}(v,r):=\mathbf{last}(\mathbf{time}(v),r)$ and provide a direct abstraction, which allows a special treatment of timestamps.

Definition 3 (Time Aware Abstract Last)

Let $y=\mathbf{last}^{\#}(\mathbf{time}^{\#}(v),r)$, we define $\mathbf{lastTime}^{\#}:\mathcal{P}_{\mathbb{D}}\times\mathcal{P}_{\mathbb{D}^{\prime}}\to\mathcal{P}_{2^{\mathbb{T}}},\mathbf{lastTime}^{\#}(v,r):=z$ as $z(t)=[a,b]$ if $y(t)=\top$ with $a=\operatorname{inf}\{t^{\prime}<t\mid\forall_{t^{\prime}<t^{\prime\prime}<t}v(t^{\prime\prime})\neq\operatorname{\smallsmile}\}$ and $b=\operatorname{max}\{t^{\prime}<t\mid t^{\prime}\in\mathit{ticks}(v)\}$ and $z(t)=y(t)$ otherwise.

Now the following result holds (the proof can be found in Appendix 0.C).

Theorem 4.2

$\mathbf{lastTime}^{\#}$* is a perfect abstraction of $\mathbf{lastTime}$.*

A similar problem occurs if $\textsf{slift}^{\#}$ is used to compare event’s timestamps. In Example 3 the stream cond derived by comparing the timestamps of values and resets has two events with the unknown data value $\top$ because of prior gaps on values. Since the $\textsf{slift}^{\#}$ is defined in terms of $\mathbf{lift}^{\#}$ and $\mathbf{last}^{\#}$ we can define the function $\textsf{sliftTime}^{\#}(f^{\#})(x,y)$ as an abstraction for the special case $\textsf{sliftTime}(f)(x,y)=\textsf{slift}(f)(\mathbf{time}(x),\mathbf{time}(y))$ by using $\textsf{lastTime}^{\#}$ instead of $\textsf{last}^{\#}$ and ensuring that $f^{\#}$ uses interval arithmetics to abstract $f$. Note that $\textsf{sliftTime}^{\#}(f^{\#})$ is a perfect abstraction of $\textsf{sliftTime}(f)$.

Example 3.

To illustrate the perfect abstraction $\textsf{sliftTime}^{\#}$ we update the definition of cond in Example 3 as follows: $\textsf{cond}=\textsf{sliftTime}(\leq)(\textsf{resets},\textsf{values})$. The events drawn in red now have concrete values instead of $\top$ as in Example 3.

5 Abstractions for Sliding Windows

In this section we demonstrate how to apply the techniques presented in this paper to specifications with richer data domains. In particular, we show now a TeSSLa specification that uses a queue to compute the average load of a processor in the last five time units. The moving window is realized using a queue storing all events that happened in the time window. The stream $\textsf{load}\in\mathcal{S}_{\mathbb{R}}$ contains an event every time the input load changes:

[TABLE]

The queue operation $\mathit{enq}$ adds elements to the queue, while $\mathit{remOlder}_{5}$ removes elements with a timestamp older than five time units. The function $\mathit{int}$ accumulates all values in the queue weighted by the length of the corresponding signal piece. The queue operation $\mathit{fold}$ is used to fold the function $f$ over all elements from the queue with the initial accumulator 0 until the timestamp $u$. Hence $f$ is called for every element in the queue with the timestamps $a$ and $b$, the element’s value $v$ and the accumulator. Consequently, the specification adds elements to the queue, removes the expired elements and accumulates the remaining values. Using our approach we replace every operator with its abstract counterpart and represent abstract queues appropriately such that also queues with partly unknown entries can be modeled. By doing this we obtain a specification that is able to handle gaps in the input stream, as illustrated in Fig. 2.

We can extend the example such that the queue only holds a predefined maximum number of events (to guarantee a finite state implementation). When removing events we represent these as unknown entries in the abstract queues. The abstract $\mathit{fold}^{\#}$ is capable of computing the interval of possible average loads for queues with unknown elements anyhow.

Note that the average load is only updated for every event on the input stream. Using a delay operator, we can set a timeout whenever an element leaves the sliding window in the abstract setting. The element is removed from the queue at that timeout and the new value of the queue is updated with the remaining elements. Formal definitions of the queue functions as well as the complete specifications are available online111http://tessla-a.isp.uni-luebeck.de/.

6 Implementation and Empirical Evaluation

As discussed in Section 3.1 the abstract TeSSLa operators can be implemented using only the existing concrete TeSSLa operators. We implemented the abstract TeSSLa operators as macros specified in the TeSSLa language itself such that the existing TeSSLa engine presented in [7] can handle abstract TeSSLa specifications. An abstract event stream $(s,\Delta)\in\mathcal{P}_{\mathbb{D}}$ can be represented as two TeSSLa streams $s\in\mathcal{S}_{\mathbb{D}^{\#}}$ and $s_{d}\in\mathcal{S}_{X}$, where $X$ contains the following six possible changes of $\Delta$: inclusive start, exclusive start, inclusive end, exclusive end, point-wise gap and point-wise event in a gap. Using this encoding it is sufficient to look up the latest $s_{d}(t^{\prime})$ with $t^{\prime}\leq t$ to decide whether $t\in\Delta$. While this encoding already allows a decent implementation of abstract TeSSLa we go one step further and assume a finite time domain with a limited precision, e.g., 64 bit integers or floats. Under this assumption there is always a known smallest relative timestamp $\varepsilon$. Hence, we can use the encoding $s_{d}\in\mathcal{S}_{\mathbb{B}}$ where an event $s_{d}(t)=\mathrm{true}$ encodes a start inclusive and $s_{d}(t)=\mathrm{false}$ an end exclusive. This encoding captures the most common cases and simplifies the implementation of union and intersection on $\Delta$ enormously since they can now be realized as $\textsf{slift}(\vee)$ and $\textsf{slift}(\wedge)$, resp. The other possible switches at timestamp $t$ can be represented as follows: $s_{d}(t+\varepsilon)=\mathrm{true}$ encodes an exclusive start, $s_{d}(t+\varepsilon)=\mathrm{false}$ encodes an inclusive end, $s_{d}(t)=\mathrm{true}$ and $s_{d}(t+\varepsilon)=\mathrm{false}$ encodes a point-wise event in a gap, and $s_{d}(t)=\mathrm{false}$ and $s_{d}(t+\varepsilon)=\mathrm{true}$ encodes a point-wise gap. Using this encoding the abstract TeSSLa operators do not need to handle these additional cases explicitly.

Furthermore, assuming the smallest relative timestamp $\varepsilon$, we can avoid the need to perform the unrolling defined in Defs. 2 by delaying the second part of the computation to the next possible timestamp $t+\varepsilon$.

As a final efficiency improvement we simplified $\mathbf{last}^{\#}$ before the first event on the stream of values, which are not relevant in practice. The abstract operator and hence abstract specifications are of course still a sound abstraction of their concrete counterparts, but due to over-abstractions no longer a perfect one during this initial event-less phase of the stream of values.

The implementation in form of a macro library for the existing TeSSLa engine is available together with all the examples and scripts used in the following empirical evaluation and can be experimented with in a web IDE222http://tessla-a.isp.uni-luebeck.de/.

In the following empirical evaluation we measure the accuracy of the abstractions presented in this paper. An abstract event stream represents input data with some sequences of data loss, where we do not know if any events might have been occurred or what their values have been. Applying an abstract TeSSLa specification to such an input stream takes these gaps into account and provides output streams that in turn contain sequences of gaps and sequences containing concrete events. To evaluate the accuracy of this procedure we compare the output of an abstract TeSSLa specification with the best possible output.

Let $r\in\mathcal{P}_{\mathbb{D}}$ be an abstract event stream. We obtain the set $R$ of all possible input streams containing all possible variants that might have happened during gaps in $r$ by applying the concretization function $\gamma$ on the abstract input stream. Now we can apply the concrete TeSSLa specification $\varphi$ to all streams in $R$ and get the set $S$ of concrete output streams. On the other hand we apply the abstract TeSSLa specification $\varphi^{\#}$ directly to $r$ and get the abstract output stream $s$. Now $S$ is the set of all possible output streams and $\gamma(s)$ is the set of output streams defined by the abstract TeSSLa specification. The diagram on the right depicts this comparison process.

To compare $\gamma(s)$ and $S$ in a quantitative way we define the ignorance measure $\iota:2^{{\mathcal{S}}_{\mathbb{D}}}\to\mathbb{I}=[0,1]$ scoring the ambiguity of such a set of streams, i.e., how similar the different streams in the set are. Events in non-synchronized streams might not have corresponding events at the same timestamp on the other streams. Hence we refer to the signal semantics of event streams where the events represent the changes of a piece-wise constant signal. As depicted on the right with three event streams over the finite data domain $\{0,1,2\}$, we score timestamps based on how many event streams have the same value with respect to the signal semantics at that timestamp. These scores are then integrated and normalized throughout the length of the streams. See Appendix 0.E for the technical details. Using this ignorance measure we can now compute the optimal ignorance $i:=\iota(S)\in\mathbb{I}$ and the ignorance $k:=\iota(\gamma(s))\in\mathbb{I}$ of the streams produced by the abstract TeSSLa specification.

For the evaluation we took several example specifications and corresponding input traces representing different use-cases of TeSSLa and compared the optimal ignorance with the ignorance of abstract TeSSLa. Note that computing the optimal ignorance requires to derive all possible variants of events that might have happened during gaps, which are in general infinitely many and in the special case of only point-wise gaps still exponentially many. Hence this can only be done on rather short traces with only a few point-wise gaps. As a measure for the overhead imposed by using the abstraction compared to the concrete TeSSLa specification we use the computation depth, i.e., the depth of the dependency graph of the computation nodes of the specifications. While runtimes are highly depending on implementation details of the used TeSSLa engines, the computation depth is a good indicator for the computational overhead in terms of how many concrete TeSSLa operators are needed to realize the abstract TeSSLa specification. See Fig. 3 for a graphical representation and Appendix 0.F for numerical results.

The first three examples represent the class of common, simple TeSSLa specifications without complex interdependencies and no generation of additional events with $\mathbf{delay}$: Reset-count counts between reset events; reset-sum sums up events between reset events; and filter-example filters events occurring in a certain timing-pattern. For these common specifications the overhead is small and the abstraction is perfectly accurate. The burst example checks if events appear according to a complex pattern. In the abstraction we loose accuracy because the starting point of a burst is not accessible by $\mathbf{last}^{\#}$ after a gap. A similar problem occurs in the queue example where we use a complex data domain to develop a queue along an event stream. If $\mathbf{last}^{\#}$ produces $\top$ after a gap all information about the queue before the gap is lost. For variable-period the abstraction is not perfectly accurate, because the $\mathbf{delay}$ is used to generate events periodically depending on an external input. This gets even worse for the self-updating queue where complex computations are performed depending on events generated by a $\mathbf{delay}$. Surprisingly, the finite-queue is again perfectly accurate, because the size of the queue is limited in a way that eliminates the inaccuracy of the abstraction in this particular example.

7 Conclusion

By replacing the basic operators of TeSSLa with abstract counterparts, we obtained a framework where properties and analyses can be specified with respect to complete traces and automatically evaluated for partially known traces. We have shown that these abstract operators can be encoded in TeSSLa, allowing existing evaluation engines to be reused. This is particularly useful as TeSSLa comprises a very small core language suitable for implementation in soft- as well as hardware. Using the example of sliding windows, we demonstrated how complex data structures like queues can be abstracted. Using finite abstractions, our approach even facilitates using complex data structures when only limited memory is available. Evaluating the abstract specification typically only increases the computational cost by a constant factor. In particular, if a concrete specification can be monitored in linear time (in the size of the trace) its abstract counterpart can be as well. Finally, we illustrated the practical feasibility of our approach by an empirical evaluation using the freely available TeSSLa engine.

Appendix 0.A TeSSLa Evaluation Example

Consider the equation

[TABLE]

where $0=\textsf{zero}=\textsf{const}(0,\textsf{unit})=\textsf{const}(0,\boxempty\infty)=0\infty$.

The equation can be seen as function of $y$ with fixed input stream $x=2\boxempty 4\boxempty\infty$. To compute the least fixed-point of this function we start with the empty stream $y_{0}=0$. We than have

[TABLE]

For the next iteration we start with $y_{1}=00$:

[TABLE]

For the next iteration we start with $y_{2}=002$:

[TABLE]

For the next iteration we start with $y_{3}=0021$:

[TABLE]

For the next iteration we start with $y_{4}=00214$:

[TABLE]

For the next iteration we start with $y_{5}=002142\infty$:

[TABLE]

So we have reached a fixed-point.

Note that $y_{0}\sqsubseteq y_{1}\sqsubseteq y_{2}\sqsubseteq y_{3}\sqsubseteq y_{4}\sqsubseteq y_{5}$ regarding the prefix relation.

Appendix 0.B Delay

In Section 2 TeSSLa was introduced with the operators $\mathbf{nil}$, $\mathbf{unit}$, $\mathbf{time}$, $\mathbf{lift}$ and $\mathbf{last}$. As discussed in [7] this set of operators is sufficient to express timestamp conservative functions, i.e., functions which do not introduce additional timestamps. In order to express arbitrary functions which can add events at arbitrary timestamps, TeSSLa was introduced in [7] with the $\mathbf{delay}$ operator. The $\mathbf{delay}$ operator was removed from the main content of this paper due to space limitations and the amount of technical details needed to define the concrete and abstract operators. Since these two operators nevertheless fit very seamless into the abstraction framework presented in this paper they are included in the implementation and the empirical evaluation and their definitions are given in this appendix.

0.B.1 Concrete Delay

$\mathbf{delay}:\mathcal{S}_{\mathbb{T}\setminus\{0\}}\times\mathcal{S}_{\mathbb{D}}\to\mathcal{S}_{\mathbb{U}},\mathbf{delay}(d,r):=z$ takes a delay stream $d$ and a reset stream $r$. It emits a unit event in the resulting stream after the delay passes. Every event on the reset stream resets any delay. New delays can only be set together with a reset event or an emitted output event. Formally,

[TABLE]

with the following auxiliary functions:

[TABLE]

For an example on how to use the $\mathbf{delay}$ operator in a TeSSLa specification see Section 0.D.4.

0.B.2 Abstract Delay

In Section 3 of this paper we presented the abstract operators $\mathbf{lift}^{\#}$ and $\mathbf{last}^{\#}$ for their concrete counterparts $\mathbf{lift}$ and $\mathbf{last}$. In a similar way we now define the abstract $\mathbf{delay}^{\#}$ operator as counterpart of the concrete $\mathbf{delay}$.

$\mathbf{delay}^{\#}:\mathcal{P}_{\mathbb{T}_{\infty}\setminus\{0\}}\times\mathcal{P}_{\mathbb{D}}\rightarrow\mathcal{P}_{\mathbb{U}},\mathbf{delay}^{\#}(d,r):=z$ needs additional logic to handle $\top$ events on the delay stream and gaps on the input streams. Since the output stream is of type $\mathcal{P}_{\mathbb{U}}$ no additional logic to produce $\top$ events is needed. We introduce the following additional auxiliary functions:

1. (1)

$\mathit{maybeEvent}$, which captures whether there may be an event that would cause the delay to hold:

[TABLE] 2. (2)

$\mathit{maybeBot}$, which captures whether it is plausible that the stream $z$ being defined does not tick:

[TABLE]

The conjunction of these two predicates captures the gap case. Again, the parts similar to the concrete operator are typeset in gray:

[TABLE]

The trace diagram on the right shows an example covering most of the interesting edge cases of the abstract delay: 0.B.2, 0.B.2 the gap on $d$ has no effect; 0.B.2 the gap on $r$ makes it unclear if a delay starts, a gap is created on $z$; 0.B.2 the gap on $r$ makes it unclear if reset happens, a gap is created on $z$. 0.B.2 $\top$ causes unknown delay which results in a gap on $z$ until next event happens on $r$; 0.B.2 the gap on $r$ starts unknown delay because of gap on $d$, reset event on $r$ does not help because gap on $d$ remains. Results in long gap on $z$ until event on $r$ happens out of the gap on $d$.

0.B.3 Finite State Implementations of Delay

Consider the example for $z=\mathbf{delay}^{\#}(d,r)$ shown on the right. If the delay produces an event after or during a gap on the reset stream, a potential reset event might cancel the delay earlier, creating point-wise gaps. The concrete delay has only one active delay at any given point in time. However, to implement the abstract delay infinite memory may be needed to keep track of all potential delays, because it may not be known whether a delay has been canceled or started earlier by a reset event. By keeping track only of the minimal and maximal potential delays we get a finite-memory implementation. However, this implementation may be an imperfect abstraction of the delay operator which produces larger gaps. Those gaps marked in red on the right are replaced with one large gap.

Definition 4 (Finite Memory Abstract Delay)

We define $\mathbf{delay}^{\#}_{\text{fin}}(d,r)=z$ to be the same as $\mathbf{delay}^{\#}(d,r)$ except that $z(t):=\operatorname{\smallsmile}$ (instead of $\bot$) if $\exists_{t^{\prime}<t}t^{\prime}+d(t^{\prime})\leq t\land r(t^{\prime})=\operatorname{\smallsmile}$ and $\forall_{t^{\prime\prime}|t^{\prime}+d(t^{\prime})\leq t^{\prime\prime}<t}z(t^{\prime\prime})=\operatorname{\smallsmile}$ and $\nexists_{t^{\prime\prime}|t^{\prime}<t^{\prime\prime}<t}t^{\prime\prime}\in\mathit{ticks}(r)$ and $\exists_{t^{\prime}<t}t^{\prime}+d(t^{\prime})\geq t\land r(t^{\prime})=\operatorname{\smallsmile}$.

0.B.4 Unrolling Delay

In Section 3.1 we discussed that using the abstract TeSSLa operators might introduce additional cyclic dependencies between the stream variables. In order to overcome this issue we presented translation in Definition 2 which reintroduces guards in the cyclic dependency by unrolling the value and gap calculation sequentially. The same approach can be applied to unroll the abstract $\mathbf{delay}^{\#}$ operator:

Definition 5 (Unrolled Abstract Delay)

We define two variants of the abstract delay, $\mathbf{delay}^{\#}_{\bot}$ and $\mathbf{delay}^{\#}_{\operatorname{\smallsmile}}$ as follows: Let $z=\mathbf{delay}^{\#}(d,r)$, then $\mathbf{delay}^{\#}_{\bot}(d,r):=z_{\bot}$ and $\mathbf{delay}^{\#}_{\operatorname{\smallsmile}}(d,r,p):=z_{\operatorname{\smallsmile}}$.

[TABLE]

Since the trigger input of a delay operator cannot be recursive in a well-formed specification, a recursive equation using one last has the form $x=\mathbf{delay}^{\#}(d,r)$ and $d=f(x,\vec{c})$, where $\vec{c}$ is a vector of streams not involved in the recursion and $f$ does not introduce further lasts or delays. Now, this equation system can be rewritten in the following equivalent form:

[TABLE]

By doing this, the calculation of the value and the domain of the definition is split in two parts preserving the semantics. The same pattern can be repeated if multiple recursive abstract lasts or delays are used.

There is a remaining case to be considered, when $f$ contains other abstract lasts or delays which lead to mutual recursive specifications. In this case, these other abstract lasts and delays have to use $x$, $d$ or $r$ as their input instead of the primed counterparts because the computation requires the complete last or delay stream, respectively. Furthermore, there may be more unrolling steps needed than just one to unroll the whole specification but every unrolling step still follows the previously described pattern for last and delay.

Appendix 0.C Missing Proofs

Theorem 0.C.2

Every abstract TeSSLa operator is a perfect abstraction of its concrete counterpart.

Proof

We need to show that for all partial streams $s_{1},\dots,s_{n}$ with $s_{i}\in{\mathcal{P}_{\mathbb{D}_{i}}}_{i}$ and every TeSSLa operator $f$ and its abstract counterpart $f^{\#}$ it holds that $f^{\#}(s_{1},\dots,s_{n})=\alpha(f(\gamma(s_{1}),\dots,\gamma(s_{n})))$. We use the Galois Connection $(\alpha,\gamma)$ as presented in Definition 1. For $\mathbf{nil}$ and $\mathbf{unit}$ this holds trivially because they are equal to their abstract counterparts. So it remains to show this for $\mathbf{time}$, $\mathbf{lift}$, $\mathbf{last}$ and $\mathbf{delay}$. Note that because the Galois Connection maps from the abstract lattice to the powerset of the (concrete) lattice, we assume all operators in the following are naturally extended to sets.

$\mathbf{time}^{\#}(s_{1})=\alpha(\mathbf{time}(\gamma(s_{1})))$ holds because $\mathbf{time}^{\#}$ changes nothing regarding the abstract elements: gaps are copied and the values of the events do not matter because they are replaced with the timestamps.

$\mathbf{lift}^{\#}(g^{\#})(s_{1},\dots,s_{n})=\alpha(\mathbf{lift}(g)(\gamma(s_{1}),\dots,\gamma(s_{n})))$ holds if $g^{\#}$ is a perfect abstraction of $g$, because the values and gaps are only passed to $g^{\#}$ in the abstract case which calculates the values and gaps.

$\mathbf{last}^{\#}(s_{1},s_{2})=\alpha(\mathbf{last}(\gamma(s_{1}),\gamma(s_{2})))$ holds because

• •

the only special case regarding the data abstraction is when a trigger occurs and there is a gap on the stream of values after the last event. Then $\top$ is the output which is fine because in the concretization the gap is replaced with arbitrary values. Other then that, the data abstraction is not important because in $\mathbf{last}^{\#}$ the data values are only copied to the new events on the output stream.

• •

the only special case regarding the gaps is a trigger event before any event on the stream of values but after a gap on said stream, which results in a gap. This is fine because the gap on the stream of values is later replaced with an arbitrary or no value which is then the output when the trigger event occurs. Thus using $\alpha$ later on this set of streams, we get a gap where the trigger event was. After the first event on the stream of values, the gaps from the stream of trigger events are just copied.

$\mathbf{delay}^{\#}(s_{1},s_{2})=\alpha(\mathbf{delay}(\gamma(s_{1}),\gamma(s_{2})))$ holds because data abstraction wise, the output can always only be unit. If we look at the gaps, there are only a few cases where $\mathbf{delay}^{\#}$ produces gaps: Point-gaps are created when a delay times out which (1) is set via a gap or (2) is set normally but a gap occurs on the reset stream before the timeout. Big gaps which last until the next event on the reset stream are created when a delay can be set but on the delay stream is (3) an event with $\top$ as value or (4) a gap. This perfectly fits to how $\alpha(\mathbf{delay}(\gamma(d),\gamma(r)))$ works because in

• (1)

the concretization function creates sets of streams where the delay is set not at all or with a value. The $\mathbf{delay}$ then outputs a set of streams where sometimes there is an output event and sometimes not which results in a point-gap again when the abstraction function is used.

• (2)

the concretization function creates sets of streams where where a reset and no reset happens before the timeout. This has the same implications as for (1).

• (3)

there is a delay started with $\top$ as value. Then the concretization function creates a set of streams having all possible values as delay at that point. Hence, $\mathbf{delay}$ results in the set of streams that have an arbitrary amount of events between the point where the delay is set and the next reset event. Using the abstraction function again this results in a big gap.

• (4)

it is the same case as (3) but the set of streams created by the concretization function contains additionally those streams with no value as delay. This has the same implications as in (3).

∎

Lemma 1

$\mathbf{lastTime}^{\#}$* is a perfect abstraction of $\mathbf{lastTime}$.*

Proof

We need to show that for all partial streams $v,r$ the following equation holds: $\mathbf{lastTime}^{\#}(v,r)=\alpha(\mathbf{lastTime}(\gamma(v),\gamma(r)))$. We use the Galois Connection $(\alpha,\gamma)$ as presented in Definition 1. Note that because the Galois Connection maps from the abstract lattice to the powerset of the (concrete) lattice, we assume all operators in the following are naturally extended to sets.

Because as shown in Theorem 3.2 $\mathbf{last}^{\#}$ and $\mathbf{time}^{\#}$ are perfects abstractions of $\mathbf{last}$ and $\mathbf{time}$, respectively, to show that $\mathbf{lastTime}^{\#}$ is a perfect abstraction of $\mathbf{lastTime}$, we just need to show that for the cases where the composition of $\mathbf{last}^{\#}$ and $\mathbf{time}^{\#}$ is not a perfect abstraction of $\mathbf{lastTime}$, $\mathbf{lastTime}^{\#}$ is now perfect. More precisely, the only case which is not perfect in the composition is the $\top$ case, which means a gap occurred after the last event on the stream of values. Then $\mathbf{lastTime}^{\#}$ returns an interval from the timestamp of the last event on $v$ to the timestamp at the end of the gap. This is the same which would be done when the concretization function first creates a set of streams containing an arbitrary amount of events in the gap which results in different timestamps as output. Either the latest from an event in the gap, if one exists or from the last event on $v$. The abstraction function would then creat said interval. In every other case, $\mathbf{lastTime}^{\#}$ outputs the same value as the composition of the perfect operators does. ∎

Appendix 0.D Data Abstraction of a Queue for Sliding Window Average Computation

0.D.1 Concrete Queue

TeSSLa can handle complex data structures and corresponding functions. An ordered queue is a sequence of timestamps and values $\mathcal{Q}_{\mathbb{D}}=(\mathbb{T}\times\mathbb{D})^{*}$ such that

[TABLE]

We use the following functions on queues:

[TABLE]

0.D.2 Abstract Queue

The set of our abstract version of queues we use here is defined as $\mathcal{Q}^{\#}_{\mathbb{D}^{\#}}=\mathbb{T}_{\infty}\times\mathcal{Q}_{\mathbb{D}^{\#}}$. The concretisation function is given as follows

[TABLE]

and the abstraction functions is given as $\alpha(Q)=\mathsf{sup}\{(0,q)\mid q\in Q\}$.

To improve the accuracy of the abstraction we insert the following limiting function as annotations on the possible ranges of variables into the concrete specification:

[TABLE]

In a similar fashion we add the a function removing newer elements from the queue which serves as annotation that a queue will never contain elements with a future timestamp:

[TABLE]

Now we define abstract versions for the previously defined functions:

[TABLE]

Note, that the abstract functions use intervals $\mathbb{I}^{\#}_{\mathbb{D}}$ to represent ranges of possible values.

In order to use the data domains we have to name the following elements:

[TABLE]

Now we can provide an abstraction of the TeSSLa specification for the input stream $\textsf{load}\in\mathcal{P}_{\mathbb{R}^{\#}}$:

[TABLE]

0.D.3 Finite Abstract Queue

If we want to limit the queue to a certain number of events, we just need to change the enqueue function as follows:

[TABLE]

For $q\in\mathcal{Q}^{\#}_{\mathbb{I}^{\#}_{\mathbb{D}}}$ we denote with $|q|$ the number of data values in $q$.

0.D.4 Concrete Self-Updating Queue

We now update the specification to be self-updating, i.e., update automatically every time an event leaves the moving window completely. For this, we can use the operator $\mathbf{delay}$ to create additional events. We add the following equations to the original specification and use updated instead of queue and load in the computation of avg:

[TABLE]

where $\mathit{dataTimeout}:\mathcal{Q}_{\mathbb{D}}\to\mathbb{T}$ is defined as follows:

[TABLE]

0.D.5 Abstract Self-Updating Queue

The abstract version of the specification for the self-updating queue can again be derived by replacing all TeSSLa operators with their abstract counterparts:

[TABLE]

where $\mathit{dataTimeout}^{\#}:\mathcal{Q}^{\#}_{\mathbb{I}^{\#}_{\mathbb{D}}}\to\mathbb{T}$ is defined as follows:

[TABLE]

The rest of the specification is adjusted to the abstract setting as shown before. The unrolling of $\mathbf{last}^{\#}$ and $\mathbf{delay}^{\#}$ as defined in 2 and 5 can be applied in order to realize this abstract TeSSLa specification in TeSSLa.

Appendix 0.E Technical Details of the Ignorance Measure

The function $v:\mathcal{S}_{\mathbb{D}}\times\mathbb{T}\to\mathbb{D}$ provides the current value of a stream at a given timestamp according to the signal semantics:

[TABLE]

For the data domain $\mathbb{D}$ we assume a measure space $(\mathbb{D},\mathcal{A},\mu)$ with the $\sigma$-algebra $\mathcal{A}\subseteq 2^{\mathbb{D}}$ on $2^{\mathbb{D}}$ and the normalized measure $\mu:\mathcal{A}\to[0,1]$ on $\mathbb{D}$, s.t. $\forall D\in\mathcal{A}:0\leq\mu(D)\leq 1$ and $\mu(\mathbb{D})=1$.

An ignorance representation is a piece-wise constant function $\operatorname{\textit{ig}}:\mathbb{T}\to\mathcal{A}$ s.t. $\operatorname{\textit{ig}}$ can be represented as a finite number of intervals. The progress of a stream $s\in\mathcal{S}_{\mathbb{D}}$ is a timestamp $t$ such that $\forall_{t^{\prime}>t}s(t^{\prime})=\mathrm{?}$ and $\forall_{t^{\prime}<t}s(t^{\prime})\neq\mathrm{?}$. For a set of streams $S\subseteq S_{\mathbb{D}}$ with equal progress $T$ an ignorance representation $\operatorname{\textit{ig}}$ can be retrieved such that

[TABLE]

Note, that depending on the chosen $\sigma$-algebra $\mathcal{A}$ one might need to extend the set $S$ into a compliant superset by adding missing streams first, before a matching ignorance representation can be derived. In those cases one has to specify a corresponding extension function together with the $\sigma$-algebra $\mathcal{A}$ and measure $\mu$. We call the superset derived by applying the extension function to $S$ the ignorance closure of $S$. From now on we assume $S$ always to be extended appropriately if needed. Under these assumptions, the tuple $(\mathcal{S}_{\mathbb{D}},2^{\mathcal{S}_{\mathbb{D}}})$ of all streams with progress $T$ and their power set form a measurable space.

The ignorance measure $\iota:2^{\hat{\mathcal{S}}_{\mathbb{D}}}\to[0,1]$ is defined via the interval representation of its ignorance representation:

[TABLE]

For the evaluation performed in this paper we either use limited intervals or finite sets. In case of the limited intervals our data domain $\mathbb{D}$ is limited such that $\forall_{d\in\mathbb{D}}$ we have $k\leq d\leq l$. We use the measure space $(\mathbb{D},\mathbb{I}_{\mathbb{D}},\mu)$ using the set of all intervals $\mathbb{I}_{\mathbb{D}}$ on $\mathbb{D}$ such that for any interval $[a,b]\subseteq\mathbb{D}$ we have

[TABLE]

In the case of a finite set $\mathbb{D}$ we can use the measure space $(\mathbb{D},2^{\mathbb{D}},\mu)$ such that for any $D\subseteq\mathbb{D}$ we have

[TABLE]

Appendix 0.F Empirical Results

[TABLE]

The above table shows the results of the empirical evaluation. The computation depth $d$ of the TeSSLa specification, the computation depth $d^{\#}$ of the corresponding abstract TeSSLa specification, the computation depth overhead $d^{\#}/d$, the perfect ignorance $i$ and the ignorance of the abstraction $k$.