Temporal Matching

TL;DR

This paper introduces the concept of temporal matching in link streams, proves its computational hardness, and provides practical algorithms with real-world and simulated data evaluations.

Contribution

It defines temporal matching, proves NP-hardness for b3>1, and offers kernelization and approximation algorithms with open-source implementations.

Findings

Maximum temporal matching computation is NP-hard for b3>1.

The 2-approximation algorithm performs well on real and simulated data.

Kernelization reduces problem size effectively in practical scenarios.

Abstract

A link stream is a sequence of pairs of the form $(t,\{u,v\})$, where $t\in\mathbb N$ represents a time instant and $u\neq v$. Given an integer $\gamma$, the $\gamma$-edge between vertices $u$ and $v$, starting at time $t$, is the set of temporally consecutive edges defined by $\{(t',\{u,v\}) | t' \in [t,t+\gamma-1]\}$. We introduce the notion of temporal matching of a link stream to be an independent $\gamma$-edge set belonging to the link stream. We show that the problem of computing a temporal matching of maximum size is NP-hard as soon as $\gamma>1$. We depict a kernelization algorithm parameterized by the solution size for the problem. As a byproduct we also give a $2$-approximation algorithm. Both our $2$-approximation and kernelization algorithms are implemented and confronted to link streams collected from real world graph data. We observe that finding temporal matchings is a sensitive question when mining our data from such a perspective as: managing peer-working when any pair of peers $X$ and $Y$ are to collaborate over a period of one month, at an average rate of at least two email exchanges every week. We furthermore design a link stream generating process by mimicking the behaviour of a random moving group of particles under natural simulation, and confront our algorithms to these generated instances of link streams. All the implementations are open source.

Figures

Equations

$$E_{\delta }=\{(t,\{u,v\})|\exists t^{\prime }\in T:\delta t\le t^{\prime }<\delta (t+1)\wedge (t^{\prime },\{u,v\})\in E\}.$$

$$E_{var}$$

$$E_{cla}$$

$$\mathcal{M}$$

$$E_{\delta }=\{(t,\{u,v\})|\exists t^{\prime }\in T:\delta t\le t^{\prime }<\delta (t+1)\wedge (t^{\prime },\{u,v\})\in E\}.$$

Full text

Both our $2$-approximation and kernelization algorithms are implemented and confronted to link streams collected from real world graph data. We observe that finding temporal matchings is a sensitive question when mining our data from such a perspective as: managing peer-working when any pair of peers $X$ and $Y$ are to collaborate over a period of one month, at an average rate of at least two email exchanges every week. We furthermore design a link stream generating process by mimicking the behaviour of a random moving group of particles under natural simulation, and confront our algorithms to these generated instances of link streams. All the implementations are open source.

††thanks: Part of the results reported in this paper were presented at CTW’18. Links to the source code and the GUI of the link stream generator:

https://github.com/antoinedimitriroux/Temporal-Matching-in-Link-Streams

https://antoinedimitriroux.github.io

For financial support, we are grateful to: Thales Communications & Security, project TCS.DJ.2015-432; Agence Nationale de la Recherche Technique, project 2016.0097; Centre National de la Recherche Scientifique, project INS2I.GraphGPU.

1 Introduction

The problem of finding a maximum matching is a fundamental and well studied question. It consists in finding a maximum independent edge set of a given graph. It can be solved in polynomial time by the well known Edmonds algorithm [8]. On the theoretical side, Edmonds result plays a primary role in combinatorial optimization. This is not only because it made a major historical impact in pointing out the polytope structure of a graph problem, but also because this result has marked the beginning of a long and fruitful list of matching algorithms all having polynomial worst case time complexity. We can cite in this sense the connection between Matching and matrix multiplication which was exploited for algorithm design [4, 16].

A lot of research effort has been put in investigating variants of Matching as well. For instance, a tricky structural analysis helps in devising a linear time procedure for finding popular matchings [1]. Albeit it must be under some conditions called fairness, the fact that a linear time algorithm exists for this kind of popular matching helps in better understanding the underlying discrete structure of matchings. Surprisingly, while being a well-known and fundamentally polynomial algorithmic problem, Matching has lately attracted research interest in the parameterized areas of algorithmic as well [9, 12]. Here, the overall effort has been put in reducing the polynomial time complexity to linear time, by means of factorising bits of the time complexity to depend on another parameter of the input instance rather than its size.

On the practical side, Matching is a convenient formalism to approach task management problems. For instance, in a bipartite graph where one vertex set represents chores and the other vertex set represents executors, each having the ability to execute a (different) subset of chores, Matching models the question of maximising the number of chores that can be executed. This problem has been intensively investigated under the setting of streaming inputs, where unpredictable arrivals of executors must be affected to chores in real time, see e.g. [14, 19]. In this topic, a careful randomized study [7] not only provides a streaming algorithm achieving competitive approximation ratios, but it also gives the upper bound of extra information the streaming algorithm requires, and, particularly, a tricky proof of a lower bound of extra information one need to use in order to achieve the previously said approximation ratio. More generally, in an arbitrary graph representing compatible coworkers, Matching models the concern of maximising the overall workload when work must be done by compatible pairs. This problem has recently been investigated from a heuristics point of view [6], as well as under a quantitative comparison of the greedy approach on large input [20].

From the perspective of mining data collected from human activities, however, the input graph should be taken under the light of the time dimension: graph edges are time stamped edges. They come ordered by the time instants where they are recorded. We call this kind of data a link stream, in the sense of [11, 18]. The most natural illustration of such thing is web logs, where any single line of log includes a field under time format. Phone calls between individuals are also time dependent information, so are email exchanges. Other kind of time dependent interaction could arise from peer programming management in IT best practices too. For instance, let us consider a human resource platform where collaborators register for the coming trimester the time intervals where they are unavailable for work. For simplicity we discretize these time intervals by days, from $1$ to $90$. Besides, the collaborators also communicate via keywords the hard skills in which they are efficient. Let us consider that a task must be processed by two skilled collaborators over at least $\gamma=5$ five consecutive days before delivery. By human limitations, a collaborator will only process a given maximum number of tasks at a time. Under these conditions, given a potentially infinite number of tasks to process, how many deliveries can be made for the coming trimester? How continuously can delivery be? How dense can peer working be versus individualistic task processing? Fundamentally, how to quantify the concession in term of continuous delivery in favoring peer programming over individualistic behaviour? While not fully answering to these questions, we propose to make one step toward this kind of reflection by formalizing the notion of timed collaboration, and show how to compute it.

A link stream $L$ is a triple $L=(T,V,E)$ where $E$ is a sequence of pairs of the form $(t,\{u,v\})$, with $\{u,v\}\in{V\choose 2}$ being an edge in the sense of classical loopless undirected simple graphs, and $t\in T\subseteq\mathbb{N}$ an integer representing a discretized time instant. If every pair $(t,\{u,v\})$ in $L$ satisfies $t=t_{0}$ for some fixed $t_{0}$, then we say that link stream $L$ is a graph. Given an integer $\gamma$, a time instant $t$, and two distinct vertices $u$ and $v$, we define the $\gamma$-edge between $u$ and $v$ starting at time $t$ as the set \{(t^{\prime},\{u,v\})\mid t^{\prime}\in\left\llbracket t,t+\gamma-1\right\rrbracket\}. A temporal vertex is a pair $(t,u)$, representing vertex $u\in V$ at time $t\in T$. We say that a $\gamma$-edge $\Gamma$ contains a temporal vertex $(t,u)$ if there exists a vertex $v\in V$ such that $(t,\{u,v\})\in\Gamma$. Two $\gamma$-edges are independent if there is no temporal vertex that is contained in both of them. Finally, a $\gamma$-matching of link stream $L$ is a set of pairwise independent $\gamma$-edges where each $\gamma$-edge contains exclusively edges from $L$. We define $\gamma$-matching as the problem of computing a maximum $\gamma$-matching from a given input link stream. We believe that problems involving $\gamma$-edges with $\gamma=1$ somewhat are rooted in classical graph theory, whereas $\gamma$-edges for $\gamma>1$ intrinsically model temporal interactions. For instance, when $\gamma=1$, this problem can be solved by a slight extension of previously mentioned Edmonds algorithm [8]. In recent studies under a temporal perspective, the problem when $\gamma=1$ has also been considered along with additional conditions in the computed $\gamma$-matching, making it NP-hard [2, 13]. In this paper, we focus on $\gamma$-edges with a non-trivial duration, that is, when $\gamma>1$.

Unfortunately, $\gamma$-matching turns out to be NP-hard for $\gamma>1$. We subsequently address the question of pre-processing, in polynomial time, an input instance of $\gamma$-matching, in order to reduce it to an equivalent instance of smaller size, in the sense of kernelization algorithms introduced in [5]. We show that $\gamma$-matching when parameterized by the solution size admits a quadratic kernel. On the way to do so, we also point out a simple way to produce a $2$-approximation algorithm for $\gamma$-matching.

We try to comprehend our result from a practical point of view. From this perspective we design a link stream generating process111Direct link to the GUI of the generator:

https://antoinedimitriroux.github.io by mimicking the behaviour of a random moving group of particles, using natural simulation: velocity, friction, and random walk. The generating process helps us in unit testing our implementations on small generated inputs, as well as in stress testing our implementations on large inputs mimicking natural movements.

Both our $2$-approximation and kernelization algorithms are implemented222The source code is available at

https://github.com/antoinedimitriroux/Temporal-Matching-in-Link-Streams and confronted, not only to our generated link streams, but also to two particular sets of link streams collected from real world graph data. These raw datasets are first cleaned by a procedure that we call time-compression, and argue the need for it right below. In one dataset the link streams have been built by time-compression over exchanges collected from the Enron emailing network [10]. The other dataset is built by time-compression over a recording of $2\times 80$ minute Rollerblade touring in Paris [17].

The reason for us to time-compress the raw data is because, therein, the (machine recorded) consecutive time stamps can happen quite instantaneously for human standards. This leaves no chance for a $\gamma$-edge to exist, as soon as $\gamma>1$. For instance with the Enron emails, by ISO8601 time stamps are discretized down to the order of seconds. However, there is absolutely no chance for that individuals $X$ and $Y$ exchange two different emails in any two consecutive seconds in the whole duration of the experiment: there is simply no time to read the first email and type a reply the following second. For Enron we usually merge up the time stamps to the order of half a week: if an email is received, read, thought over, eventually replied within $3.5$ days, then we consider there is collaboration within that period of time. From this perspective, we compress our raw data by edge contraction over the time dimension, formally as follows. For any link stream $L=(T,V,E)$ and $1<\delta<|T|$, we define the $\delta$-compression $L_{\delta}=(T_{\delta},V_{\delta},E_{\delta})$ as $V_{\delta}=V$, $T_{\delta}=\llbracket\frac{\min T}{\delta},\frac{\max T}{\delta}\rrbracket$, and

[TABLE]

After running our implementation on the two datasets, we make three observations. First, we believe that solving $\gamma$-matching is not easy as soon as we time-compress the raw data with “human-understandable” values of $\delta$ and $\gamma$. Second, on small values of $\gamma$, we observe that the kernelization algorithm helps in reducing the input link stream to an equivalent instance of size approximatively $10-20\%$ the size of the original input. This gives measurable evidence of performance for our preprocessing by kernelization. Our third observation is very marginal. Note beforehand from definition that the $2$-approximation algorithm produces a lower bound for $\gamma$-matching, which is at least half the optimal value. Moreover, note also that the kernelization algorithm gives a naive upper bound for $\gamma$-matching by simply counting the number of $\gamma$-edges present in the kernel. Our third observation from the numerical analysis is that these upper bound and lower bound nearly meet on some areas in the datasets. Even though they remain extremely marginal, these cases point out that, sometimes, a kernelization algorithm can also provide a numerical proof of optimality of the result found by a (greedy) $2$-approximation. This hints at the usefulness beyond theoretical considerations of $\gamma$-matching kernelization. Moreover, our kernelization runtime is under ten seconds for inputs where the input size is some hundreds thousand and the parameter is some thousands. Fixed parameter tractable (FPT) paradigm in general, and kernelization in particular, would never be numerically helpful if the complexity analysis hides a big function of the parameter in the Landau notation. Luckily, we use simple algorithmic processes for our kernelization.

The paper is organised as follows. We first introduce the notion of temporal matching in Section 2. In Section 3, we present our algorithmic tools in order to obtain our main result, the kernelization algorithm: it is presented in Section 4. In Section 5, we present our numerical analysis. We close the paper with concluding remarks and directions for further research.

2 Temporal matching

Unless otherwise stated, graphs in this paper are simple, undirected and loopless graphs. We denote by $\mathbb{N}$ the set of non negative integer. Given two integers $p$ and $q$, we denote by \left\llbracket p,q\right\rrbracket the set $\{r\in\mathbb{N}\mid p\leq r\leq q\}$. A link stream $L$ is a triple $(T,V,E)$ such that $T\subseteq\mathbb{N}$ is an interval, $V$ is a set, and $E\subseteq T\times{V\choose 2}$. The link stream can be seen as an extension of graphs. Indeed, a graph is a link stream where $|T|=1$. The elements of $V$ are called vertices and the elements of $E$ are called (timed) edges. A temporal vertex of $L$ is a pair $(t,u)$ such that $t\in T$ and $u\in V$.

Given an integer $\gamma$, a $\gamma$-edge between two vertices $u$ and $v$ at time $t$, denoted $\Gamma_{\gamma}(t,u,v)$, is the set \{(t^{\prime},\{u,v\})\mid t^{\prime}\in\left\llbracket t,t+\gamma-1\right\rrbracket\}. We say that a $\gamma$-edge $\Gamma$ contains a temporal vertex $(t,u)$ if there exists a vertex $v\in V$ such that $(t,\{u,v\})\in\Gamma$. We say that two $\gamma$-edges are independent if there is no temporal vertex that is contained in both of them. A $\gamma$-matching $\mathcal{M}$ of a link stream $L$ is a set of pairwise independent $\gamma$-edges. We say that a $\gamma$-edge $\Gamma$ is incident with a vertex $u\in V$ if there exist a vertex $v\in V$ and an integer $t\in T$ such that $\Gamma=\Gamma_{\gamma}(t,u,v)$. We say that an edge $e\in E$ is in a $\gamma$-matching $\mathcal{M}$ if there exists $\Gamma\in\mathcal{M}$ such that $e\in\Gamma$.

We focus on the following problem.

$\gamma$-matching

Input: A link stream $L$ and an integer $k$.

Output: A $\gamma$-matching of $L$ of size $k$ or a correct answer that such a set does not exist.

Theorem 1

$\gamma$-matching* is NP-hard for $\gamma>1$.*

• *Proof: *

We prove the NP-completeness of the decision version of $\gamma$-matching by a reduction from 3-Sat, that is well known to be NP-complete. Let $\varphi$ be a formula with $n$ variables $x_{1},\ldots,x_{n}$ and $m$ clauses $C_{0},\ldots,C_{m-1}$ such that each clauses is of size at most $3$. Without loss of generality, we assume that a clause does not contain twice the same variable. We call $X$ the set containing the $n$ variables and $\mathcal{C}$ the set containing the $m$ clauses.

We define the link stream $L=(T,V,E)$ in the following way:

• –

T=\left\llbracket 0,(m+1)\gamma-1\right\rrbracket.

• –

V=\{x^{-},x^{=},x^{+}\mid x\in X\}\cup\{x^{++}_{t},x^{--}_{t}\mid x\in X,t\in\left\llbracket 0,m-1\right\rrbracket\}\cup\{c\}

• –

$E=E_{var}\cup E_{cla}$ where:

[TABLE]

We depict in Figure 1 the link stream build for $\gamma=3$ and $\varphi=(w\vee\overline{x}\vee y)\wedge(w\vee x\vee\overline{z})$.

We show that there is an assignments of the variables that satisfies $\varphi$ if and only if $L$ contains a $\gamma$-matching of size $(2m+1)n+m$.

Intuitively, the edge between $(0,\{x^{=},x^{+}\})$ and $(0,\{x^{=},x^{-}\})$ that is in the requested $\gamma$-matching determines if the variable $x$ is set to true or false. Moreover, the size of the requested $\gamma$-matching will ensure that if the edge $(0,\{x^{=},x^{+}\})$ (resp. $(0,\{x^{=},x^{-}\})$) is in the $\gamma$-matching, then every edge $(t,\{x^{=},x^{+}\})$ (resp. $(t,\{x^{=},x^{-}\})$), t\in\left\llbracket 0,(m+1)\gamma-1\right\rrbracket and every edge $(t,\{x^{-},x^{--}_{i}\})$ (resp. $(t,\{x^{+},x^{++}_{i}\})$), t\in\left\llbracket 1,m\gamma\right\rrbracket\}, $i=\left\lfloor\frac{t-1}{\gamma}\right\rfloor$, are in the $\gamma$-matching as well. Finally, during the time interval \left\llbracket i\gamma+1,(i+1)\gamma\right\rrbracket, we will certify that the clause $C_{i}$ is satisfied.

First assume that $\varphi$ is satisfiable. Let $\psi$ be a satisfying assignment of $\varphi$ and let $\chi:\mathcal{C}\rightarrow V$ be a function that, for each clause $C_{i}$, i\in\left\llbracket 0,m-1\right\rrbracket, arbitrary chooses a variable $x\in X$, such that the assignment of $x$ given by $\psi$ satisfies $C_{i}$, and returns $x^{++}_{i}$ (resp. $x^{--}_{i}$) if $\psi(x)=\mathtt{true}$ (resp. $\psi(x)=\mathtt{false}$). Let

[TABLE]

One can verify that $\mathcal{M}$ is a $\gamma$-matching of $L$ of size $(2m+1)n+m$.

Assume now that $L$ contains a $\gamma$-matching $\mathcal{M}$ of size $(2m+1)n+m$. We use several claim in order to construct a satisfying assignment of $\varphi$.

Claim 1

For each $x\in X$, $\mathcal{M}$ contains at most $m+1$ $\gamma$-edges incident with $x^{+}$ (resp. $x^{-}$).

• *Proof: *

This result follows from the fact that T=\left\llbracket 0,(m+1)\gamma-1\right\rrbracket is of size $(m+1)\gamma$ and so, cannot be divided into $m+2$ pairwise disjoint sets of size $\gamma$. $\Box$

Claim 2

Given $x\in X$, if $\Gamma_{\gamma}(0,x^{=},x^{+})\not\in\mathcal{M}$ (resp. $\Gamma_{\gamma}(0,x^{=},x^{-})\not\in\mathcal{M}$), then $\mathcal{M}$ contains at most $m$ $\gamma$-edges incident with $x^{+}$ (resp. $x^{-}$).

• *Proof: *

As $\Gamma_{\gamma}(0,x^{=},x^{+})$ is the only $\gamma$-edge of $L$ that contains the edge $e_{x}^{0}=(0,\{x^{=},x^{+}\})$, this implies that the edge $e_{x}^{0}$ is not contained in any $\gamma$-edge of $\mathcal{M}$. So the $\gamma$-edge of $\mathcal{M}$ that are incident with $x^{+}$ are constraint to exist in the time interval I=\left\llbracket 1,(m+1)\gamma-1\right\rrbracket that is of size $(m+1)\gamma-1$. Thus, $I$ cannot be divided in $m+1$ pairwise disjoint sets of size $\gamma$. The claim follows. $\Box$

Claim 3

$\mathcal{M}$* contains exactly $m$ $\gamma$-edges incident with $c$ and contains exactly $2m+1$ $\gamma$-edges incident with $x^{+}$ or $x^{-}$, for each $x\in X$.*

• *Proof: *

As $\mathcal{M}$ is a $\gamma$-matching, then for each $x\in X$, $\Gamma_{\gamma}(0,x^{=},x^{+})\not\in\mathcal{M}$ or $\Gamma_{\gamma}(0,x^{=},x^{-})\not\in\mathcal{M}$. So Claim 1 and Claim 2 implie that for each $x\in X$, $\mathcal{M}$ contains at most $2m+1$ $\gamma$-edges incident with $x^{+}$ or $x^{-}$. Moreover, by construction $\mathcal{M}$ can contains at most $m$ $\gamma$-edges incident with $c$ and $L$ does not contains any edge of the form $(t,\{x^{+},y^{-}\})$, $(t,\{x^{+},y^{+}\})$, $(t,\{x^{-},y^{-}\})$, $(t,\{x^{+},c\})$, or $(t,\{x^{-},c\})$, for any $x,y\in X$. Thus the budget is tight. The claim follows. $\Box$

Note that by construction, if $\mathcal{M}$ contains a $\gamma$-edge incident with $x^{++}_{i}$ for some $x\in X$ and i\in\left\llbracket 0,m-1\right\rrbracket, then this $\gamma$-edge has to be either $\Gamma_{\gamma}(i\gamma+1,c,x^{++}_{i})$ or $\Gamma_{\gamma}(i\gamma+1,x^{+},x^{++}_{i})$. Moreover Claim 4 give us some information in the case where $\Gamma_{\gamma}(i\gamma+1,x^{+},x^{++}_{i})\in\mathcal{M}$

Claim 4

Given $x\in X$, if $\mathcal{M}$ contains a $\gamma$-edge $\Gamma_{\gamma}(i\gamma+1,x^{+},x^{++}_{i})$ (resp. $\Gamma_{\gamma}(i\gamma+1,x^{-},x^{--}_{i})$) for some i\in\left\llbracket 0,m-1\right\rrbracket, then $\mathcal{M}$ contains at most $m$ $\gamma$-edges incident with $x^{+}$ (resp. $x^{-}$).

• *Proof: *

Let $x\in X$ and let $i$ be the first value such that $\Gamma_{\gamma}(i\gamma+1,x^{+},x^{++}_{i})\in\mathcal{M}$. As $\gamma$ does not divide $i\gamma+1$, this implies that, in the interval \left\llbracket 0,i\gamma\right\rrbracket, at least one edge $e_{x}^{t}=(t,\{x^{=},x^{+}\})$, t\in\left\llbracket 0,i\gamma\right\rrbracket is not in $\mathcal{M}$. So the $\gamma$-edges of $\mathcal{M}$ that are incident with $x^{+}$ are constraint to exist in the time interval $I=T\setminus{t}$ that is of size $(m+1)\gamma-1$. Thus, $I$ cannot be divided in $m+1$ pairwise disjoint sets of size $\gamma$. The claim follows. $\Box$

Let $x\in X$. Using Claim 3, we know that $\mathcal{M}$ contains exactly $2m+1$ $\gamma$-edges incident with $x^{+}$ or $x^{-}$. By the pigeonhole principle, we know that for $x^{+}$ or $x^{-}$, say $x^{+}$, $\mathcal{M}$ contains exactly $m+1$ $\gamma$-edges incident with $x^{+}$. By Claim 4, this implies that \{\Gamma_{\gamma}(i\gamma,x^{=},x^{+})\mid i\in\left\llbracket 0,m\right\rrbracket\}\subseteq\mathcal{M}. Thus, as $\mathcal{M}$ is a $\gamma$-matching that contains $m$ $\gamma$-edges incident with $x^{-}$, this also implies that \{\Gamma_{\gamma}(i\gamma+1,x^{-},x^{--}_{i})\mid i\in\left\llbracket 0,m-1\right\rrbracket\}\subseteq\mathcal{M}.

For each variable $x\in X$, we set $x$ to true (resp. false) if $\Gamma_{\gamma}(0,x^{=},x^{+})\in\mathcal{M}$ (resp. $\Gamma_{\gamma}(0,x^{=},x^{-})\in\mathcal{M}$). Let $\varphi$ be the so obtained assignment. Let i\in\left\llbracket 0,m-1\right\rrbracket. We know that there exists $x\in X$ such that either $\Gamma_{\gamma}(i\gamma+1,c,x^{++}_{i})\in\mathcal{M}$ or $\Gamma_{\gamma}(i\gamma+1,c,x^{--}_{i})\in\mathcal{M}$. Let fix this $x\in X$ and assume that $\Gamma_{\gamma}(i\gamma+1,c,x^{++}_{i})\in\mathcal{M}$, meaning that $x$ appears positively in $C_{i}$. This implies that $\Gamma_{\gamma}(i\gamma+1,x^{+},x^{++})\not\in\mathcal{M}$, so that \{\Gamma_{\gamma}(i^{\prime}\gamma,x^{=},x^{+})\mid i^{\prime}\in\left\llbracket 0,m\right\rrbracket\}\subseteq\mathcal{M}. Thus, $x$ is set to true by $\varphi$ and $x$ satisfies $C_{i}$. This concludes the proof. $\Box$

3 Approximation algorithm

In classical graph theory, it is folklore that any maximal matching is also a $2$-approximation of a maximum matching, see e.g. [3, Exercice 35.4]. Fortunately enough, it is roughly the same situation with link streams. Precisely, in this section, we adopt the greedy approach –finding a maximal $\gamma$-matching– in order to provide a $2-$approximation algorithm for $\gamma$-matching.

Let $L=(T,V,E)$ be a link stream. Let $\mathcal{P}$ be the set of all $\gamma$-edges of $L$. Note that these $\gamma$-edges are not independent from each other, on the contrary, they highly overlap. Let $\preceq$ be an arbitrary total ordering on the elements of $\mathcal{P}$ such that given for any two elements of $\mathcal{P}$, $\Gamma_{1}=\Gamma_{\gamma}(t_{1},u_{1},v_{1})$ and $\Gamma_{2}=\Gamma_{\gamma}(t_{2},u_{2},v_{2})$ such that $t_{1}<t_{2}$, we have $\Gamma_{1}\preceq\Gamma_{2}$.

We denote by $\mathcal{A}$ the following greedy algorithm. The algorithm starts with $\mathcal{M}=\emptyset$, $\mathcal{Q}=\mathcal{P}$, and a function $\rho:V\times T\rightarrow\{0,1\}$ such that for each $(t,v)\in T\times V$, $\rho(t,v)=0$. The purpose of $\rho$ is to keep track of the temporal vertices that are contained in a $\gamma$-edge of $\mathcal{M}$. As long as $\mathcal{Q}$ is not empty, the algorithm selects $\Gamma$, the $\gamma$-edge of $\mathcal{Q}$ that is minimum for $\preceq$, and removes it from $\mathcal{Q}$. Let $K$ be the set of the $2\gamma$ temporal vertices that are contained in $\Gamma$. If, for each $(t,v)\in K$, $\rho(t,v)=0$, then the algorithm adds $\Gamma$ to $\mathcal{M}$, otherwise it does nothing at this step. For each $(t,v)\in K$, it sets $\rho(t,v)$ to $1$ and repeats. If $\mathcal{Q}=\emptyset$, it returns $\mathcal{M}$.

As $\mathcal{P}$ can be determined in a sorted way in time $\mathcal{O}(m)$, this algorithm runs in time $\mathcal{O}(n\tau+m)$, where $\tau=|T|$, $n=|V|$, $m=|E|$, and where $\gamma$ is a constant hidden in the $\mathcal{O}$.

Given a $\gamma$-matching $\mathcal{M}$, we define the bottom temporal vertices of $\mathcal{M}$, denoted by $\mathtt{bot}(\mathcal{M})$, as the set $\{(t+\gamma-1,u),(t+\gamma-1,v)\mid\Gamma_{\gamma}(t,u,v)\in\mathcal{M}\}$. Lemma 1 shows the crucial role of the bottom temporal vertices of the matchings returned by $\mathcal{A}$.

Lemma 1

Let $\gamma$ be a positive integer, let $L$ be a link stream, and let $\mathcal{M}$ be a $\gamma$-matching returned by $\mathcal{A}$ when applied to $L$. If $\mathcal{M}^{\prime}$ is a $\gamma$-matching of $L$, then every $\gamma$-edge of $\mathcal{M^{\prime}}$ contains, at least, one temporal vertex of $\mathtt{bot}(\mathcal{M})$.

• *Proof: *

First, note that any $\gamma$-edge of $\mathcal{M}$ contains two temporal vertices of $\mathtt{bot}(\mathcal{M})$, and so, at least one. Let $\Gamma^{\prime}$ be a $\gamma$-edge of $\mathcal{M^{\prime}}$ that is not in $\mathcal{M}$. Let $\mathcal{M}^{*}\subseteq\mathcal{M}$ be the set of every $\gamma$-edge $\Gamma^{*}$ of $\mathcal{M}$ such that there exists a temporal vertex $(t,u)$ that is contained in both $\Gamma^{\prime}$ and $\Gamma^{*}$. Assume that $\Gamma^{\prime}=\Gamma_{\gamma}(t,u,v)$. If there exists $\Gamma^{*}\in\mathcal{M}$ such that $\Gamma^{*}=\Gamma_{\gamma}(t^{\prime},u,v^{\prime})$ and $t^{\prime}\leq t$, then we have that $(t^{\prime}+\gamma-1,u)\in\mathtt{bot}(\mathcal{M})$ is contained in $\Gamma^{\prime}$. Otherwise, we have that for each $\Gamma^{*}\in\mathcal{M}^{*}$ such that $\Gamma^{*}=\Gamma_{\gamma}(t^{\prime},u,v^{\prime})$, $t^{\prime}>t$. This is not possible by construction of $\mathcal{A}$. This concludes the proof. $\Box$

Lemma 1 plays a cornerstone role in the proof of subsequent Theorem 2. As a byproduct, we also obtain the following result.

Corollary 1

$\mathcal{A}$* is a $2$-approximation of the $\gamma$-matching problem.*

• *Proof: *

Let $L$ be the input link stream. Let $\mathcal{M}$ be a solution returned by the algorithm $\mathcal{A}$ when applied to $L$, and let $\mathcal{M}^{\prime}$ be a $\gamma$-matching of $L$. As $|\mathtt{bot}(\mathcal{M})|=2|\mathcal{M}|$, two $\gamma$-edges of $\mathcal{M}^{\prime}$ cannot contains the same temporal vertex, and, by Lemma 1, every $\gamma$-edge of $\mathcal{M}^{\prime}$ contains at least one element of $\mathtt{bot}(\mathcal{M})$, we obtained that $|\mathcal{M}^{\prime}|\leq 2|\mathcal{M}|$. $\Box$

4 Kernelization algorithm

Problem $\gamma$-matching has a kernel if there exist a computable function $f:\mathbb{N}\rightarrow\mathbb{N}$ and a polynomial time algorithm ${\mathcal{A}}$ which takes as input an instance $(L,k)$ of $\gamma$-matching and produces an instance $(L^{\prime},k^{\prime})$ such that: $k^{\prime}\leq k$; $|L^{\prime}|\leq f(k)$; and $(L^{\prime},k^{\prime})$ yields a positive answer for $\gamma$-matching if and only if $(L,k)$ yields a positive answer for $\gamma$-matching. In this case, algorithm ${\mathcal{A}}$ is called a kernelization algorithm for $\gamma$-matching [5].

We now show a kernelization algorithm for $\gamma$-matching by a direct pruning process based on Lemma 1. For convenience, let us say that a $\gamma$-edge $\Gamma$ is incident to a temporal vertex $(t,u)$ when there exists vertex $v\neq u$ such that $(t,\{u,v\})\in\Gamma$. The main idea is as follows. First, we compute the set $S$ of all bottom temporal vertices of a $\gamma$-matching produced by previously defined algorithm $\mathcal{A}$. Then, we prune the original instance by only keeping edges that belong to a $\gamma$-edge incident to a temporal vertex of $S$. More precisely, we prove the following result.

Theorem 2

There exists a polynomial-time algorithm that for each instance $(L,k)$, either returns a true instance which correctly correspond to the fact that $L$ contains a $\gamma$-matching of size $k$, or returns an equivalence instance $(L^{\prime},k)$ such that the number of edges of $L^{\prime}$ is $2(k-1)(2k-1)\gamma^{2}$.

• *Proof: *

Let $L=(T,V,E)$ be a link stream and $k$ be an integer. We first run the algorithm $\mathcal{A}$ on $L$. Let $\mathcal{M}$ be the $\gamma$-matching outputed by the algorithm and let $\ell=|\mathcal{M}|$. If $\ell\geq k$, then we already have a solution and then return a true instance. If $\ell<\frac{k}{2}$, then, by Corollary 1, we know that the instance does not contains a $\gamma$-matching of size $k$, and then we return a false instance. We now assume that $\frac{k}{2}\leq\ell<k$.

Lemma 1 justifies that we are now focusing on the temporal vertices of $\mathtt{bot}(\mathcal{M})$ in order to find the requested kernel. We construct a set $\mathcal{P}$ of $\gamma$-edges and we show that any edge $e$, that is not in a $\gamma$-edge of $\mathcal{P}$, is useless when looking for a $\gamma$-matching of size $k$. For each $(t,u)\in\mathtt{bot}(\mathcal{M})$, and for each $t^{\prime}$ such that $\max(0,t-\gamma+1)\leq t^{\prime}\leq t$, we consider the set $\mathcal{S}(t^{\prime},u)$ of every $\gamma$-edge, existing in $L$, with the form $\Gamma_{\gamma}(t^{\prime},u,v)$ with $v\in V$. If the set $\mathcal{S}(t^{\prime},u)$ is of size at most $2k-1$, we add every element of $\mathcal{S}(t^{\prime},u)$ to $\mathcal{P}$. Otherwise, we select $2k-1$ elements of $\mathcal{S}(t^{\prime},u)$ that we add to $\mathcal{P}$. In both cases, we denote by $\mathcal{S^{\prime}}(t^{\prime},u)$ the set of elements of $\mathcal{S}(t^{\prime},u)$ that we have added to $\mathcal{P}$. This finish the construction of $\mathcal{P}$. As $|\mathtt{bot}(\mathcal{M})|=2\ell$ and for each element of $\mathtt{bot}(\mathcal{M})$ we have added at most $(2k-1)\gamma$ $\gamma$-edges to $\mathcal{P}$, we have that $|\mathcal{P}|\leq 2\ell(2k-1)\gamma\leq 2(k-1)(2k-1)\gamma$.

We now prove that if $L$ contains a $\gamma$-matching $\mathcal{M^{\prime}}$ of size $k$, then it also contains a $\gamma$-matching $\mathcal{M^{\prime\prime}}$ of size $k$ such that $\mathcal{M^{\prime\prime}}\subseteq\mathcal{P}$. Let $\mathcal{M^{\prime}}$ be a $\gamma$-matching of $L$ of size $k$ such that $p=|\mathcal{M^{\prime}}\setminus\mathcal{P}|$ is minimum. We have to prove that $p=0$. Assume that $p\geq 1$. Let $\Gamma$ be a $\gamma$-edge in $\mathcal{M^{\prime}}\setminus\mathcal{P}$. Let $(t,u)$ be a temporal vertex of $\mathtt{bot}(\mathcal{M})$ that is contained in $\Gamma$. We know by Lemma 1 that this temporal vertex exists. Assume that $\Gamma=\Gamma_{\gamma}(t^{\prime},u,v)$ for some $v\in V$ and some $t^{\prime}$ such that $\max(0,t-\gamma+1)\leq t^{\prime}\leq t$. As $\Gamma\not\in\mathcal{P}$, we have that $\Gamma\in\mathcal{S}(t^{\prime},u)\setminus\mathcal{S^{\prime}}(t^{\prime},u)$, and so $|\mathcal{S^{\prime}}(t^{\prime},u)|=2k-1$. Let $N_{\mathcal{S^{\prime}}}(t^{\prime},u)$ be the set of vertices $w$ of $V\setminus\{u\}$ such that a $\gamma$-edge of $\mathcal{S^{\prime}}(t^{\prime},u)$ is incident to $w$. As $\mathcal{M^{\prime}}\setminus\{\Gamma\}$ is of size $k-1$, the $\gamma$-edges that it contains can be incident to at most $2k-2$ vertices. This means that there exists $w\in N_{\mathcal{S^{\prime}}}(t^{\prime},u)$ such that no $\gamma$-edge of $\mathcal{M^{\prime}}\setminus\{\Gamma\}$ is incident to $w$. Thus $(\mathcal{M^{\prime}}\setminus\{\Gamma\})\cup\{\Gamma_{\gamma}(t^{\prime},u,w)\}$ is a $\gamma$-matching of size $k$. As $\Gamma\not\in\mathcal{P}$ and $\Gamma_{\gamma}(t^{\prime},u,v)\in\mathcal{P}$, this contradicts the fact that $p$ is minimum.

We now can define the link stream $L^{\prime}=(T,V,E^{\prime})$ such that $E^{\prime}=\{e\in E\mid\exists\Gamma\in\mathcal{P}:e\in\Gamma\}$. As $|\mathcal{P}|\leq 2(k-1)(2k-1)\gamma$ and every element of $\mathcal{P}$ is a $\gamma$-edge, we have that $|E^{\prime}|\leq 2(k-1)(2k-1)\gamma^{2}$. The theorem follows. $\Box$

5 Experimental result

For easy diffusion, both our $2$-approximation and kernelization algorithms are implemented in Java and JavaScript333The source code is available at

https://github.com/antoinedimitriroux/Temporal-Matching-in-Link-Streams. Experiments are run on a standard laptop clocking at 3,1 Ghz with DDR3 16Go memory.

5.1 Dataset

We carried out our experiments on two main types of datasets: those that are randomly generated444Direct link to the GUI of the generator:

https://antoinedimitriroux.github.io; and those that are collected from human activities.

*Artificially generated link streams, and stress test:

*In order to generate random sets of link stream instances, we adopt the more realistic point of view of random geometric graphs, rather than the classically theoretic Erdös-Rényi model, as follows. Let ${\mathcal{S}}$ be a 2D Euclidian space. We define a particle as a point in space ${\mathcal{S}}$. Every particle is given along with a radius representing the maximum communication distance it can have with another particle. Thus, the particle together with its range define a disk in space ${\mathcal{S}}$. Let ${\mathcal{P}}$ be a set of particles, given along with the same value of radius. We partition set ${\mathcal{P}}$ into $n$ parts, ${\mathcal{P}}=P_{1}\cup P_{2}\cup\dots\cup P_{n}$, of roughly equal size. We will construct a link stream $L=(T,V,E)$ as follows. Let $V=\{P_{1},P_{2},\dots,P_{n}\}$. At time zero, let E_{0}=\{(0,\{P_{i},P_{j}\})~{}|~{}\exists a\in P_{i}\land b\in P_{j},\textit{ the distance between a$and$b is less than their radius}\}. In other words, if there are at least two particles under communication range $a\in P_{i},b\in P_{j}$ of different groups $P_{i}\neq P_{j}$ (at time zero), then, we consider there is a (zero-timed) edge between $P_{i}$ and $P_{j}$. Every particle has a velocity that is defined as follows. First, the velocity of a particle at time $t$ is a fraction of the velocity at time $t-1$ of that particle (friction). Second, all velocity vectors are subject to a small random additional factor (random walk factor modeling the wind condition). Finally, we truncate every velocity vector in order to insure that the norm of the vector is lower than a given maximum particle speed (physical limits). We then let the system evolve during a given laps of time, that we also refer to as $T$. At every time instant $t\in T$, we define, similarly as before, the $t$-timed edge set E_{t}=\{(t,\{P_{i},P_{j}\})~{}|~{}\exists a\in P_{i}\land b\in P_{j},\textit{ the distance between a$and$b is less than their radius}\}. Finally, we define our link stream as $E=\bigcup_{t\in T}E_{t}$.

Roughly, increasing any of the three parameters which are defined by the particle radius, the cardinality of ${\mathcal{P}}$, and the maximum particle speed, results in the same effect on the generated link stream, that is, to produce a dense link stream. The generated data allows us to unit test our code, and especially to verify that approximation and kernelization runtime is sound on large input. For instance, with inputs containing hundreds of thousand timed edges, our runtime is under ten seconds, cf. Fig. 2.

Interestingly, in the left chart of Fig. 2, we note for some input with a large number of timed edges and no $\gamma$-edges that the runtime can be very quick. We also discuss this phenomenon on real world dataset, in below Fig. 3 and 4. For this reason, it is much more interesting to examine the runtime as a function of the number of $\gamma$-edges of the input, cf. the right chart in Fig. 2. For easy eye-comparison, we tried to parametrise the generator in a way that most of the generated instances have roughly the same number of timed edges and $\gamma$-edges. For instance, most instances with less than $100000$ timed edges also have roughly the same number of $\gamma$-edges. However, the situation is more random for instances having between $100000$ and $200000$ timed edges.

*Real world datasets, with cleaning methodology:

*We also confront the implementations of our algorithms to two particular link streams collected from real world graph data. In one dataset the link stream is built from emailing information collected from the Enron company [10]. The other dataset has been built by analysing a recording of $2\times 80$ minute Rollerblade touring in Paris [17]. Because of the long duration of these two experiments, the number of vertices (under two hundred persons in both cases) is negligible when comparing to the number of temporal vertices (nearly one million for Rollernet). For a link stream $L=(T,V,E)$, we mostly compare $|T|$ with $|E|$ to get a glimpse on the density of the links. For a complete view of $|T|$, $|V|$, and $|E|$ in the datasets, we refer the reader to Fig. 7. Furthermore, we noticed with our raw datasets that the instants where some timed edge is present can be very sparse, leaving no chance for a $\gamma$-edge to exist as soon as $\gamma>1$. For instance, in the Enron experiment (Fig. 3), we can see that there are no pair of employees who keep sharing $1$ mail per hour during $24$ hours, probably due to inactivity at night. We will, for this reason, time-compress our raw datasets by the following process.

Definition 1** (Data cleaning by time-compression)**

For any link stream $L=(T,V,E)$ and for any $1<\delta<|T|$, we define the $\delta$-compression* $L_{\delta}=(T_{\delta},V_{\delta},E_{\delta})$ as $V_{\delta}=V$, $T_{\delta}=\llbracket\frac{\min T}{\delta},\frac{\max T}{\delta}\rrbracket$, and*

[TABLE]

Fig. 3 and 4 show that parameters $\delta$ and $\gamma$ have an important influence on the number of $\gamma-$edges. One can also notice from Fig. 3 and 4 that the compression process generally breaks down the number $|E|$ of timed edges in the dataset. However, we stress that it is not necessarily the case: Fig. 5 exemplifies two different time-compressions of the same original link stream, respectively with $\delta=3$ and $\delta=4$, where it is possible to obtain more edges even if we have a larger $\delta$. Nonetheless, the usual effect of time-compression is to drastically reduce the number of timed edges. On Enron and Rollernet datasets, we need to ensure that time-compression does not result in empty inputs. Luckily, for sensible values of $\delta$, e.g. $\frac{1}{2}$ week for Enron or $15$ minutes for Rollernet, there is still a large number of timed edges after $\delta$-compression, cf. Fig. 6. We give in the subsequent Fig. 7 and 8 the runtime of our algorithm on random pieces of the two Enron and Rollernet datasets, where we observe that our runtime is very quick.

5.2 Hypothesis

We theorise three hypotheses. For each hypothesis we run experiment on the above described datasets, and expose our results in the next Subsection 5.3. We discuss and conclude our numerical analysis in the subsequent and last Subsection 5.4 of current Section 5.

*Hypothesis 1. Consistence of the formalism:

*We would like to verify that $\gamma$-matching is non-trivial on human values for $\delta$ and $\gamma$. For instance, we suppose when mining emails that collaborating during a month at a rate of at least two emails per week (round trip) is sensibly human values. When mining proximity records of $2\times 80$ minute Rollerblade touring Paris, we consider that collaborating during $80$ minutes at a rate of one visit every quarter hour (water/snack supplying) is sensibly human values.

*Hypothesis 2. Kernelization quality:

*We reckon that, beside the hidden constants under the Landau notation, a space reduction from $O(n)$ to $O(k^{2})$, when $k=O(\sqrt{n})$ is also meaningless. Unfortunately, when parameterizing by the size of the solution as we do in this paper, one very usually results in the situation where $k$ is numerically in the order of $\sqrt{n}$. This is particularly true for our study of temporal matchings on Enron and Rollernet. For this reason, our second hypothesis is that, in addition to a theoretical guarantee of reduction from $O(n)$ to $O(k^{2})$ space complexity, solving $\gamma$-matching can numerically benefit from the kernelization algorithm described in Theorem 2, at least on well-chosen and humanly sensible intervals of $\delta$ and $\gamma$.

*Hypothesis 3. Approximation quality:

*We stress that Matching in a classical graph is polynomial. Unfortunately, $\gamma$-matching in a link stream is NP-hard. However, in practice, a lot of NP-complete problems are not difficult on datasets arising from human activities. What’s more, some such problems can be solved near-optimally by simple algorithms such as by a random or greedy approach, or a mix of both approaches, even on arbitrary inputs. A popular example is Coloring [15]. Accordingly, our last hypothesis is that, in practice, finding an optimal $\gamma$-matching need not to be difficult. Moreover, we hypothesise that the greedy $2$-approximation described in Lemma 1 can produce near-optimal $\gamma$-matching on real world dataset, as well as artificial datasets that mimic real word datasets.

5.3 Result

Both our $2$-approximation and kernelization algorithms are implemented and confronted to the above mentioned datasets.

*Observations w.r.t. Hypothesis 1. Consistence of the formalism:

*Results are given in Fig. 9. We observe on Enron dataset with $\delta\approx\frac{1}{2}$ week that, after $\delta$-compression, the number of $\gamma$-edges for $\gamma$ varying from $2$ to $10$ is: over $500$ for $\gamma=10$; over $1000$ for $\gamma=6$; and over $4500$ for $\gamma=2$. Moreover, we will see in the next paragraph that our numerical analysis can only find $\gamma$-matchings of size approximately one fifth of the previous number. We also tried other techniques to improve the size of the $\gamma$-matchings but failed in finding substantial difference. With the Enron dataset, we believe that $\gamma$-matching for $\gamma\approx 10$ is a tricky question when the time-compression rate is $\delta\approx\frac{1}{2}$ week. These values translate the fact that any pair of collaborators in the $\gamma$-matching necessarily keep exchanging emails together continuously for one month, at a rate of at least one email per week and in average at least two emails every week.

*Observations w.r.t. Hypothesis 2. Kernelization quality:

*Results are given in Fig. 10. The parameter $k$ for the kernelization algorithm is the size of the solution found by the $2$-approximation algorithm. We observe that on well chosen intervals of $\delta$ and $\gamma$, kernelization reduces the input size down to under twenty per cent. This is particularly true for $\gamma\approx 20,30$ with $\delta\leq 2$ month on Enron; and $\gamma\leq 10$ with $\delta\leq 20$ minutes for Rollernet. We observe on these values that the kernelization algorithm reduces the input link stream to an equivalent instance of size smaller than $20\%$ the size of the original input, and sometimes under $10\%$. We conclude that Hypothesis 2 is sound.

*Observations w.r.t. Hypothesis 3. Approximation quality:

*Results are given in Fig. 11. The parameter $k$ for the kernelization algorithm is the size of the solution found by the $2$-approximation algorithm. We notice from definition that the $2$-approximation algorithm produces a lower bound for $\gamma$-matching, which is at least half the optimal value. Moreover, the kernelization algorithm gives a naive upper bound for $\gamma$-matching by simply counting the number of $\gamma$-edges present in the kernel. We observe for tangent areas in Fig. 11 that these two upper and lower bounds meet. This means that the $2$-approximation outputs an optimal solution for $\gamma$-matching on these areas. However, we observe that for most parts of our dataset, Hypothesis 3 is not confirmed. At this state, our experiments w.r.t. Hypothesis 3 fail in giving any clue for a conclusion. Further experiments must be done in order to clarify this question. Our feeling, however, is that Hypothesis 3 is generally false. We conjecture that the $2$ approximation factor is far from optimal.

5.4 Discussion

Our experiment results are optimistic about the numerical usefulness of kernelization in finding temporal matching. At the same time, they also point out several questions. While our experiments allow us to observe that:

• •

preprocessing an instance of $\gamma$-matching by a greedy process, and then kernelization as described in Theroem 2, seems to be sound;

• •

the preprocessing is very quick on real world input;

• •

the preprocessing is robust versus stress testing on large inputs using common laptop: below ten seconds on input of hundreds thousand timed edges;

they also testify that works still need to be done for further investigating $\gamma$-matching, especially that:

• •

the optimisation problem is NP-hard;

• •

numerical proofs of optimality of the $2$-approximation are only available for very marginal bits of data in the Enron and Rollernet datasets;

• •

while it is true that the kernelization algorithm helps in reducing the input down to $10-20\%$ for interesting mining parameters on Enron and Rollernet datasets, we still do not know how then to find a $\gamma$-matching of the kernel that is better than the output of the $2$-approximation;

• •

in particular, we do not know if the approximation factor can be improved.

6 Conclusion and perspectives

We introduce the notion of temporal matching in a link stream. Unfortunately, the problem of computing a temporal matching of maximum size, called $\gamma$-matching, turns out to be NP-hard. We then show a kernelization algorithm for $\gamma$-matching parameterized by the size of the solution. Our process produces quadratic kernels. On the way to obtaining the kernelization algorithm, we also provide a $2$-approximation algorithm for $\gamma$-matching. We believe that the same techniques extend to a large class of hitting set problems in link streams.

Acknowledgements: We are grateful to Clémence Magnien for helpful pointers and valuable pieces of advice. We are grateful to the anonymous referees for helpful comments which greatly improve the paper. In particular, we are grateful to the referee who coined the name of time-compression, whose usage greatly improves the paper. For financial support, we are grateful to: Thales Communications & Security, project TCS.DJ.2015-432; Agence Nationale de la Recherche Technique, project 2016.0097; Centre National de la Recherche Scientifique, project INS2I.GraphGPU.