On computing distances and latencies in Link Streams

TL;DR

This paper introduces efficient algorithms for computing distances, latencies, and shortest paths in link streams, aiding the analysis of temporal networks and their centrality measures.

Contribution

It presents novel algorithms with correctness proofs and complexity bounds for analyzing link streams, facilitating the computation of centrality metrics.

Findings

Algorithms for shortest paths and latencies are correct and efficient.

Complexity bounds are established based on link stream parameters.

The methods enable better analysis of temporal network centrality.

Abstract

Link Streams were proposed a few years ago as a model of temporal networks. We seek to understand the topological and temporal nature of those objects through efficiently computing the distances, latencies and lengths of shortest fastest paths. We develop different algorithms to compute those values efficiently. Proofs of correctness for those methods are presented as well as bounds on their temporal complexities as functions of link stream parameters. One purpose of this study is to help develop algorithms to compute centrality functions on link streams such as the betweenness centrality and the closeness centrality.

Tables

Table 1. Table 1 : Comparisons between Algorithms 3 and [ 15 ]

Dataset	$\left|V\right|$	$\left|\Omega \right|$	$\left|E_{\Omega }\right|$	Wu et al. (s)	${\mathrm{SSMD}}_{\gamma }$ (s)	ratio
arxiv	28093	2337	4596803	1.30	170.00	130.77
digg	30398	9125	87627	1.60	1.10	0.69
elec	7118	90741	103675	0.71	2.90	4.08
enron	87273	178721	1148072	5.20	85.00	16.35
epinions	755760	501	13668320	41.00	40.00	0.98
facebook	63731	204914	817035	10.00	8.90	0.89
flickr	2302925	134	33140017	120.00	3700.00	30.83
slashdot	51083	67327	140778	4.80	4.30	0.90
wikiconflict	116836	215982	2917785	6.90	21.00	3.04
wiki	1870709	2198	39953145	100.00	22000.00	220.00
youtube	3223585	203	9375374	170.00	160.00	0.94

Table 2. (a) Comparisons between algorithms 1 and 2

$\left|V\right|$	$\left|E_{\Omega }\right|$	SSMD (s)	MSMD (s)
100	6942.40	142.36	11.74
105	7656.40	173.02	13.58
110	8394.00	208.28	15.47
115	9173.60	248.52	17.65
120	10005.60	293.48	20.01
125	10835.60	354.76	22.41
130	11723.20	404.31	25.23
135	12654.00	470.48	28.19
140	13601.60	547.13	31.50
145	14583.20	628.99	34.84
150	15609.20	718.28	38.40
155	16675.20	824.66	42.47
160	17794.80	946.35	46.74
165	18915.20	1107.04	52.12

Equations

$$d((t_s,s),(t_y,y))$$

$$+d((t,u),(t,v))+d((t,v),(t_y,y)).$$

$$d((-s_w,s),(-s_w,u)),\dots ,d((-s_w,s),(t_{\Delta },u))$$

$$d((-s_w,s),(t_{\Delta },w))$$

$$+d((t_{\Delta },x),(t_{\Delta },y))$$

$$+d((t_{\Delta },y),(t_{\Delta },w))$$

$$=\underset{u\in C_v}{\min }d((-s_w,s),(t_{\Delta -1},x))$$

$$+d((t_{\Delta },x),(t_{\Delta },w)).$$

$$d((-s_w,s),(t_{\Delta },w))$$

$$=\underset{x\in C_v}{\min }\underset{y\in U_x}{\min }{d}_y+d^{\prime }[(y,w)]$$

$$=\underset{x\in C_v}{\min }{d}_x+\underset{y\in U_x}{\min }{d}^{\prime }[(y,w)].$$

$$\sum _{C\subseteq V}\sum _{u\in C}O\left(n(n+\omega )\log \omega \right)$$

Full text

A short version of this text is set to be presented at the International Conference on Advances in Social Networks Analysis and Mining (ASONAM ’19), in Vancouver, Canada [11].

1 Introduction

Network science has been greatly influenced in recent years by the notion of temporal networks. Researchers in various fields have observed that real data varies over time and that static networks are insufficient to capture the full extent of some phenomenon. Different models of temporal networks have been suggested, among which the Link Streams of Latapy et al. [7] that captures the network evolution in continuous time. As is the case with other forms of networks, the notions of paths and distances are fundamental to the study of link streams. Kempe et al. [5] mention the use of time-respecting paths to study temporal networks. They further mention applications to epidemiology, in which one would seek information about the spread of a virus in a population. Human interactions can also be analyzed with temporal networks as has been observed by Tang et al. [13] and the link stream framework can help advance those studies. Although online social networks can be thought to vary in discrete time, with tweets and retweets for example, in real social networks the interactions have durations which are important to take into account in order to have an accurate description of the data. To see how link streams can be used in practice, many studies have emerged from the SocioPatterns Collaboration that includes datasets on face-to-face contacts [4, 1] with temporal labels. Those datasets are valuable tools to more accurately investigate aspects of social networks such as homophily [12] and epidemics [8].

Latapy et al. develop the notion of shortest fastest paths in their link stream model as a new concept of paths that gather together the temporal as well as the structural information of a link stream. A shortest fastest path is one that is shortest among the fastest paths between two endpoints. This type of path is used to define a betweenness centrality and it appears other centrality functions could be so defined as well. A social network can thus be analyzed through different perspectives: using the distance to measure how the connectivity of a group varies over time, the latency to measure how quickly an information can spread into a group of people and the length of a shortest fastest path to measure how efficiently this information is relayed. Note also how the time a shortest path starts and ends influences the information it can spread.

We propose here to compute the metrics of shortest (fastest) paths in a link stream with different algorithms. General definitions are presented in section 2, followed by a state of the art on section 3. Then, we present our two main methods in section 4, experiments in section 5 and we conclude in section 6.

2 Background

Most definitions are taken from Latapy et al. [7]. A link stream $L$ is a tuple $L=(T,V,E)$ where $T\subseteq\mathbb{R}$ is a set of time instants, $V$ is a finite set of nodes (vertices) and $E\subseteq T\times V\otimes V$ is a set of links (edges). Here, $V\otimes V$ denotes the set of unordered pairs of vertices and we write $uv\in V\otimes V$. We say an element $(t_{v},v)\in T\times V$ is a temporal vertex.

An edge of $E$ is a tuple $(t,uv)$. Given an interval $I\subseteq T$, we write $(I,uv)\subseteq E$, instead of $I\times\{uv\}\subseteq E$, to mean all edges $(t,uv)$ such that $t\in I$ are in $E$. We say an edge $(I,uv)\subseteq E$ is maximal if there exists no other edge $(J,uv)\subseteq E$ such that $I\subset J$. We say a maximal edge $([a,b],uv)\subseteq E$ starts on $a$, ends on $b$ and has duration $b-a$. We let $\Omega$ be the set of event times of $T$, that is $\Omega:=\{t\in T\,|\,\mathopen{}\exists\mbox{ maximal edge }([t,t^{\prime}],uv)\subseteq E\mbox{ or }([t^{\prime},t],uv)\subseteq E\}$. Elements of $\Omega\times V$ are called event nodes. We write $E_{\Omega}:=\{(t,uv)\in E\,|\,\mathopen{}t\in\Omega\}$.

A maximal edge, as well as $\Omega$ and $\Omega\times V$ are illustrated on the link stream of Figure 1. On this link stream, $([1,2],cb)\subset E$ is a maximal edge, whereas $([1,1.5],cb)\subset E$ is not. Thus, $\Omega=\{0,1,2,3\}$.

The graph $G_{t}$ induced by a time $t\in T$ is defined as $G_{t}=(V,\{uv\,|\,\mathopen{}(t,uv)\in E\})$. In a link stream $L$, a path $P$ from $(\alpha,u)\in T\times V$ to $(\omega,v)\in T\times V$ is a sequence $(t_{0},u_{0},v_{0}),(t_{1},u_{1},v_{1}),\dots,(t_{k},u_{k},v_{k})$ of elements of $T\times V\times V$ such that $u_{0}=u$, $v_{k}=v$, $t_{0}\geq\alpha$, $t_{k}\leq\omega$ and for all $i,t_{i}\leq t_{i+1}$, $v_{i}=u_{i+1}$ and $(t_{i},u_{i}v_{i})\in E$. We say that such a path starts at $t_{0}$, arrives at $t_{k}$, has length $k+1$ and duration $t_{k}-t_{0}$. We write $(\alpha,u)\rightsquigarrow(\omega,v)$ to mean that there exists a path from $(\alpha,u)$ to $(\omega,v)$ and say $(\omega,v)$ is reachable from $(\alpha,u)$. We also call $t_{0}$ a starting time and $t_{k}$ an arrival time from $(\alpha,u)$ to $(\omega,v)$. Each path between two fixed temporal nodes $(\alpha,u)$ and $(\omega,v)$ defines a pair of starting time and associated arrival time. On the link stream of Figure 1, two paths are illustrated: the green one $P_{1}=(0,d,c),(1,c,b),(3,b,a)$ and the red one $P_{2}=(0,d,c),(2,c,b),(3,b,a)$. Both have the same starting and arrival times from $(0,d)$ to $(3,a)$, namely times [math] and $3$. Both paths are fastest. We can also say $s$ is a starting time from a temporal node $(\alpha,u)\in T\times V$ to a node $v\in V$, in which case there exists some time $t\in T$ such that $s$ is the starting time of a path from $(\alpha,u)$ to $(t,v)$. Same goes for the arrival times.

We say a path $P$ is shortest if it has minimal length and call its length the distance from $(\alpha,u)$ to $(\omega,v)$, written $\mathit{d}((\alpha,u),(\omega,v))$. Similarly, $P$ is fastest if it has minimal duration, in which case this duration is called the latency from $(\alpha,u)$ to $(\omega,v)$ and is written $\mathit{l}\left((\alpha,u),(\omega,v)\right)$. Note that if $(\alpha,u)\rightsquigarrow(\omega,v)$, there exists at least one pair of starting time and arrival time $(s,a)\in\mathcal{T}_{(\alpha,u)(\omega,v)}$ such that $\mathit{l}\left((\alpha,u),(\omega,v)\right)=a-s$. Finally, $P$ is called shortest fastest if it has minimal length among the set of fastest paths from $(\alpha,u)$ to $(\omega,v)$. We call its length the sf-metric from $(\alpha,u)$ to $(\omega,v)$ and write it $\mathit{d_{f}}\left((\alpha,u),(\omega,v)\right)$. In general, this is not a distance as it does not respect the triangular inequality and is only a premetric, a simple counterexample is shown on Figure 2. On the same figure are drawn a shortest path, two fastest paths and a unique shortest fastest path.

3 Related work

This work is close to the study of Wu et al. [15]. As such, the applications of computing fastest and shortest paths mentioned by these authors also apply here. The main contribution of the present work is to compute *sf-*metrics, as well as distances and latencies, in a single pass over a dataset. Separately, Wu et al.’s fastest and shortest paths methods are insufficient to compute centralities such the betweenness of Latapy et al., while an algorithm combining them to produce *sf-*metrics is not efficient because it requires iterating multiple times over the dataset. Meanwhile, our methods iterate only once to produce the three metrics and are suitable for studying different aspects of a link stream. We also output information on the starting and arrival times of shortest (fastest) paths that give valuable information on connectivity. This study was instigated as a first step in computing Latapy et al.’s betweenness centrality.

Furthermore, this work is also close to Tang et al. [14] since these authors define a betweenness centrality on temporal networks in terms of fastest shortest paths. Whether to use fastest shortest or shortest fastest paths (or any other path that combines temporal and structural information) depends on what information one wants to emphasize which depends on the context of the study. Shortest and fastest paths were also studied by Xuan et al. [16] and we were inspired by their all-pairs fastest path method to develop Algorithm 2. The latter is relevant to compute some centralities because metrics between all pairs of (temporal) nodes may be required. To our knowledge, Xuan et al.’s method is the only of its kind to return latencies between all pairs of nodes. More recently, Casteigts et al. [2]. adopted the same strategies as Xuan et al. for computing shortest and fastest paths in a distributed way.

Casteigts et al. [3] also offer a survey of temporal networks that includes many applications of shortest and fastest paths. In particular, such paths can be used to study the reachability of a temporal node from another. It appears from that survey that either the distance or the latency is often used as a temporal metric to evaluate how well a temporal node can communicate with another. In this regard, the *sf-*metric can be used as another temporal function since it combines the temporal as well as the structural information into a single map. Note that the notion of foremost paths (or journeys) is also used by some authors [2] to study temporal reachability. A foremost path only has minimal arrival time, while its starting time is unconstrained. This type of path is also useful in many studies and we expect our algorithms can be extended to those cases to output lengths of shortest foremost paths.

Finally, observe that the link stream framework is also close to the Time-Varying Graphs framework [3]. Thus, all results presented in this paper carry to this other framework as well.

4 Multiple-targets shortest fastest paths algorithms

The full implementations of the algorithms presented here, in C++, can be found online [10].

We present here two main methods, Algorithms 1 and 2 that compute the distances, latencies and *sf-*metrics from one source event node to all other event nodes. Algorithm 2 builds on the first method to compute those values for all pairs of event nodes. Subsection 4.4 also presents Algorithm 3 that was derived from Algorithm 1. This last method was first devised to fairly compare Algorithm 1 against the literature, but is also interesting as a standalone algorithm. We focus on the first two algorithms.

We present some small results that lead the way to those algorithms. The strategy for both methods is essentially the same: we compute the distances from any temporal node $(s_{v},u)$ to $(t_{v},v)$ such that $s_{v}$ is the largest (or maximal) starting time from any $(t_{u},u)$ to $(t_{v},v)$. If it happens that $t_{v}-s_{v}=\mathit{l}\left((s_{v},u),(t_{v},v)\right)$, then this distance is the *sf-*metric from the former to the latter temporal node. Otherwise, since we iterate chronologically over $\Omega$, this latency must have been computed at a time earlier than $t_{v}$ and is saved in memory.

4.1 Two simple lemmas

The algorithms we present compute what we call reachability triples that contain information about the lengths of shortest paths from one temporal node to another as well as the starting and arrival times of those paths.

Definition 4.1** (Reachability triples).**

Let $(t_{s},s)$ be an event node. If there exists a shortest path of length $l$ from $(t_{s},s)$ to the event node $(t_{y},y)$ that starts on a largest starting time $t\in\Omega$, then we say $(t,t_{y},l)$ is a reachability triple from $(t_{s},s)$ to $y$.

In the following, we write $\mathrm{R}_{v}$ for the dictionary of reachability triples from a fixed source event node to any node $v$. In order to reduce to cost of operations in $\mathrm{R}_{v}$, we assume this dictionary is implemented in such a way that $\mathrm{R}_{v}$ holds keys $s_{v}$ and $\mathrm{R}_{v}[s_{v}]$ holds pairs $(a_{v},d_{v})$ that form reachability triples $(s_{v},a_{v},d_{v})$. We write this dictionary so that accessing each $R_{v}$ takes constant time.

Algorithms 1 and 2 compute distances from largest starting times only. Those distances are contained in dictionaries $\mathrm{R}_{v}$ for each $v\in V$ as part of reachability triples. Note that if a link stream reduces to a network, that is if the set of time instants $T$ is a singleton, then each $R_{v}$ will contain the usual distances from a fixed source to $v$. The temporal nature of a link stream forces us to take starting and arrival times into account when looking for shortest paths. Moreover, reachability triples could also be defined without the constraint that starting times are largest, however the algorithms would not be as efficient because the dictionaries would grow larger.

4.2 below, due to Wu et al. [15], states that shortest paths are prefix-shortest. We say a path $P_{(t_{s},s)(t_{u},u)}$ from a temporal node $(t_{s},s)$ to another temporal node $(t_{u},u)$ is a prefix of another path $P_{(t_{s},s)(t_{v},v)}$ from the same source to temporal node $(t_{v},v)$ if $P_{(t_{s},s)(t_{u},u)}$ is a subsequence of $P_{(t_{s},s)(t_{v},v)}$.

Lemma 4.2**.**

Let $P_{(t_{s},s)(t_{v},v)}$ be a shortest path from a temporal node $(t_{s},s)$ to another $(t_{v},v)$. Then, every prefix $P_{(t_{s},s)(t_{u},u)}$ of $P_{(t_{s},s)(t_{v},v)}$ is a shortest path from $(t_{s},s)$ to $(t_{u},u)$.

Proof.

Suppose otherwise and assume there exists a temporal node $(t_{u},u)$ such that the prefix $P_{(t_{s},s)(t_{u},u)}$ of $P_{(t_{s},s)(t_{v},v)}$ is not shortest from $(t_{s},s)$ to $(t_{u},u)$. Then, there exists a shorter path from $(t_{s},s)$ to $(t_{u},u)$, $Q_{(t_{s},s)(t_{u},u)}$. Since $t_{s}\leq t_{u}\leq t_{v}$, we can use $Q_{(t_{s},s)(t_{u},u)}$ to form a shorter path to $(t_{v},v)$, contradicting the minimality of $P_{(t_{s},s)(t_{v},v)}$. ∎

Let $(t_{s},s)$ and $(t,v)$ be two temporal nodes. Then we define the outer distance from $(t_{s},s)$ to $(t,v)$, $\mathit{d}((t_{s},s),(t^{-},v))$, as either $\lim_{t_{0}\to t^{-}}\mathit{d}((t_{s},s),(t_{0},v))$, when $t>t_{s}$, or $\mathit{d}((t_{s},s),(t,v))$, when $t_{s}=t$. 4.3 suggests it suffices to compute distances in induced graphs $G_{t}$ for any time $t$ to deduce the distances between two temporal nodes.

Lemma 4.3**.**

Let $(t_{s},s)$ be a source temporal node and $(t_{y},y)$ be a temporal node reachable from the source by a non-empty shortest path. Then, there exists $t_{s}\leq t\leq t_{y}$ and a connected component $C$ of $G_{t}$ such that

[TABLE]

Proof.

Let $P=(t_{1},u_{1},u_{2}),\dots,(t_{n},u_{n},u_{n+1})$ be a non-empty shortest path from $(t_{s},s)$ to $(t_{y},y)$. Then, $t_{y}\geq t_{n}\geq t_{1}\geq t_{s}$ and $u_{1}=s,u_{n+1}=y$. There exist non-empty subpaths in $P$ of the form $(t_{j},u_{j},u_{j+1}),\dots,(t_{j},u_{k},u_{k+1})$. Let $Q=(t_{j},u_{j},u_{j+1}),\dots,(t_{j},u_{k},u_{k+1})$ be such a subpath with the largest number of elements. By Lemma 4.2, the prefix of $P$ from $(t_{s},s)$ to $(t_{j}^{-},u_{j})$ is shortest and its length is $\mathit{d}((t_{s},s),(t_{j}^{-},u_{j}))$. Moreover, the subpath of $P$ from $(t_{j},u_{k+1})$ to $(t_{y},y)$ must also be shortest with length $\mathit{d}((t_{j},u_{k+1}),(t_{y},y))$. Finally, since $P$ is shortest and the two subpaths formed by $P\setminus Q$ are shortest, $Q$ must also be a shortest path. Then, $Q$ has length $\mathit{d}((t_{j},u_{j}),(t_{j},u_{k+1}))$. The result follows by letting $t=t_{j}$ and $C=\{u_{j},u_{j+1},\dots,u_{k+1}\}$ be a connected component of $G_{t}$. ∎

4.2 A single-source method

In this section, we present Algorithm 1 that computes the distances (from largest starting times), latencies and *sf-*metrics from a source event node $(t_{s},s)$ to all other reachable event nodes. This algorithm mixes iterations on the induced graphs $G_{t}$ for each time $t\in\Omega$ with an all-pairs distances method on their connected components. Recall that if $s^{*}$ is the largest starting time from the source $(t_{s},s)$ to some temporal node $(t,v)$, then either $t-s^{*}=\mathit{l}\left((t_{s},s),(t,v)\right)$ or not. If so, then $\mathit{d}((t_{s},s),(t,v))$ is the *sf-*metric from $(t_{s},s)$ to $(t,v)$. This length is computed with 4.3 by using the outer distances saved in memory as well as the all-pairs distance method on $G_{t}$. Thus, when we iterate over all pairs $(s_{v},d_{v})$ of starting time and outer distance from the source to $(t,v)$, we can deduce the duration and length of the shortest fastest paths from the source to $(t,v)$. This method uses a set $D$ that is assumed sorted in lexicographic order. Sorting $D$ helps lower the temporal complexity, but is not fundamental to understand the algorithm.

Remark 4.4**.**

In Algorithms 1 and 2, we assumed the dictionaries were implemented in the form of self-balanced binary trees in order to obtain logarithmic worst-case complexities. In our implementations, we used hash tables to lower the average-case complexity.

Before proving that Algorithm 1 is correct, let us go through a small example in order to build intuition. Algorithms 2 and 3 are highly similar.

Example 4.5**.**

Consider again the link stream of Figure 2. Suppose the source is again $(1,g)$, $t=7$ and $C=\{a,b,c\}$. Thus, Algorithm 1 will look for shortest (fastest) paths that can reach temporal nodes $(7,a),(7,b)$ and $(7,c)$. The unique largest starting time from the source to $C$ at time $7$ is $s_{v}=4$. This time is given by the greatest key in $\mathrm{R}_{u}$ for any $u\in C$. Then, we iterate over the outer distances from $(4,g)$ to $(7,v)$ for each $v\in C$. Note how the time of the source has changed from $1$ to $4$. By definition, and since the link stream is discrete, outer distances are given as the distances from $(4,g)$ to $(6,v)$ for each $v\in C$. Thus, we find outer distances $2$ from $(4,g)$ to $(7,c)$ and $3$ from $(4,g)$ to $(7,b)$. Node $a$ is discovered at time $7$ and its outer distance does not exist before that. Finally, combining the outer distances with the distances inside the graph induced by $C$ at time $7$, we find the distance from $(4,g)$ to $(7,c)$ is $2$, $3$ from $(4,g)$ to $(7,b)$ and also $3$ from $(4,g)$ to $(7,a)$. This last distance is given by the combination between the outer distance from $(4,g)$ to $(7,c)$ and the distance in $C$ from $(7,c)$ to $(7,a)$. Since node $a$ is discovered first at time $7$, that is its first arrival time from $(1,g)$ is $7$, then the latency from $(1,g)$ to $(7,a)$ is $\mathit{l}\left((1,g),(7,a)\right)=7-4=3$ and the distance from $(1,g)$ to $(7,a)$ is the sf-metric from the former to the latter.

Proposition 4.6**.**

Algorithm 1 correctly computes the latencies and sf-metrics from a source event node to all other reachable event nodes as well as the set of dictionaries $\{\mathrm{R}_{v}\,|\,\mathopen{}v\in V\}$. It requires at most $\mathop{}\!O{\left(\lvert V\rvert^{2}\lvert\Omega\rvert^{2}\log{\lvert\Omega\rvert}+\lvert V\rvert\lvert E_{\Omega}\rvert\right)}$ operations in the worst case.

Proof of correctness.

Let $(t_{v},v)\in\Omega\times V$ be some reachable destination. Let’s show by induction on $\Delta:=\lvert\{t_{0}\in\Omega\,|\,\mathopen{}t_{v}\geq t_{0}\geq t_{s}\}\rvert$ that $d[(t_{v},v)]=\mathit{d_{f}}\left((t_{s},s),(t_{v},v)\right)$, $f[(t_{v},v)]=\mathit{l}\left((t_{s},s),(t_{v},v)\right)$ and $\mathrm{R}_{v}$ is correct up to time $t_{v}$.

• •

When $\Delta=1$, we iterate only on time $t_{s}$ and the result is clear.

• •

Suppose the result holds for all $k<\Delta$. Let $(t_{1},\dots,t_{\Delta-1})$ be the times previously iterated over on line 1 and $t_{\Delta}$ the current time. By the induction hypothesis, by time $t_{\Delta-1}$, all values of $\mathrm{R}_{w}$, for all $w\in V$, are correctly updated. Let $C_{v}$ be the connected component of $G_{t_{\Delta}}$ containing $v$. If $s\in C_{v}$, then the result follows as in the case with $\Delta=1$. Then, suppose $s\notin C_{v}$. Since each $\mathrm{R}_{v}$ is correctly updated up to time $t_{\Delta-1}$ for each reachable $v\in V$, $D$ contains triples $(-s_{w},d_{w},w)$ for each $w\in C_{v}$ that have been visited prior to $t_{\Delta-1}$ from the source from a starting time $s_{w}$. The set $D$ contains the largest starting time $s_{w}$ from the source to $(t_{\Delta},w)$. Then, either $t_{\Delta}+s_{w}=\mathit{l}\left((t_{s},s),(t_{\Delta},w)\right)$ or this latency is given by some $f[(t_{0},w)]$ such that $t_{0}<t_{\Delta}$. Let’s iterate on $(-s_{w},d_{w},w)$.

By Lemma 4.3, there exists a time $-s_{w}\leq t_{i}\leq t_{\Delta}$ and a connected component $C_{i}$ of $G_{t_{i}}$ such that $\mathit{d}((-s_{w},s),(t_{\Delta},w))=\min_{x,y\in C_{i}}\mathit{d}((-s_{w},s),(t_{i}^{-},x))+\mathit{d}((t_{i},x),(t_{i},y))$ $+\mathit{d}((t_{i},y),(t_{\Delta},w))$. The sequence of distances

[TABLE]

is non-increasing for each $u\in V$ because each element is minimal. Thus, since $w\in C_{v}$, in particular this lemma holds with $t_{i}=t_{\Delta}$ and $C_{i}=C_{v}$. Then,

[TABLE]

By the induction hypothesis, the outer distance $d_{x}=\mathit{d}((-s_{w},s),(t_{\Delta-1},x))$ can be recovered from $(-s_{w},t_{\Delta-1},d_{x})\in\mathrm{R}_{x}$ for each $x\in C_{v}$. Then, using $d_{x}$ and the dictionary $d^{\prime}$ returned by the all-pairs distances algorithm on line 1, the expression above reduces to $\mathit{d}((-s_{w},s),(t_{\Delta},w))=\min_{x\in C_{v}}d_{x}+d^{\prime}[(x,w)]$. In the last equation, the intermediary node $x\in C_{v}$ over which the minimum is taken is irrelevant. If $y\in U_{x}$, then the distance from the source to $y$ is the same as the distance from the source to $x$. Thus, it holds that:

[TABLE]

Thus, when we iterate on the element $(-s_{w},d_{w},w)$ from $D$, we construct the set $U_{w}$ of nodes at distance $d_{w}$ from $(-s_{w},s)$ at time $t_{\Delta}$. The last equation is thus used to insert into $\mathrm{R}_{w}$ the right triple $(-s_{w},t_{\Delta},\mathit{d}((-s_{w},s),(t_{\Delta},w)))$ for each $w\in C_{v}$. When we have iterated over all of $D$, all dictionaries $\mathrm{R}_{v}$ are correct at time $t_{\Delta}$. Finally, it suffices to observe that once $f[(t_{\Delta},w)]$ is updated with its final value, then by definition the update of $d[(t_{\Delta},w)]$ on algorithm 1 yields the *sf-*metric from $(t_{s},s)$ to $(t_{\Delta},w)$ for each $w$.

∎

Proof of complexity.

Let us write $n:=\lvert V\rvert,m_{t}:=\lvert E_{t}\rvert$ and $\omega:=\lvert\Omega\rvert$. On each time $t\in\{t_{0}\in\Omega\,|\,\mathopen{}t_{0}\geq t_{s}\}$, we first look up the connected components of $G_{t}$, which requires at most $\mathop{}\!O{\left(n+m_{t}\right)}$ operations. On each component $C$ of $G_{t}$, we run an all-pairs distances method, which makes at most $\mathop{}\!O{\left(n^{2}+nm_{t}\right)}$ operations. For each node $v\in V$, the list in $\mathrm{R}_{v}[-s_{u}]$ contains at most $\omega$ elements since there can be at most as many pairs in $\mathrm{R}_{v}[-s_{u}]$ as there are arrival times on $v$. The same goes for the number of keys $s_{v}$ in $\mathrm{R}_{v}$.

There are at most $\omega$ times $a_{v}$ such that $(s_{v},a_{v},d_{v})\in\mathrm{R}_{v}$ and thus $D$ can be constructed with at most $\mathop{}\!O{\left(n\omega\right)}$ operations for all $v\in C$. Inserting and removing an element from $\mathrm{R}_{v}[-s_{u}]$ takes at most $\mathop{}\!O{\left(1+\log\omega+\log\omega\right)}$ operations: $\mathop{}\!O{\left(1\right)}$ operation for accessing $R_{w}$, $\mathop{}\!O{\left(\log\omega\right)}$ operations for accessing key $-s_{u}$ and $\mathop{}\!O{\left(\log\omega\right)}$ operations to insert or remove an item in a set of size at most $\omega$. The costliest operations on the connected component $C$ are those insertions and deletions. Thus, operating over $C$ takes at most $\mathop{}\!O{\left(n\log\omega\right)}$ operations. The list $D$ contains at most $\mathop{}\!O{\left(n\omega\right)}$ triples since for each node $v\in V$, it holds a largest starting time and at most $\omega$ distances (one distance for each arrival time on $v$). Thus, the for loop over $D$ will make at most $\mathop{}\!O{\left(n^{2}\omega\log\omega\right)}$ operations.

The total number of operations at any time $t\in\Omega$ is bounded above by $\mathop{}\!O{\left(n^{2}\omega\log\omega\right)}+\mathop{}\!O{\left(n^{2}+nm_{t}\right)}$. It suffices to multiply this sum by $\mathop{}\!O{\left(\omega\right)}$ and use the observation that $\sum_{t\in\Omega}m_{t}=\lvert E_{\Omega}\rvert$. ∎

Observe that we use the sets $V,E_{\Omega}$ and $\Omega$ as parameters to evaluate the temporal complexities of our algorithms. These appear as natural choices since $\Omega$ indicates how the temporal dimension affects the number of operations while $E_{\Omega}$ is a surrogate for $E$, which is in general infinite.

4.3 A multiple-sources *sf-*metrics method

Suppose $\Omega$ is finite and starts on some time $a$. Algorithm 2 returns a set of dictionaries of *sf-*metrics $D_{uv}$ for each pair of nodes $(u,v)\in V^{2}$ of dictionary $D_{uv}[s_{uv}]=(a_{uv},d_{uv})$ such that $\mathit{l}\left((s_{uv},u),(a_{uv},v)\right)=a_{uv}-s_{uv}$ and $\mathit{d}((s_{uv},u),(a_{uv},v))=d_{uv}$. During its execution, it updates a dictionary $D^{0}$ such that $D_{uv}[t]=(a_{uv},d_{uv})$, $t\in\mathrm{R}_{v}$ and $(a_{uv},d_{uv})\in\mathrm{R}_{v}[t]$ from $(a,u)\in T\times V$. This dictionary helps in computing $D$ and in constructing $\mathrm{R}_{v}$ from any source. It also returns a set of dictionaries $F_{uv}$ of latencies.

Proposition 4.7**.**

Algorithm 2 returns the latencies, sf-metrics and dictionaries $\mathrm{R}_{v}$ between all pairs of nodes in at most $\mathop{}\!O{\left(\lvert\Omega\rvert\lvert V\rvert^{2}\left(\lvert V\rvert+\lvert\Omega\rvert\right)\log{\lvert\Omega\rvert}+\lvert V\rvert\lvert E_{\Omega}\rvert\right)}$ operations.

Proof of correctness.

Let us show that $D^{0}[u,v][t_{v}]$ holds correct reachability triples from $(a,u)$ to $(t_{v},v)$ for any two nodes $u$, $v$ and time $t_{v}$. Thus, let us fix those three variables. Let us show this by induction on $\Delta:=\lvert\{t\in\Omega\,|\,\mathopen{}a\leq t\leq t_{v}\}\rvert$.

• •

If $\Delta=1$, then either $u$ and $v$ are in the same connected component $C$ of $G_{t_{v}}$ or not. This part is clear.

• •

Suppose the result holds for any $k<\Delta$. Let $(t_{1},\dots,t_{\Delta-1})$ be the sequence of times previously iterated over. Let $C_{v}$ be the connected component containing $v$ at time $t_{\Delta}$. If $u\in C_{v}$, then we argue as in the first case and the result follows. Otherwise, by the induction hypothesis, there must exist a largest starting time $s_{v}$ from $u$ to $(t_{\Delta},v)$ that can be found in $SA[u,w][t_{\Delta-1}]$, for some $w\in C_{v}$ since all such node $w$ is connected to $v$. Observe that $SA[u,v][t_{\Delta-1}]$ contains pairs of largest starting time and arrival time from $u$ to $(t_{\Delta-1},v)$. Observe also that $t_{\Delta}$ is again an arrival time on $v$. Thus, it suffices to compute the distance from $(s_{v},u)$ to $(t_{\Delta},v)$ to obtain a reachability triple $(s_{v},t_{\Delta},d_{v})$ from $(a,u)$ to $v$. We argue as in the proof of Algorithm 1 that Algorithm 2 returns this distance $d_{v}$. The update $D[u,v][t_{\Delta}][s^{*}]\leftarrow d^{*}$ again follows the same reasoning as before.

∎

Proof of complexity.

Again, let $n:=\lvert V\rvert,m_{t}:=\lvert E_{t}\rvert$ and $\omega:=\lvert\Omega\rvert$. The costliest operations occur in the for loop starting on algorithm 2. There are at most $\omega$ keys on each $SA_{uv}$, for any $u,v\in V$. For any $t\in\Omega$ and $u,v\in V$, the size of $SA_{uv}[t]$ is upper-bounded by $\omega$ since the starting time is maximal. Thus, at most $\mathop{}\!O{\left(1+\log\omega+\log\omega\right)}\subseteq\mathop{}\!O{\left(\log\omega\right)}$ operations are required. Finding the largest starting time $s_{v}$ requires in the worst case $\mathop{}\!O{\left(n\log\omega\right)}$ operations. By the same reasoning, the insertion on algorithm 2 will make at most $\mathop{}\!O{\left(\omega\log\omega\right)}$ operations.

$D^{0}_{uv}[t]$, for any $u,v\in V$ and $t\in\Omega$, has a size at most $\omega^{2}$, thus the loop over $C$ to find $d_{\min}$ requires at most $\mathop{}\!O{\left(n\log\omega\right)}$ operations.

Recovering the last element of $D^{0}_{uv}[t]$ takes at most $\mathop{}\!O{\left(\log\omega\right)}$ operations, thus the loop on $C_{v}$ makes at most $\mathop{}\!O{\left(\lvert C_{v}\rvert\log{\omega}\right)}$ operations. Meanwhile, inserting into $SA_{uv}[t]$ takes at most $\mathop{}\!O{\left(\omega\log{\omega}\right)}$ operations. The for loop on algorithm 2 thus makes at most:

[TABLE]

operations. This loop is itself repeated for all connected components $C\subseteq V(G_{t})$, which in turn yields:

[TABLE]

operations. Thus, this method should make at most $\mathop{}\!O{\left(n^{2}+nm_{t}\right)}+\mathop{}\!O{\left(n^{2}(n+\omega)\log{\omega}\right)}$ operations in the worst case on each time $t$. This number of operations is repeated at most $\omega$ times and the result follows. ∎

Observe that Algorithm 1 needs only be called $\lvert V\rvert$ times in order to deduce the lengths of all shortest fastest paths from any source to any destination, since it discovers all starting times from each source. Thus, about $\mathop{}\!O{\left(\lvert\Omega\rvert^{2}\lvert V\rvert^{3}\log\lvert\Omega\rvert+\lvert V\rvert^{2}\lvert E_{\Omega}\rvert\right)}$ operations are required for Algorithm 1 to produce the same output as Algorithm 2. The multiple-sources algorithm is thus faster when the desired output is the set of *sf-*metrics from all sources to all destinations. The temporal complexities of both methods are affected mostly by the induced graphs $G_{t}$. In subsection 4.4, we will see that complexities decrease drastically on cases such as $\gamma$-paths with $\gamma>0$ since we can remove the dependency on those induced graphs.

4.4 Shortest paths with delays

In subsection 5.1, we want to compare Algorithm 1 against the shortest path procedure of Wu et al. [15] on the same datasets they used. The shortest path procedure of these authors is the most efficient method known to return distances in temporal networks. However, this algorithm works only on paths with delays $\gamma>0$, that is $\gamma$-paths.

A $\gamma$-path in a link stream is a path $(t_{1},u_{1},u_{2}),\dots,(t_{n},u_{n},u_{n+1})$ such that $t_{i}\geq t_{i-1}+\gamma$ for all $1<i\leq n$ and some $\gamma\in\mathbb{R}_{+}$. We call $\gamma$ the delay and note that the usual path corresponds to a [math]-path. When $\gamma>0$, it is not necessary to iterate over connected components, since all nodes of a component do not communicate, and we can simplify Algorithm 1 in order to reduce its number of operations. The complexities of algorithms 1 and 2 are mainly influenced by the operations related to the graphs $G_{t}$, for each time $t$, namely: finding connected components, computing the all-pairs distances and iterating on the set of nodes at equal distances in the connected component. When $\gamma>0$, we can remove the dependency on the induced graphs $G_{t}$ and accelerate our methods. Thus, we present Algorithm 3 that is deduced from Algorithm 1 and assumes $\gamma>0$. Its correctness and temporal complexity follow from the same arguments used in 4.6.

Proposition 4.8**.**

When $\gamma>0$, Algorithm 3 computes the latencies and sf-metrics from a source event node to all reachable event nodes as well as the set of dictionaries $\mathrm{R}_{v}$, for all $v\in V$, in at most $\mathop{}\!O{\left(\lvert V\rvert+\lvert E_{\Omega}\rvert\log\lvert\Omega\rvert\right)}$ operations.

Proof.

This follows from the same reasoning as in 4.6. ∎

Finally, in Algorithm 3, the dictionaries $d$ and $f$ are implemented such that the keys are nodes and values are pairs $(t,k)$ such that $t$ is the time value $k$ is computed at that node. For example, if $(t,f_{v})\in f[v]$, then the latency from the source to $(t,v)$ is $f_{v}$. This enables us to sort dictionaries by time. The same work could be done for Algorithm 2, that is to adapt it for the case $\gamma>0$, although that was not the focus here.

5 Experiments

We present some experiments to highlight the running times of Algorithms 1 and 2. In the first one, we compare Algorithm 3 with the single-source shortest path method from Wu et al. [15]. Algorithm 3 acts as a surrogate for Algorithm 1. Although Algorithm 2 should be more efficient than Algorithm 1 when the goal is to compute values between all pairs of temporal nodes, Wu et al. evaluated their method from a small set of source nodes on large datasets. It would be infeasible at this point to evaluate both our methods on the same datasets between all pairs of temporal nodes. In a second experiment, we compared the running times of our two methods on synthetic link streams.

Algorithm 2 was inspired by Xuan et al.’s fastest paths method that does not return distances. Comparing the two methods would be unfair against ours.

All experiments were run on a single machine with $2.6$ GHz Intel Core i7 processor and $16$ Gb of RAM. All methods were implemented in C++ with standard libraries, including Wu et al.’s method. We implemented standard approaches to compute connected components and all pairs distances in graphs.

5.1 Runtime comparison with the literature

We presented Algorithm 3 in subsection 4.4 that was motivated by a similar method developed by Wu et al. [15]. We now compare how Algorithm 3 fares against their algorithm. Since we are not aware of methods comparable to Algorithms 1 and 2, this is our comparison with the literature.

Wu et al. analyzed their method with the framework of temporal graphs and deduce a temporal complexity that is hard to compare with ours. We translate their result with link stream parameters, upper bounding $M$ with $\lvert E_{\Omega}\rvert$ and $d_{\max}$ with $\lvert\Omega\rvert$. Thus, the shortest path algorithm of Wu et al. makes at most $\mathop{}\!O{\left(\lvert V\rvert+\lvert E_{\Omega}\rvert\log\lvert\Omega\rvert\right)}$ operations in the worst case. The worst-case temporal complexities of both algorithms are thus the same.

We ran experiments on link streams of various sizes, as measured with $\lvert V\rvert$, $\lvert\Omega\rvert$ and $\lvert E_{\Omega}\rvert$. We used the same datasets as Wu et al.111 The datasets are only used as benchmarks. They all describe discrete temporal networks and can be found as part of the KONECT library of networks [6]. Only the values of the parameters $\lvert V\rvert,\lvert\Omega\rvert$ and $\lvert E_{\Omega}\rvert$ were extracted since only these were required for our experiments. , randomly chose $100$ different nodes from each and ran both methods one after the other. The full results (in seconds) can be found in Table 1. The running times of Wu et al.’s method are either comparable or significantly less than that of Algorithm 3. However, our method does more operations, since it must compute latencies as well and ensure the distances correspond to the *sf-*metrics. Thus, the running times of Wu et al.’s procedure are presented for reference only, it should not be expected that our methods would be faster. All datasets are heterogenous, which explains the variability in running times and we have not yet pinpointed any hidden link stream parameter that might explain this variability. The dictionaries $\mathrm{R}_{v}$ are sensitive to the number of arrival times from the source and we suspect that in the problematic datasets some nodes must have a really high number of arrival times. This would make it more difficult to search values in some dictionary $\mathrm{R}_{v}$.

5.2 Comparison between algorithms 1 and 2

Algorithm 1 and 2 were run on a set of randomly generated link streams of size $\lvert V\rvert$ ranging from $100$ to $165$, with increments of $5$, and repeated $5$ times. Although the link streams are small in scale, the running times are significant since we compute the distances from every source to every destination. The link streams were constructed by generating Erdös-Renyi graphs $G(n,p)$, with $n=\lvert V\rvert$ and $p=0.7$. Then, on each edge $(u,v)$, we drew a time instant $t\in\{0,1,\dots,7\}$ uniformly at random and added both directed edges $(t,u,v)$ and $(t,v,u)$ to $E$. In this case, edges have no duration and the time instants are integers: this helps ensure the size of $\Omega$ is fixed and small, so the running times scale only with $\lvert V\rvert$.

Figure 3 presents the results of this comparison. We observe that, as the number of nodes involved increases, the amount of time taken by Algorithm 1 grows faster than that of Algorithm 2. This gives clear indication that this method is faster than Algorithm 1. 4(a) shows the mean running times (over all repetitions of the same experiment) of each algorithms on a link stream with a fixed number of nodes. In terms of scale, the MSMD method manages a link stream of $160$ nodes and about $18000$ edges (the size of $E_{\Omega}$ is an average over all repetitions) in, on average, less than $50$ seconds. Its counterpart takes more than $15$ minutes for the same calculations.

Since Algorithm 2 is more scalable than Algorithm 1, we generated a new set of link streams, again with the same process as before, although the time instants are now drawn uniformly at random in the interval $[0,10]$ while the duration of an edge $(t,uv)$ is drawn uniformly at random in the interval $[0,10-t]$. Since $\Omega$ grows on each generation, we kept $\lvert V\rvert$ lower than in the former experiment and let $\lvert V\rvert\in\{10,12,\dots,68,70\}$. The results are presented in the upper part of 4(b), above the horizontal line with $\lvert V\rvert$ up to $70$. We fitted, with the statistical software $\mathrm{R}$ [9], a linear model on the runtime of Algorithm 2 as function of both $\lvert V\rvert$ and $\lvert\Omega\rvert$ in order to extrapolate the runtime of this method for larger values of $\lvert V\rvert$ and $\lvert\Omega\rvert$. The fit is reasonable but imperfect, although this is sufficient to illustrate the scaling trend. Extrapolating, we obtain the values below the horizontal line. We observe that with around $190$ nodes and $12000$ event times, Algorithm 2 should already take more than a day to finish. This suggests scalability might be an issue as we could not tackle a real-world dataset even with this long amount of time.

6 Conclusion

In this paper, we presented three algorithms to compute metrics between pairs of event nodes. As opposed to similar known algorithms, those methods return all metrics at once in a single pass over the dataset. Moreover, the starting and arrival times of (some) shortest paths are returned, which is valuable information to compute, for example, the betweenness centrality of temporal nodes.

Algorithm 1 works from a fixed source and is suitable when not all pairwise functions are required. Our experiments show that Algorithm 3, and by extension Algorithm 1, is in general slower than the state of the art method to compute distances from a source node to all other nodes. However this is expected as it has to make more operations and work with bigger data structures. We did note some odd behaviour when comparing this method with the literature in that the ratio of running times between our method and Wu et al.’s method does not vary smoothly with known quantities. This should be inspected further if we would like to speed up the computation time of this method. Nevertheless, the focus of this study was to compute all metrics at once most efficiently, not to beat the state of the art distance method.

In practice, Algorithm 2 has proved to finish its task faster than its counterpart on synthetic link streams. Since the link streams used were smaller than what we would expect from real-world instances, we extrapolated the running times produced by Algorithm 2. At this point, scalability is an issue and we could not expect to run this method on realistic link streams and obtain results in a reasonable amount the time. Thus, in order to speed up the computation time, we suggest studying how to lessen the amount of operations in either methods by skipping some temporal nodes and extrapolating the distances. Also, finding ways not to have to recompute the connected components and the all-pairs distances at every time would also be helpful in improving both methods.

We believe the methods can be easily modified to compute other types of paths combining temporal and structural information, such as shortest foremost paths. In turn, those paths can be used to compute other centralities than the betweenness centrality or to investigate different topics such as reachability.