Distributed Monitoring of Topological Events via Homology

TL;DR

This paper presents a distributed method for detecting topological events in sensor networks by leveraging local graph changes and homology, enabling accurate detection of multiple concurrent events.

Contribution

It introduces a novel model that uses graph homology and Betti number differences to detect and categorize topological events in dynamic sensor networks.

Findings

Effective detection of non-incremental topological events

Region updates are conflict-free and order-independent

Method accurately categorizes multiple concurrent events

Abstract

Topological event detection allows for the distributed computation of homology by focusing on local changes occurring in a network over time. In this paper, a model for the monitoring of topological events in dynamically changing regions will be developed. Regions are approximated as the connected components of the communication graph of a sensor network, reducing homology computation to graph homology. Betti number differences together with cyclic neighbor-rings are used to categorize topological event types. The focus lies on the correct detection of non-incremental (i.e., multiple concurrently occurring) events and the necessary region update process. Network number differences between a network's state before and after events are spread from event nodes into network regions, allowing for the conflict-free updating of regions independent of the update messages' order of arrival.

Tables

Table 1. TABLE I: Topological event types.

Positive Events		Negative Events
(1)	Region-Appearance	Region-Disappearance	(2)
(3)	Hole-Appearance	Hole-Disappearance	(4)
(5)	Region-Merge	Region-Split	(6)
(7)	Region-Self-Merge	Region-Self-Split	(8)
(9)	Topological Invariance

Equations

$$\chi (\Delta )=k_0-k_1+k_2-k_3+\dots ,$$

$$\chi (X)={\beta }_0-{\beta }_1+{\beta }_2-{\beta }_3+\dots ,$$

$$\chi ({\Delta }_2)=n-m+f={\beta }_0-{\beta }_1,$$

$${\beta }_1=-n+m-f+{\beta }_0.$$

$$\Delta {\beta }_k(t,t^{\prime })={\beta }_k^{(t^{\prime })}-{\beta }_k^{(t)},k\ge 0.$$

$$\mathrm{In}(v)$$

$$\mathrm{Out}(v)=$$

$$\begin{array}[]{ll}\mbox{\tt event-ID}:&[\pi_{e},i_{e}]\\ \mbox{\tt update}:&[n_{e},m_{e},f_{e},k_{e},c_{e}]\end{array}$$

$$\begin{array}[]{ll}\mbox{\tt event-ID}:&[\pi_{e},i_{e}]\\ \mbox{\tt update}:&[1,e_{\rm new}/2,f_{\rm new}/3]\end{array}$$

Full text

1 Introduction

Topology captures a network’s essential structure; i.e., the connected components and holes of the corresponding communication graph. These are properties which are of importance not only for the in-network routing of messages but also for the representation of a region monitored by a sensor network. Often more relevant than a precise approximation of a monitored region is the development of its structure over time; the topological changes a region undergoes. Environmental monitoring entails the periodic measurement and analysis of geospatial data. Applications include surveillance with moving sensors, the information exchange in multi-agent systems for the purposes of exploration is an example, and the monitoring of dynamic regions; usually the collected data is used for predictions (e.g., for weather forecasts).

The topic of this paper is the monitoring of topological events in dynamically evolving regions via homology. These events represent fundamental changes to the topology of observed regions; the formation of holes and the merging of different regions are prominent examples. Topological event detection is an appropriate method for the distributed computation of a region’s topological properties: A monitoring sensor network can be subdivided into connected components whose sensors share the same readings. Together they represent a so-called clique complex for which homology can easily be computed by means of graph homology. Moreover, Betti number differences resulting from changes in sensor readings then can be used to detect topological events. All events are detected locally at event nodes, where the required Betti number differences can be inferred by querying neighboring nodes.

The remainder of this paper is organized as follows: Section 2 provides general definitions necessary for topological event detection, and Section 3 defines the topological event model central to this paper. A combination of Betti number differences and a cyclic neighbor-ring is employed for event detection. As main part of this paper, Section 4 details the distributed region update process initiated upon event detection. This update process enables the detection of non-incremental (i.e., multiple concurrently occurring) events. Finally, in Section 5, results of topological event detection for simulated forest fires are presented.

2 Background

This introductory section provides an overview on recent research activities focusing on applying homology for the purpose of network analysis. Moreover, the necessary background on topology and homology is presented [7, 2].

2.1 Related Work

There exist several attempts in which efforts were made to employ homology for network analysis. In [5] a criterion for hole detection in wireless sensor networks (WSNs) with uniform coverage radii is developed:

Two Rips complexes are constructed as bounds for the union of coverage disks. Generators of the first homology group which are valid for both are proven to be network holes. However, the presented criterion comes with some disadvantages. The found generators may be non-minimal, some holes remain undetectable (in [12] the undetectable holes are identified as triangular holes) and all necessary computations are executed centralized.

Another approach [1] is the usage of a coverage criterion. A network is surrounded by a cycle of boundary nodes. When the boundary cycle can be filled in with 2-simplices of network nodes, no holes exist. To this end, the second homology group relative to the boundary cycle is computed. At least one hole exists if no generator can be found. This work was extended in [10], where a distributed algorithm for the coverage criterion is developed. All above mentioned works focus on the description of one network state. Instead of analyzing one snapshot of a complete network state at a time, the focus of the research field of topological events lies solely on the parts of a network changing over time. For example, in [9] monitored areas are partitioned into different region types. Regions of successive network snapshots are matched, and topological events are determined according to observed region type changes. Contrary to the previous example, in [11] a distributed algorithm for topological event detection is developed. Network nodes approximate the boundary of an areal object and are classified in relation to their positions at this boundary. The presented algorithm detects events locally at event nodes based on the nodes’ and their neighbors’ boundary-state transitions.

All of these works have in common a focus on incremental event detection. Only one node’s reading can change at a time; i.e., all events are detected successively. Consequently, the process of region updates, in which region identifiers are distributed in response to topological events, is not considered. In view of this observation, the contribution of this paper then is the development of a distributed region update process which allows for the detection of non-incremental events.

2.2 Homology and Betti Numbers

In algebraic topology, the information about a topological space $X$ can be encoded by a chain complex $C(X)$, which is a sequence of abelian groups $(C_{i})_{\geq 0}$ connected by homomorphisms $\partial_{n}:C_{n}\rightarrow C_{n-1}$ called boundary operators. It is necessary that the composition of any two consecutive boundary operators is trivial; that is, $\partial_{n}\circ\partial_{n+1}=0$ for each $n\geq 0$. Thus the image of the boundary operator $\partial_{n+1}$ is contained in the kernel of the boundary operator $\partial_{n}$; that is, ${\rm im}(\partial_{n+1})\subseteq{\rm ker}(\partial_{n})$. The elements of $B_{n}(X)={\rm im}(\partial_{n+1})$ are called boundaries and the elements of $Z_{n}(X)={\rm ker}(\partial_{n})$ are called cycles.

The quotient group $H_{n}(X)=Z_{n}(X)/B_{n}(X)$ is called the $n$th homology group of $X$. Elements of $H_{n}(X)$ are called homology classes and the rank of $H_{n}(X)$ is called the $n$th Betti number of $X$; it is denoted by $\beta_{n}(X)$. The number $\beta_{n}(X)$ counts the number of $n$-dimensional holes of a topological space $X$. In particular, $\beta_{0}$ is the number of connected components of $X$, $\beta_{1}$ is the number of one-dimensional holes of $X$, and $\beta_{2}$ is the number of two-dimensional cavities of $X$.

For instance, a graph with $n$ vertices, $m$ edges, and $k$ connected components has the Betti numbers $\beta_{0}=k$, $\beta_{1}=m-n+k$, and $\beta_{n}=0$ for $n\geq 2$.

2.3 Euler Characteristic

An abstract simplicial complex is a family $\Delta$ of non-empty finite subsets of a set $S$ which is closed under the operation of taking subsets. The finite sets in $S$ are called faces of the complex. A complex $\Delta$ is finite if it has finitely many faces. The dimension of a face $F$ is defined as $|F|-1$. In particular, the zero-dimensional faces are called the vertices of $S$. And the dimension of the complex $\Delta$ is given by the largest dimension of any of its faces.

For instance, let $V$ be a finite subset of $S$ of cardinality $n+1$, and let $\Delta=2^{V}$ be the power set of $V$. Then $\Delta$ is called a combinatorial $n$-simplex with vertex set $V$. Each combinatorial $n$-simplex has dimension $n$. In particular, if $V=S=\{0,1,\ldots,n\}$, then $\Delta=2^{V}$ is called the standard combinatorial $n$-simplex.

The Euler characteristic of an abstract simplicial complex $\Delta$ is the alternating sum

[TABLE]

where $k_{n}$ is the number of combinatorial $n$-simplices of $\Delta$. More generally, the Euler characteristic of a topological space $X$ is the alternating sum

[TABLE]

where $\beta_{n}$ denotes the $n$th Betti number of $\Delta$. For abstract simplicial complexes these two definitions will yield the same value for $\chi$.

For instance, a finite connected planar graph $G$ with $n$ vertices, $m$ edges, and $f$ faces including the exterior face has Euler characteristic $\chi(G)=n-m+f=2$. In particular, if $G$ is a tree, then $m=n-1$ and $f=1$. If the graph $G$ has $k$ connected components, then $n-m+f-k=1$. More generally, the Euler characteristic was first defined for the surface of polyhedra as $\chi=n-m+f$. In particular, the surface of any convex polyhedron has Euler characteristic $\chi=n-m+f=2$.

2.4 Clique Complexes

Clique complexes form a subclass of abstract simplicial complexes. The clique complex $X(G)$ of an undirected graph $G$ has a combinatorial simplex for each clique of the graph (Fig. 1). Since each subset of a clique is also a clique, the family of sets forms an abstract simplicial complex. The 1-skeleton of $X(G)$ is an undirected graph whose vertices correspond one-to-one with the 1-element sets in the family and whose edges are associated one-to-one with the 2-element sets in the family; i.e., the 1-skeleton of $X(G)$ is isomorphic to $G$.

2.5 Whitney Triangulation

A triangulation of a topological space $X$ is an abstract simplicial complex $\Delta$ which is homeomorphic to $X$. Triangulations are important in algebraic topology since they allow to compute homology and cohomology groups of triangulated spaces. A Whitney triangulation of a compact surface $X$ is an embedding of an undirected graph $G$ onto the manifold such that the faces (triangles) of the embedding are exactly the cliques (triangles) of the graph [8]. The resulting clique complex then is homeomorphic to the surface. The neighborhood set of a vertex in a Whitney triangulation is either cyclic (in the interior) or forms a path (at the boundary). A Whitney triangulation is closed exactly when its 1-skeleton is a locally cyclic graph, i.e., each vertex has a cyclic neighborhood structure.

A Whitney triangulation of a compact surface contains combinatorial simplices up to dimension two; i.e., the corresponding clique complex $\Delta_{2}$ is a 2-clique complex and thus the Euler characteristic for $\Delta_{2}$ is given by

[TABLE]

where $n$, $m$, and $f$ denote the number of vertices, edges, and faces, respectively. Thus the number of holes in a Whitney triangulation is given as

[TABLE]

3 Topological Event Detection

This section describes a formal model for topological event detection via homology, which is based in parts on the research of Farah et al. [3, 4]. Differences of Betti numbers [3] are used to represent topological changes. Moreover, network nodes possess a cyclic ordering of their neighbors, the so-called neighbor-ring [4], with which events can be detected as binary patterns.

In the following, the topological space given by a forest fire will serve as an application example for topological event detection. To this end, it is assumed that the observed space contains a static sensor network which updates measured values to approximate regions covered by fire. The common model makes use of a fire index (FI), a value incorporating information such as humidity, temperature, and wind speed.

3.1 Sensor Network Model

Let $X$ be a bounded region embedded in the Euclidean plane ${\mathbb{R}}^{2}$. Each point $p\in X$ is denoted as a vector $(x_{p},y_{p},t_{p})$, where the first two coordinates represent the spatial position and the third one represents a measurable scalar value. In the context of forest fire monitoring, the value $t_{p}$ represents the FI-value at the given position. Using a threshold value $\theta$, the measured scalar values can be discretized into binary values (0 and 1). For this, let $\hat{t}_{p}$ denote the binary value representing the discretized scalar value at sensor location $p$. The connected components with FI-values of one form to be monitored fire regions.

Let $S$ denote a non-empty finite set of monitoring sensors stationed in $X$. Consider a Whitney triangulation $\Delta$ of the region $X$ whose vertex set is given by $S$. The neighborhood structure of each interior node is cyclic, while the neighborhood structure of each boundary node forms a path. By deleting the nodes in the triangulation $\Delta$ (including their edges) which have FI-values of zero, one obtains the clique complex $\Delta_{\theta}$ of the to be monitored fire regions in $X$. We assume that for each sensor $s\in S$ of the network the following data are available:

• •

neighborhood structure $N_{s}$,

• •

measured FI-value $t_{s}$ and associated binary value $\hat{t}_{s}$,

• •

component information (number of nodes, edges, and faces) $(n_{s},m_{s},f_{s})$,

• •

component-ID $c_{s}$ and sensor-ID $\pi_{s}$.

Note that each sensor in $\Delta_{\theta}$ possesses information about the connected component to which it belongs. This is expressed by the component information and the component-ID. Also note that the clique complex $\Delta_{\theta}$ is embedded in the plane and so the zeroth Betti number $\beta_{0}$ is the number of fire regions (connected components) and the first Betti number $\beta_{1}$ is the number of one-dimensional holes (Fig. 2).

3.2 Topological Events

A topological event is a change of one or more topological invariants (i.e., Betti numbers) occurring in a topological space $X$ between two points in time. Topological events were first defined via Betti number differences in [3]. Write $\beta_{n}^{(t)}$ for the $n$th Betti number of the network observed at time $t$. Then the difference between the Betti numbers of the network observed at successive time steps $t$ and $t^{\prime}$ ($t^{\prime}>t$) is given by

[TABLE]

A positive topological event can be described as a mapping between two topological spaces $\phi:X\rightarrow X^{\prime}$ which is injective but not surjective (e.g., addition of a new node to $\Delta_{\theta}$), whereas a negative topological event is a surjective but not injective mapping (e.g., deletion of a node from $\Delta_{\theta}$).

In principle, there are nine types of topological events for two-dimensional spaces (Tab. I), which can be completely described by the first two Betti numbers $\beta_{0}$ and $\beta_{1}$. The first eight event types are causing a change of topological invariants (Figs. 3-6), while the ninth event type of topological invariance describes the case when no topological relevant event occurs, i.e., $\Delta\beta_{0}=\Delta\beta_{1}=0$; for a positive event this means a growing region, for a negative event a shrinking region. In the following, we will describe how these events can be detected using a neighbor-ring in addition to Betti number differences.

3.3 Event Detection via Homology

Basic topological event detection can be achieved by using homology. To see this, define an event node to be a node in the triangulation $\Delta$ whose FI-value changes between two successive time steps. Furthermore, assume that all event nodes’ neighbors are non-event nodes. A positive event occurs if an event node’s FI-value $t_{s}$ exceeds $\theta$ ($\hat{t}_{s}=1$); otherwise, the event is negative ($\hat{t}_{s}=0$). In case of a positive event, the corresponding event node is added to $\Delta_{\theta}$; otherwise, it is deleted. Event nodes with associated positive events are called positive event nodes, and event nodes associated to negative events are called negative event nodes.

An inner edge is an edge in $\Delta$ linking an event node to one of its neighbors, and an outer edge is an edge in $\Delta_{\theta}$ connecting two neighbors of an event node. Formally, the sets of inner and outer edges of an event node $v\in V(\Delta)$ are defined respectively as follows,

[TABLE]

and

[TABLE]

The cardinalities of these sets represent the numbers of changed edges $e_{\rm new}=|{\rm In}(v)|$ and faces $f_{\rm new}=|{\rm Out}(v)|$ detected by an event node between two successive snapshots of the network.

With $\hat{t}_{s}$ capturing the addition/deletion of a vertex (i.e., the event’s sign) as $n_{new}=\hat{t}_{s}$, the component information can be updated by adding $n_{new},e_{new},f_{new}$ with appropriate signs to ($n_{s},m_{s},f_{s}$). Combined with the number of surrounding components $\beta_{0}$, the updated component data can be used to locally calculate Betti number differences of the connected component to which the event node belongs.

3.4 Cyclic Neighborhood Ring

Event nodes may have insufficient information to correctly determine a topological event type. In case of a positive event the associated event node can determine its number of surrounding components $\beta_{0}$ using the component-IDs of neighboring nodes. However, in case of a negative event, this component-ID query will fail since all neighbors previously were part of the same component as the event node; i.e., all nodes will necessarily have the same component-IDs. In order to compute the zeroth Betti number for negative events, we introduce an additional data structure which was used in [4] for event detection, the so-called neighbor-ring.

The Whitney triangulation $\Delta$ defining a network’s communication graph determines a cyclic ordering for each interior node’s neighbors. FI-values of all direct event node neighbors are collected in a list called neighbor-ring and sorted by the event node’s cyclic ordering. A continuous block of ones in the neighbor-ring represents a ring component; boundary nodes of $\Delta$, having non-cyclic neighbor-rings, always separate entries of ones at the start/end of the list as two different ring components. The number of ones in the neighbor-ring is equal to $e_{new}$, while the number of ring components $r_{c}$ allows the computation of $f_{new}=e_{new}-r_{c}$.

Generally, the number of ring components can be assumed to be equal to the number of different connected components surrounding an event node, and can be used as a replacement for the zeroth Betti number when detecting negative events. But this assumption only holds true for split events. Self-split events, seen from an event node’s perspective, involve multiple ring components, yet only one region actually exists. Split and self-split events are therefore indistinguishable (Fig. 7). Section 4.3 will provide a (partial) solution for the detection of self-split events.

3.5 Ring Query

Event nodes query their neighbors to both update their neighbor-rings for event detection and attain the component data of surrounding ring components necessary for region updates (Sect. 4.1). As neighboring nodes belonging to the same ring component share their component data, only one representative node per ring component has to be queried by an event node. For this, a ring query can be executed:

At first the event node creates an event token with its sensor-ID as content. This token is passed to the neighbor associated with the first entry in the neighbor-ring. When the queried neighbor has $\hat{t}_{s}=0$, the ring query is rejected and the next node in the neighbor-ring is queried. Otherwise, the representative node reports its component information to the event node before starting two query chains - one for each neighbor shared with the event node - in which the event token is passed around the ring of event node neighbors simultaneously in two directions. Event tokens are passed as long as the receiving sensors have FI-values of one. These tokens serve to detect when the cyclic ring of neighbors is completed; both query chains will eventually reach a node already possessing an event token. When a token cannot be passed any further, i.e., the next node rejects the token ($\hat{t}_{s}=0$) or the cycle is completed, the corresponding nodes report back the so-called chain ends to the event node, ending the query of one ring component. A chain end consists of the sensor-IDs of the last two nodes in a query chain. The two received chain ends are used by the event node to determine which entries in the neighbor-ring must be set to one for the previously queried ring component. These are precisely the neighbor-ring entries inbetween the entries associated to the two chain ends by the event node’s cyclic order.

This process is repeated for the next ring component, whose first queried sensor is located at least two positions behind the last queried ring component in the neighbor-ring. The ring query ends when all neighbors were queried directly by the event node, or indirectly through a ring component query (Fig. 8).

3.6 Event Decision Diagram

The event decision diagram (Fig. 9) illustrates the decision process of an event node for topological event detection. Instead of directly computing Betti number differences, an event node’s neighbor-ring is used to infer the differences and distinguish event types. This approach allows event detection independent of the component numbers. Additionally, the actual Betti number differences can be computed and compared with the inferred values; conflicting values indicate erroneous component data.

Region-Appearance/-Disappearance (1,2) and Hole-Appearance/-Disappearance (3,4) events can be inferred directly from the cyclic neighbor-ring. In these cases, the whole neighbor-ring is either a sequence of ones or a sequence of zeros - boundary nodes, having non-cyclic neighbor-rings, cannot detect the events (3,4). A self-merge (7) event can be identified when the event node detects multiple ring components but only receives one component-ID from all of its neighbors. Similarly, merge events (5) are identified when not only multiple ring components but also multiple different component-IDs are received. In particular, a positive $\Delta\beta_{1}$ value at the merge node implies that a combined merge/self-merge event has happened. And split events (6), which are indistinguishable (Sect. 3.4) from self-split events (8), are identified when the event node is surrounded by multiple ring components. Each detectable event type in the diagram is annotated with the corresponding Betti number differences. All with inequalities listed event types require actual Betti number computations to determine the precise numbers of appearing/vanishing regions/holes.

4 Distributed Event Monitoring

The previously introduced event detection model (Sect. 3.3) implicitly relied on the assumption of all network nodes but one event node having stable FI readings. By itself this approach is only applicable for incremental event detection. The following section will extend this model with a region update process allowing for the distributed monitoring of non-incremental events.

4.1 Region Updates

During the process of monitoring an areal object for topological changes, regular updates of the monitoring network’s sensor data are necessary. Let $S_{t}$ denote the network’s state detected at time $t$: It is assumed that all sensors periodically update their FI-values at the start of each sample time interval $(t,t^{\prime})$, where $t^{\prime}>t$. For this, all sensors are assumed to have globally synchronized clocks.

Sensors which detect a change in their FI-values, i.e., event nodes, determine the topological event types and initiate region updates. In response to detected topological events, each node residing inside a connected component of $\Delta_{\theta}$ must update its component information $[n_{s},m_{s},f_{s}]$, as well as its component-ID $c_{s}$. To this end component number differences between $S_{t}$ and the previous state $S_{t-1}$ are distributed by event nodes into their surrounding components, changing the network’s state from $S_{t-1}$ to $S_{t}$.

During rinq queries event nodes collect component data $[n_{c},m_{c},f_{c}]$ from each of their surrounding components $c$ (Sect. 3.5). Depending on the detected event type, either the event node’s update list $[n_{new},e_{new},f_{new}]$ (Sect. 3.3), or the queried components’ data are used to create lists of component number differences for each surrounding component.

4.1.1 Region Update Messages

Region updates are achieved by spreading region update messages from event nodes into regions of $\Delta_{\theta}$. We consider a simplified communication model: Update messages are spread unidirectionally by each component node starting at the event nodes. An update node is a network node which is receiving update messages. Update nodes pass received event messages to all of their neighbors. Zero nodes ($\hat{t}_{s}=0$) neither process nor pass received update messages. Furthermore, we assume that the communication is without errors.

[TABLE]

Region update messages consist of unique event-IDs as message headers, and lists of component number differences as update message contents. An event-ID contains two parts:

The sensor-ID $\pi_{e}$ of the event node and the event number $i_{e}$; each sensor counts its number of detected events and assigns each created update message an appropriate event number. This definition of an event-ID guarantees that no network node applies the same update more than once; update nodes store received event-IDs and reject known updates: $[\pi_{e_{1}},i_{e_{1}}]\neq[\pi_{e_{2}},i_{e_{2}}]$. Event nodes store their created event-IDs before sending update messages, preventing them from processing their own update messages. An update message’s contents consist of a list of network numbers to update. These are the component number differences which each update node adds to its component information to apply the update. Component numbers are followed by a target component-ID $k_{e}$ together with a new component-ID $c_{e}$ if the corresponding event concerns more than one network component (e.g., merge events). New component-IDs are always processed, even if the event-ID is known (Sect. 4.3).

Component-IDs consist of sensor-IDs and event-IDs of the creating event nodes, i.e, $c_{e}=[\pi_{s},(\pi_{e},i_{e})]$ (from here on only $\pi_{s}$ is used when referring to component-IDs). Sensors store component-ID values for both the current and the previous sample interval. The latter values are stable during the current sample interval and can be compared against the target-ID values of update messages; they indicate intended regions for region update messages. Region updates then can be selectively applied only to nodes which were part of the component $k_{e}$ during the previous network state $S_{t-1}$.

There exist three different update message types: Normal updates messages are sent following topological events which involve exactly one region. Merge update messages are sent into each component connected via the event node after a merge event. And split update messages are sent into event nodes’ surrounding components after the detection of split events. In the following the creation of these update message types by event nodes and the subsequent region update process will be described in detail (Sect. 4.1.2–4.1.4).

4.1.2 Normal Update

Updates resulting from hole-appearance/-disappearance, region-appearance/-disappearance, and topological invariant events fall under the category of normal updates. In all aforementioned cases the event node is surrounded by at most one fire region. Therefore, it is sufficient to transmit a region update message to one of the event node’s neighbors $r$ lying inside $\Delta_{\theta}$ (Alg. 1).

The component number difference list for a normal update message is created by multiplying the event node’s update list $[n_{new},e_{new},f_{new}]$ with the event’s sign. The normal region update then is applied by adding these values to the component information $[n_{s},m_{s},f_{s}]$ at each node processing the update message. In case that no surrounding region exists, the event node updates its component-ID to its sensor-ID (region-appearance), or skips the region update process altogether (region-disappearance). Otherwise, the component-ID of the surrounding region is assumed by the event node; no new component-ID has to be added to the region update message.

Lemma 4.1.

Normal updates correctly update regions surrounding event nodes, independent on whether other events occur concurrently in these regions.

Proof.

As update messages are passed to each neighbor inside the component, every node of the component surrounding the event node will receive the normal update message. Concurrently merged regions receive normal updates via merge event nodes.

Update messages from other event nodes cause no data conflicts. Independent on the processing order at each component node, the overall sum of component number differences will reflect all occurred events. When each node has processed the normal update, the region is updated in response to the associated event. ∎

4.1.3 Merge Update

After the detection of a merge event, the event node sends merge update messages into each surrounding component. For each component $c$ merged into the new merged region, the component numbers of all other merged components must be added to all component nodes. Therefore the component information $[n_{c},m_{c},f_{c}]$ is used as component number difference list for merge update messages. Additionally, the data ($\pm 1$, $e_{new}$,$f_{new}$) directly added by a merge event node to the merged region must be added to all surrounding components’ numbers. Each merge event node transmits one additional normal update message with this data into each component (Alg. 2).

Merge update messages contain the IDs $k_{e},c_{e}$ in addition to the component number differences contained in normal updates messages. A merge update message is processed only if it originated from a different region ($c_{u}\neq k_{e}$) than the processing update node $u$. In addition, a sensor maintains a list of merged component-IDs, the merge tokens list, to distinguish which components were already merged during the current sample interval. Only merge updates with target IDs not already contained in the merge tokens list are processed. Event nodes detecting merge events fill their merge tokens lists with IDs of all their surrounding components (line 2 of Alg. 2).

Having different component-IDs before the merge event, a new component-ID $c_{e}$ for the merged regions after the event is required. The event node’s sensor ID is used for that purpose: For each component surrounding the event node, the component-ID $c_{e}$ of the first split or merge update message to reach an update node is used as the new component-ID. Otherwise only a lower value is accepted as a new component-ID. Components after merge/split events will assume the lowest ID of all update messages sent by participating merge/split event nodes in the region.

Although the components surrounding an event node can be differentiated during merge events, merge update messages are spread into each ring component via representative nodes $r$ to guarantee that each node in the region receives all updates. For instance, when a combined merge/self-merge event occurs, a self-split event could happen concurrently in the same region. Would only one representative node of a component be informed of this event, at least one part of the new merged region would not receive the merge update message.

Lemma 4.2.

Merge updates correctly update regions after merge events, independent on whether other events occur concurrently inside the merged region.

Proof.

The sums $[\sum_{c}n_{c},\sum_{c}m_{c},\sum_{c}f_{c}]$ of component numbers of each merged component $c$, with the addition of the merge event node’s update numbers ($\pm 1$, $e_{new}$,$f_{new}$), represent the component numbers for a merged region. Merge updates apply these numbers at each node of a merged region. Regions concurrently merged at other merge event nodes either add to the overall component sums, or represent regions which are already part of the component sums. Target component-IDs $k_{e}$ allow for the distinction between different merge events of the same region:

Two regions can merge at different points at the same time. Without target-IDs the merge event nodes would send the same merge update with different event-IDs, and the same merge update would be added more than once at each component node. To avoid this possible conflict target-IDs are sent by event nodes and saved by each node receiving update messages. Only one merge update message per target-ID is applied in one sample interval at each update node. ∎

4.1.4 Split Update

Updates resulting from split, self-split and self-merge events all fall under the category of split updates. Self-merge updates, although categorized under split updates, are applied by sending normal update messages. Contrary to normal updates, self-merge updates must be transmitted into each ring component of an event node and are therefore handled together with split messages.

After a split event no information on the number of lost nodes, edges or faces of the split regions is available. Instead of transmitting differences to update the component numbers, a complete recomputation of the split components is necessary. Split update messages are sent to one representative node per ring component (Alg. 3). The reasoning is the same as for merge updates; concurrent events can cause ring components to become disconnected. Split updates messages, like merge update messages, contain two component-IDs. One for the new component-ID $c_{e}$ after the split, and one to indicate the targeted region $k_{e}$. The target component-ID serves to indicate which nodes are part of the split regions. Split updates are executed in two phases:

In the first phase, the split event node transmits split update messages which contain the component numbers of the component previously surrounding the event node with negative signs. Each node $u$ receiving a split update message adds these numbers to its component numbers. Additionally, the split updates’ target-IDs are added to the split tokens lists of each node. During one sample interval only one split update message per target-ID is processed, guaranteeing that each split component’s numbers are subtracted only once when multiple split event nodes exist in the same region.

In the second phase, split update nodes $u$ send split update event messages to recompute the split components. Split update event messages are only created by nodes which lie inside the region previously surrounding the event node; i.e., $c_{u}=k_{e}$. A split update event message is nothing but a normal update message with the following contents:

[TABLE]

For the computation of $e_{\rm new},f_{\rm new}$ additional ring queries at each split update node are necessary.

Two special cases must be accounted for when recomputing split regions: Neighboring positive event nodes must not be counted for inner and outer edge numbers, they already sent these numbers via own event update messages into the component. Neighboring negative normal event nodes (not split event nodes) send their inner/outer edge numbers as negative component difference numbers into the component. Therefore each split update event node increments its update numbers with neighboring negative event nodes’ inner/outer edge numbers, and decrements with positive event nodes’ inner/outer edge numbers. Algorithm 4 describes the split update event process in detail.

Lemma 4.3.

Split updates correctly update regions after split events, independent on whether other events occur concurrently inside the split regions.

Proof.

First, the split components’ numbers are reset to zero by spreading split update messages in the affected regions. All neighboring regions which were concurrently merged into one of the split regions will also receive split update messages, and will subtract the same amounts from their component numbers. Effectively, the component numbers of the split region in the previous state $S_{t-1}$ are subtracted from all component nodes: To receive a split update message, an update node must either be part of the targeted component, in that case its numbers are set to zero, or it receives the split message from a different region through a merge event node, in which case the split message’s numbers will be canceled by a merge message of the same amount. In either case, the split components’ numbers will be erased from all network nodes.

During the second split phase each node sends split update event messages. Each update node counts one vertex, two connected nodes count a half of an edge each, and three connected nodes each count a third of one face. The overall sums of split update event messages will represent the split components’ numbers after split events. Due to the target-ID only regions surrounding split event nodes during the state $S_{t-1}$ are affected. Regions merged to concurrent split regions will not be recomputed. ∎

4.1.5 Event Regions

Although the concurrent detection of multiple events inside a connected component of $\Delta_{\theta}$ is possible, regions consisting of event nodes cannot reliably determine event types. An event region is defined as a connected component of at least two network nodes where each contained node, independent on its FI-value, is an event node. Figure 12 demonstrates one such region of three negative event nodes. In this particular example none of the three event nodes is able to detect a hole appearance. Event nodes inside an event region cannot correctly determine their inner/outer edge numbers (Sect. 3.3) as the neighbor-rings’ values do not reflect the previous network state. To enable event detection for event regions, event regions have to be replaced with single event nodes. For this, each event node maintains a counter which indicates the sampling interval at which the last event was detected. This time stamp can be passed along in ring queries (Sect. 3.5). Neighboring event nodes send back blocking messages if both nodes have the same time stamp and the querying node has a higher sensor-ID. Event nodes stop their event detection process upon reception of such blocking messages and will retry the event detection in the next sample interval, provided their FI-values stay unchanged. Event regions are thus replaced by single event nodes and their events’ are reconstructed as chains of multiple sub-events.

Theorem 4.1.

The region update correctly updates all component data for each node inside $\Delta_{\theta}$ after non-incremental events detected at time $t$ when the sample interval is long enough to process all update messages.

Proof.

All update messages sent during the region update process contain component number differences. Therefore the messages’ order of arrival/processing has no impact on the resulting component numbers after the region update. By Lemma 4.1 normal updates reach all nodes inside the affected regions and are applied once at each node. Each normal update applies the respective event node’s numbers to its surrounding component. By Lemma 4.2 merge updates increment all merged components’ numbers to the component numbers of the merged regions. Due to the target-ID no component is counted twice; each components’ numbers are added once at each node inside merged regions.

By Lemma 4.3 split events cause a recomputation of all split regions. Overall, the list $-[n_{c},e_{c},f_{c}]$ of previous component numbers in state $S_{t-1}$, and the lists of split components’ new numbers $[n_{d},m_{d},f_{d}]$ are distributed into each component $d$. Regions concurrently merged into split regions additionally will receive merge updates $[n_{c},m_{c},f_{c}]$ based on the previous network state. The split update’s numbers will cancel the previous component’s numbers at each node. Only the component numbers $[n_{d},m_{d},f_{d}]$ remain.

The usage of unique sensor-IDs for component-IDs guarantees that no two components can receive the same component-IDs during one sample interval. However, it is possible that two different components are created with the same sensor-IDs during different network states. When the event node creating the event-ID is the same in both states, the event number $i_{e}$ of the event-ID in $c_{e}$ will be different. When the event nodes are different, the event node sensor-IDs will be different. In either case the component-ID will be unique for all components.

One cause for false component information would be neighboring event nodes, in which case the differences to previous component numbers could not be inferred reliably at event nodes. However, an event node cannot have a neighboring event node, since by (Sect. 4.1.5) event regions are replaced by single event nodes. When all update messages of a region update are processed, the network’s state is changed from $S_{t-1}$ to $S_{t}$. ∎

4.2 Sensor FSM Model

A sensor designated for topological event detection can be described as a finite state machine (FSM) with five states (Fig. 13): Initially no network data is available and all sensors are in the init state. Here the cyclic ordering of neighbor nodes necessary for event detection is established. Next follows the sample state. FI-values are sampled and the state changes accordingly. In case of a detected change of the FI-value, the event state is entered. After event processing, an event node either is set inactive, i.e., it changes into the idle state, or the update state is entered. In both cases the sample state is reentered at the beginning of the next sample interval.

4.2.1 Init

The network’s communication structure is set up in the init state. For this, sensors exchange their neighbor lists to determine lists of shared neighbors. Then each sensor creates its own cyclic ordering of direct neighbors by passing a cycle message around its neighbor-ring; i.e., neighbors pass the message to the next neighbor shared with the initiating sensor until a cycle is completed.

4.2.2 Sample

At the beginning of each sample interval all sensors reside in the sample state. All sensors sample new FI-values. When a changed FI-value is detected, a sensor changes into the event state. Otherwise, depending on the sensor’s current FI-value, either the idle state ($\hat{t}_{s}=0$), or the update state ($\hat{t}_{s}=1$) is entered.

4.2.3 Idle

Upon entering the idle state, a sensor becomes inactive. Only queries from neighboring event nodes are answered during the current sample interval. Event nodes in this context also include nodes in the update state which recompute their components after split events (Sect. 4.1.4). The idle state is automatically left when a new sampling interval starts.

4.2.4 Event

The event state can be subdivided into three phases. First, all event node neighbors are queried in the form of a ring query to update the neighbor-ring. At this point an event node’s detected event can be canceled out by a neighboring event node with a lower sensor-ID (Sect. 4.1.5). Whereupon the sensor changes into the idle or update state, depending on its previous FI-value, its newly sampled FI-value is ignored and all data of the previous network state are retained. After a successful ring query and the determination of the event type, update messages are sent to the neighboring sensors in order to update the event node’s surrounding components (Sect. 4.1).

4.2.5 Update

All sensors in the update state have a current FI-value of one; that is, they belong to a connected component of a monitored fire region. A sensor in the update state processes region update messages (Sect. 4.1) sent by event nodes. Upon reaching a new sample interval, the update state is left.

4.3 Self-Split Event Detection

Although self-split events cannot be distinguished from split events (Sect. 3.4), they can be detected as a byproduct of the split update process. When a self-split event happens, the detecting event node will pass a split update message to each ring component. Line 4 of Algorithm 3 reveals that, instead of using the event node’s sensor-ID, a representative node’s sensor-ID is used for the region’s component-ID after the split. For a self-split event this means that multiple component-IDs will be spread in the same region.

Split messages which reach already recomputed nodes (i.e., the event ID is known) will still be processed if they have a lower component-ID. It is exactly here, where a node changes its component-ID again following the same split event, that self-split events can be detected. The original event node will receive a special self-split message from a neighboring node detecting the event during its update state (Fig. 14).

The above described method for the detection of self-split events can fail to detect self-splits in cases where other split/merge events happen concurrently in the same region. When another split/merge event node in the same region transmits the lowest component-ID, that ID could be spread to all ring components before the self-split can be detected. In that case the self-split event is detected as a split event at the event node. However, even then the self-split event can be detected indirectly after the region update process. The component numbers after the split update will reveal a decrease in the first Betti number for self-split events.

5 Simulations

The GAMA [6] based multi-agent simulation tool TopED (Topological Event Detection) was developed in conjunction with this paper for the simulation of topological event monitoring. In the simulation network sensors are deployed in hexagonal grids, each sensor is located at the center of a hexagon, and communication links are established between sensors of neighboring hexagons. The resulting triangulation is a Whitney triangulation fulfilling all criteria defined in Section 3.1. In addition to the sensor network, randomly spreading forest fires are simulated as the to be observed regions. Coordinates of the simulated world contain FI-values reflecting temperatures as scalars. Sensors sample the FI-values and convert them into binary values. The resulting subgraph of all sensors with FI-values of one represents the simulated forest fire.

Supported by the TopED simulation are the nine topological event types discussed in Section 3.3. Figures 16 and 17 show examples of networks simulated with TopED. The underlying scalar field is represented as a heat map. Black regions represent fires, bright nodes indicate sensors with FI-values of one, and dark sensors have FI readings of zero. Additionally, communication links together with component-IDs are displayed for sensors lying inside fire regions. Topological events are highlighted with event numbers, subscripts indicate the Betti number differences $(\Delta\beta_{0},\Delta\beta_{1})$, and positive/negative events are indicated by bright/dark numbers. Most computations during event monitoring (event/update state) are simple additions, and event nodes transmit messages only to a few select representative nodes. Thus the complexity of computation at single network nodes is negligible. Important as a metric of complexity for distributed computations is the overall amount of transmitted messages:

All in all approximately $(e\cdot n_{r})$ messages are transmitted during ring queries (Sect. 3.5): Each node in a query chain transmits one message, two chain ends are sent back per ring component and two messages are sent to zero nodes or detect a cycle per ring component. That makes for a total of $c_{r}\cdot(r_{n}+4)$ messages, where $c_{r}$ denotes the number of ring components and $r_{n}$ represents the average length of a ring component. Not counting the number of zero nodes directly queried by an event node, this number more or less is equal to the number of event node neighbors $n_{r}=|N_{s}|$. Hence, with $e$ events happening during one sample period, ($e\cdot n_{r}$) ring messages are transmitted.

During each sample period of a network approximately $(e\cdot n_{r}\cdot n_{c})$ region update messages (Sect. 4.1) are transmitted in total: Each update node passes one update message to each of its neighbor nodes. Let $n_{c}$ be the number of non-event nodes lying in positive regions in which at least one event happened, $e$ be the number of events, and $n_{r}$ be the average number of neighbors of each node. Then $(e\cdot n_{r}\cdot n_{c})$ update messages are transmitted during one sample period.

When split events occur, update nodes additionally execute ring queries to recompute their components’ numbers, and create split update event messages (Sect. 4.1.4). All affected update nodes start additional region updates with message amounts comparable to regular detected events. In such cases the update message number can increase up to $(e\cdot n_{r}\cdot n_{c})+(e\cdot n_{r}\cdot n_{c}^{2})$, while the number of ring messages can increase up to $(e+(e\cdot n_{c}))\cdot n_{r}$.

The charts in Figure 15 display the amount of transmitted messages during the simulation of a spreading forest fire with TopED. In the lower chart the number of ring and update messages are shown separately, while the upper chart displays the number of sensors lying inside fire regions in relation to the number of different detected regions. The amount of update messages clearly exceeds the number of ring messages; update messages constitute the largest part of in-network communication.

Figure 17 shows the first detected case of merging regions during the simulation, it is at this point where a first visible small increase in update messages becomes visible in Figure 15. Afterwards, the message number steadily increases with growing region sizes. Evidently, the variable $n_{c}$, the average region size, is the deciding factor for the message amount. And Figure 16 highlights the worst case scenario: split updates. All three visible steps in the update message graph are the result of split events occurring.

6 Conclusion

After the definition of Betti numbers and their computation for graphs associated to Whitney triangulations in Section 2, the topological event detection model central to this paper was defined in Section 3. Events are detected locally via homology computations at event nodes. In total nine basic event types are supported. Component numbers necessary for graph homology computation are updated via region updates. The usage of differences for update messages (Sect. 4.1) and the reduction of event regions (Sect. 4.1.5) to single event nodes allows for the conflict-free detection of non-incremental events.

We assumed a simplified communication model with globally synchronized clocks and error-free communication for event detection. This model was used to verify the correct monitoring of topological events in simulation. In practice locally synchronized clocks are used for distributed computations. For application in real-world examples (e.g., in WSNs) the definition of an extended message model dealing with communication errors will be required.

The last section showed that the complexity of topological event monitoring lies in the region update process, split updates in particular cause a great message amount. It was assumed that all update nodes execute ring queries when performing a split update (Sect. 4.1.4). Most of the nodes’ neighbor values are unchanged when compared to the last sample interval of the network. Additional ring queries are unnecessary for these nodes. An extension to the topological event detection model could include event nodes notifying their neighbors of their changed FI-values during ring queries. With this additional bit of information update nodes not only could avoid the execution of additional ring queries during split updates, but also could transmit update messages exclusively to neighbor nodes with FI-values of one.

Section 3.6 introduced the event decision diagram and stated that Betti number differences can be inferred from the neighbor-ring. When neither the components’ network numbers $n_{c},m_{c},f_{c}$ nor their exact Betti numbers are required, the neighbor-ring alone is sufficient for event detection. Ignoring the actual Betti numbers, region updates are then reduced to the spreading of component-IDs after merge/split events, making the component recomputation during the split update (Sect. 4.1.4) superfluous.