Learning Graphs from Noisy Epidemic Cascades

TL;DR

This paper develops algorithms to learn the structure and weights of graphs from noisy epidemic cascade data, addressing both limited and extreme noise scenarios with provable optimality and efficiency.

Contribution

It introduces the first polynomial-time algorithms for graph learning from noisy epidemic data, including structure and weight recovery in various noise settings and graph classes.

Findings

Algorithm for bidirectional trees in extreme-noise setting is nearly optimal.

Algorithms work for any noise distribution without variance restrictions.

Extends to general graphs with exponential time, proving solvability.

Abstract

We consider the problem of learning the weighted edges of a graph by observing the noisy times of infection for multiple epidemic cascades on this graph. Past work has considered this problem when the cascade information, i.e., infection times, are known exactly. Though the noisy setting is well motivated by many epidemic processes (e.g., most human epidemics), to the best of our knowledge, very little is known about when it is solvable. Previous work on the no-noise setting critically uses the ordering information. If noise can reverse this -- a node's reported (noisy) infection time comes after the reported infection time of some node it infected -- then we are unable to see how previous results can be extended. We therefore tackle two versions of the noisy setting: the limited-noise setting, where we know noisy times of infections, and the extreme-noise setting, in which we only know whether or not a node was infected. We provide a polynomial time algorithm for recovering the structure of bidirectional trees in the extreme-noise setting, and show our algorithm almost matches lower bounds established in the no-noise setting, and hence is optimal up to log-factors. We extend our results for general degree-bounded graphs, where again we show that our (poly-time) algorithm can recover the structure of the graph with optimal sample complexity. We also provide the first efficient algorithm to learn the weights of the bidirectional tree in the limited-noise setting. Finally, we give a polynomial time algorithm for learning the weights of general bounded-degree graphs in the limited-noise setting. This algorithm extends to general graphs (at the price of exponential running time), proving the problem is solvable in the general case. All our algorithms work for any noise distribution, without any restriction on the variance.

Tables

Table 1. Table 1 : Notations

$G=(V,E)$	Graph $G$, $V$ set of nodes, $E$ set of edges.
$N$	Number of nodes in the graph.
$T_i^m$	Random variable for the actual time of infection of node $i$ during cascade $m$.
$n_i^m$	Noise of node $i$ during cascade $m$.
$T_i^{{}_{}{}^{\prime }m}=T_i^m+n_i^m$	Random variable for the noisy time of infection of node $i$ during cascade $m$.
$I_i^m$	Random boolean variable. ($I_i^{{}_{}{}^{\prime }m}=True\iff$ node $i$ was infected during cascade $m$).
$p_{ij}$	Weight of edge $(i,j)$, corresponding to the probability that $i$ infects $j$.

Equations

$$\widehat{p_{ij}}=\frac{\text{Number of times j becomes infected one time step after i}}{\text{Number of times i was infected before j}}.$$

$$\mathcal{L}(T,P_{ij})$$

$$\cdot \underset{\begin{array}{c}\text{Probability that i was not}\\ \text{infected before ti′.}\end{array}}{\underbrace{\left(\prod _{j;t_j<t_i-1}(1-p_{ji})\right)}}\cdot \underset{\begin{array}{c}\text{Probability that i was}\\ \text{infected at ti′.}\end{array}}{\underbrace{\left(1-\prod _{j;t_j=t_i-1}(1-p_{ji})\right)}})$$

$$=\log \left(\frac{1}{N}\right)+\log \left(\sum _{\begin{array}{c}(t_1,\dots ,t_N)\le \\ (t_1^{\prime }-1,\dots ,t_N^{\prime }-1)\end{array}}\prod _{1\le i\le N}n(t_i^{\prime }-t_i)\left(\prod _{j;t_j<t_i-1}(1-p_{ji})\right)\cdot \left(1-\prod _{j;t_j=t_i-1}(1-p_{ji})\right)\right)$$

$${\hat{h}}_{i,j}{\to }_{M\to \infty }\mathbb{P}(I_i^m\&I_j^m):=h_{i,j}.$$

$$\forall r\in \{0,d-1\},h_{i,j}<h_{u_r,ur+1}.$$

$$\forall (i,j,k)\in {\mathcal{H}}_3,{\hat{h}}_{i,j}>{\hat{h}}_{i,k}\text{ and }{\hat{h}}_{j,k}>{\hat{h}}_{i,k},$$

$$\forall r\in \{0,\dots ,d-1\},{\hat{h}}_{u_r,u_{r+1}}>{\hat{h}}_{u_0,u_d}.$$

$$\forall (i,j,k)\in {\mathcal{H}}_3,{\hat{h}}_{i,j}>{\hat{h}}_{i,k}\text{ and }{\hat{h}}_{j,k}>{\hat{h}}_{i,k},$$

$$\forall (i,j,k)\in {\mathcal{H}}_3,{\hat{h}}_{i,j}>{\hat{h}}_{i,k}\text{ and }{\hat{h}}_{j,k}>{\hat{h}}_{i,k}.$$

$$P_{\text{triplet identified}}$$

$$\ge \mathbb{P}(\text{i was a source, i infected j, j did not infect k})$$

$$+\mathbb{P}(\text{j was a source, j infected i, j did not infect k})$$

$$\ge \frac{1}{N}\cdot p_{ij}\cdot (1-p_{jk})+\frac{1}{N}\cdot p_{ji}\cdot (1-p_{jk})$$

$$\ge \frac{1}{N}{p}_{min}(1-p_{max}).$$

$$\mathbb{P}({\hat{h}}_{i,j}={\hat{h}}_{i,k})$$

$$\le e^{-\frac{M}{N}{p}_{min}(1-p_{max})}$$

$$\le \frac{\delta }{N^2}.$$

$$\mathbb{P}\left(\bigcup _{(i,j,k)\in {\mathcal{H}}_3}{\hat{h}}_{i,j}={\hat{h}}_{i,k}\right)$$

$$<N^2\cdot \frac{\delta }{N^2}$$

$$\le \delta .$$

$$H(G)$$

$$\le I(G;T)+H(G|\hat{G})$$

$$\le M\cdot I(T^1;T^{{}^{\prime }1})+H(G|\hat{G})$$

$$I(X,Y)\le H(X)$$

$$\le M\cdot \sum _{i=1}^{N}H(T_i^1)+(1+P_e\log (|\mathcal{G}|))$$

$$M\ge \frac{(1-P_e)(N-2)\log (N)-1}{N\cdot H(T_i^1)}=\Omega \left(\frac{\log (N)}{H(T_i^1)}\right)$$

$${\hat{f}}_{i<j}$$

$${\hat{g}}_{i,\bcancel{j}}$$

$$f_{i<j}$$

$$g_{i,\bcancel{j}}$$

$$f_{i<j}$$

$$+\sum _{l=1}^{d-1}{\mathcal{P}}_{\bcancel{i},\bcancel{j}}(\to u_l)\cdot p_{u_l\to i}\cdot p_{u_l\to j}\cdot s_{2l-d+1}.$$

$${\hat{g}}_{i,\bcancel{j}}$$

$$f_{i<j}$$

$$g_{i,\bcancel{j}}$$

$$f_{i<j}$$

$$=\mathbb{P}(\text{i got infected before any nodes on the path from i to j,}$$

$$\text{then infected j, and the noise did not flip the times of infection})$$

Full text

1 Introduction

Epidemic models accurately represent (among other processes) the spread of diseases, information (rumors, viral videos, news stories, etc.), the spread of malevolent agents in a network (computer viruses, malicious apps, etc.), or even biological processes (pathways in cell signaling networks, chains of activation in the gene regulatory network, etc.).

We focus on epidemics that spread on an underlying graph [30], as opposed to the fully mixed models introduced in the early literature [4].

Most settings assume we know the underlying graph and aim to study properties of the spread. Much work has been done in detection [2, 3, 27, 26, 25, 24, 21], where the goal is to decide whether or not there is indeed an infection. This problem is of importance in deciding whether or not a computer network is under attack, for instance, or whether a product gets sold through word-of-mouth or thanks to the advertisement campaign (or both [28]). More specifically, the problem of source detection [32, 33, 31, 34, 35] or obfuscation [11, 13, 12] has been extensively studied. On the other side of the spectrum, both experimental and theoretical work has tackled the problem of modeling [7, 36, 17], predicting the growth [6, 38], and controlling the spread of epidemics [9, 10, 18, 14].

In this work, we take the opposite approach: assuming we know some properties of the spread, can we recover the underlying graph? The early works on this subject proposed a few heuristics and experimentally proved their effectiveness [16, 19]. Netrapalli et al. [29] established the first theoretical guarantees for this problem for discrete-time infections. They proved one can recover the edges of any graph with correlation decay, with access to the times of infection for multiple cascades spreading on the graph. They introduced a likelihood, proved it decouples into convex subproblems, and demonstrated that the edges of the graph can therefore be obtained efficiently. They also proved a sample complexity lower bound and showed their method is within a log factor of it. Abrahao et al. [1] also introduced a method of solving this problem, this time for a more realistic, continuous-time infection model, through learning only the first edge of each cascade. Zarezade et al. [37] proposed a first experimental attempt to tackle the case of correlated cascades using Hawkes processes. Khim et al. [22] extended the theoretical results to the case where the the cascades spreading on the graph are not independent, which required completely new machinery involving martingales and weighted Pólya urns.

All the results above assume we have perfect knowledge of the properties of the spread we use to reconstruct the graph. For most of the literature, those are the times of infection for all nodes for each cascade. This assumption may hold for online epidemics, as information is usually dated (for instance, posts or retweets on social networks have time stamps). For human networks, however, this assumption is often unrealistic: official diagnosis (and hence recording by any tracking entity such as the CDC) may come days, weeks, or in important examples such as HIV, years after the actual moment of infection. Moreover, this can be highly variable from person to person, hence the infector is often diagnosed after the infectee. Similar issues arise with biological networks: we only know the expression of a gene when a measure is taken, which can happen after a typically arbitrary delay.

We therefore develop a method for learning the graph of epidemics with noisy times of infection. We demonstrate that past approaches are unusable, due to the fact that even small levels of noise are typically enough to cause order-of-diagnosis to differ from order-of-infection. We develop new techniques to deal with this setting, and prove our algorithm can reliably learn the edges of a tree in the limited-noise setting, for any noise distribution. We also show we can learn the structure of any bounded degree graph from a very weak observation model, in an sample-optimal fashion (up to log-factors). We finally provide an algorithm which learns the weights of any bounded-degree graph in the limited-noise setting.

1.1 Model

We observe epidemics spreading on a graph, and aim to reconstruct the graph structure from noisy estimates of the times of infection. In this section, we specify the exact propagation model, the noisy observation model, and the two learning tasks this work tackles.

Propagation model: We consider a particular variant of the independent cascade model, close to the one-step model introduced by [15] and further studied by [20]. The epidemic spreads in discrete time on a weighted directed graph $G=(V,E)$, where parents can infect their children with probability equal to the weight of the edge between them, but children cannot infect their parents. We allow bidirectional edges: it is possible that both $(i,j)\in E$ and $(j,i)\in E$, possibly with different weights. For each edge $(i,j)\in E$, the corresponding weight $p_{ij}$ is such that $0<p_{min}\leq p_{ij}\leq p_{max}<1$.

This process is an instance of a $Susceptible\rightarrow Infected\rightarrow Removed$ (SIR) process. Each node starts out in the susceptible state. As in [1], each cascade $m$ starts at a positive time 111Most of the literature considers the initial time of infection to be 0. This is because when we have access to the exact times of infection, we can make this assumption without loss of generality. In our case, it would imply we know exactly when an outbreak started, which is usually not the case. on a unique node source node, picked uniformly among the nodes of the graph. Once the source becomes infected, it is removed from the graph, and if it has children, each is infected at the next time step independently according to a probability specified by the weight of the edge shared with the source.

The process ends when there are no newly infected nodes (either because no infection happened during the previous time step, in which case some nodes may never be infected, or because all the nodes of the graph are removed). One realization of this process from start to finish is called a cascade. If two nodes are infected during the same cascade, we say that they are co-infected for this cascade. This process is illustrated in Figure 1.

Observation model: Let $T_{i}^{m}$ be a random variable corresponding to the time of infection of node $i$ during cascade $m$, and let $t_{i}^{m}$ be its realization (if $i$ stays in the susceptible state during cascade $m$, we have $t_{i}^{m}=\infty$). We introduce three observation models.

In the no-noise setting, we have access to the exact times of infection $T_{i}^{m}$.

In the limited-noise setting, we never get to observe the exact times of infection $T_{i}^{m}$, but only a noisy version $T^{{}^{\prime}m}_{i}=T^{m}_{i}+n_{i}^{m}$ (with realization $t_{i}^{{}^{\prime}m}$), where all the $n_{i}^{m}$ are i.i.d., and represent the noise added to the $T^{m}_{i}$. We assume $n_{i}^{m}$ follows a known distribution $\mathcal{D}$. The only restriction we put on $\mathcal{D}$ is that it cannot have infinite value (i.e., $t^{{}^{\prime}m}_{i}=\infty\Leftrightarrow t^{m}_{i}=\infty$, and we know for a fact when nodes have been infected or not).

In the extreme-noise setting, we take the previous setting to the extreme, and we assume that instead of having access to the noisy times of infection $T_{i}^{{}^{\prime}m}$, we only have access to the infection status of the nodes $I_{i}^{m}$. We know $I_{i}^{m}=True$ if $i$ was infected during cascade $m$, and $I_{i}^{m}=False$ otherwise. Note that $T_{i}^{{}^{\prime}m}<\infty\Leftrightarrow I_{i}^{m}=True$, so we can always deduce the infection status from the noisy times of infection. However, we cannot guess the noisy times of infection from the infection status: the (noisy) times of infections contain strictly more information than the infection status.

For these three settings, we call a sample the vector of all observations for the cascade $m$. In the no-noise setting, this is the extended-integer vector $\{t_{i}^{m}\}_{i\in V}$. In the limited-noise setting, this is the extended-integer vector $\{t_{i}^{{}^{\prime}m}\}_{i\in V}$. In the extreme-noise setting, this is the boolean vector corresponding to the realization of $\{I_{i}^{m}\}_{i\in V}$. We also use the notation $T^{\prime}=\{T_{i}^{{}^{\prime}m}\}_{i\in V}^{m=1\dots M}$ (respectively $t^{\prime}=\{t_{i}^{{}^{\prime}m}\}_{i\in V}^{m=1\dots M}$) for the matrix representing the random variable (respectively the realizations) of all the samples.

Learning tasks: We focus on two different learning tasks. When we learn the structure of a graph, it means that for any two nodes $i$ and $j$, we can decide whether or not there exists an edge between these two nodes (whatever its direction). When we learn the weights of the graph, it means that for every two nodes $i$ and $j$, we learn the exact value222When $(i,j)\notin E$, we have $p_{ij}=0$. of both $p_{ij}$ and $p_{ji}$ up to precision $\epsilon$.

1.2 Why is it a hard problem?

1.2.1 Counting approaches

Most approaches in the no-noise setting relate to counting. In our setting, for instance, a natural (and consistent) estimator for $p_{ij}$ is to count how often an infection occurred along an edge, and divide it by how often such an infection could have happened:

[TABLE]

In the no-noise setting, $j$ could only have been infected by a node signaling exactly one time step before $j$. However, in the limited-noise setting, $j$ signaling its infection one time step after $i$ could stem from a variety of scenarios:

• •

$i$ could have indeed infected $j$: cases a), b) and c) of Figure LABEL:fig:second above.

• •

$j$ could have infected $i$, but the noise flipped the order of signaling: cases d), e) and f).

• •

No infection happen between $i$ and $j$, and the probability of infectin depends mainly on another node $k$: cases g), e) and f). This could happen for any other node $k$ in the graph.

The natural estimator introduced earlier is therefore not consistent anymore; instead, it tends to a quantity which depends on $p_{ij}$, but also $p_{ji}$, and $p_{ik},p_{ki},p_{jk},p_{kj}$ as well, for all the other nodes $k$ in the graph. By counting the number of times $j$ became infected one time step after $i$, we are not counting the number of infections along the edge $(i,j)$ anymore, but instead a mixture of all the scenarios described above, which not only include the cases where $j$ infected $i$, but also events in which the cascade spread through another node $k$, and the edge $(i,j)$ was irrelevant to the process. Using this estimator, or any obvious (to us) extension of it, would not only imply learning the wrong weights for the edges, but also learning edges when there are no edges. Our first contribution is therefore to design a new set of estimators, from which we can deduce the value of $p_{ij}$ (Sections 2.3 and 3.2).

Adding noise in the time of infection not only reverses the cascade chronology, it also exponentially increased the number of possible infection patterns that could have happened. Bounding the realm of possibilities is therefore our second step towards solving the problem (Section 2.1).

1.2.2 Max-likelihood approaches

Another common approach is to use likelihood-based methods. For instance, in [29], the authors develop a max-likelihood-based approach to learn the edges of the graph. They prove the log-likelihood has desirable properties: it decouples into only one local problem for each node, and this local problem is convex (up to the change of variable $\theta_{ij}=-\log(1-p_{ij})$):

[TABLE]

In our setting, the log-likelihood has none of these properties. It is not convex, and it is unclear any method other than brute force could find its maximum. Moreover, it does not decouple anymore, and even computing the log-likelihood itself takes exponential time.

[TABLE]

When dealing with hidden variables, a common technique would be to use the Expectation-Maximization algorithm [8]. However, in our setting, the number of hidden states is $\displaystyle\prod_{i=1}^{N}t^{\prime}_{i}$, which can be as large as $(N-1)^{N}$. This prohibits any realistic use of the Expectation-Maximization algorithm for networks with more than twelve nodes. Moreover, except for the recent contributions [23], very little is known about the theoretical convergence of the Expectation-Maximization algorithm.

1.3 Contributions

The contributions of this article are multiple:

• •

To the best of our knowledge, we are the first to tackle the problem of learning the edges of a graph from noisy times of infection, a simple but natural extension of a well-known problem.

• •

We provide the first efficient algorithm for learning the structure and weights of a bidirectional tree in this setting. We also establish a tree-specific lower bound which shows that our algorithm is sample-optimal (up to log-factors) for learning the structure of the tree (Section 2).

• •

We prove it is possible to learn the structure of any bounded-degree graph in the extreme setting for which we only have access to the infection status (i.e., whether or not a node was infected). Moreover, we can do so with almost optimal sample complexity, according to the bound established in [29].

• •

We provide polynomial algorithms for learning the weights of bounded degree graphs.

• •

Finally, we extend the results from bounded-degree graphs to general graphs. This proves the problem is solvable under any noise distribution, although the exponential sample complexity and running time prohibits any use of this algorithm in practice (Section 3.2).

2 Learning bidirectional trees

The bidirectional tree is the simplest example which illustrates some of the difficulties of the noisy setting. Indeed, for a directed tree, the true sequence of infections can be reconstructed, and we can use techniques from the no-noise setting. For a bidirectional tree, those techniques cannot be extended. However, the uniqueness of paths in the bidirectional tree still makes this problem considerably easier than the general setting. We therefore start by presenting a solution for the bidirectional tree. The key ideas here generalize to the neighborhood-based decomposition we introduce below, which forms our key conceptual approach for the general problem.

This section contains three contributions. First, we show how to learn the structure of a tree using only the infection status, i.e., what we call the extreme-noise setting (Section 2.1). For each cascade, we only know which nodes were infected. We show this contains enough information to learn the structure of bidirectional tree. Second, we establish a lower bound for the no-noise setting, and show our algorithm has the same dependency in the number of nodes $N$ as this lower bound (up to log-factors). In other words, for the task of learning the structure of any tree, an optimal algorithm in the no-noise setting would need as many cascades as our algorithm needs in the extreme-noise setting (up to log-factors).

Finally, we show how we can leverage this learned structure to learn the weights of the tree, this time when we have noisy access to the times of infection, i.e., the limited-noise setting (Section 2.3). We provide sample complexity for this task.

2.1 Tree structure

As illustrated in Section 1.2, the number of edges that could exist is much higher in the limited-noise setting than the number of actual edges in the tree. Our first key contribution is therefore to introduce a new estimator, $\hat{h}_{ij}$, which keeps track of the fraction of cascades for which $i$ and $j$ were both infected. This estimator can therefore be computed only with the infection status in the extreme-noise setting. Using this estimator, we show that in the specific case where the graph is a tree, we learn the structure of this tree, $i.e.$ whether or not both $p_{ij}=p_{ij}=0$.

Our algorithm for learning the edges of the tree relies on one central observation: $h_{i,j}$ achieves a kind of local maximum if there is an edge between $i$ and $j$ (Lemma 1). This observation relies heavily on the fact that there is uniqueness of paths on a tree. Let us now dive into the proof.

Definition 1**.**

Let $\hat{h}_{i,j}$ be the fraction of cascades in which both $i$ and $j$ became infected. We have:

[TABLE]

We now show that the limit $h_{i,j}$ of the estimator $\hat{h}_{i,j}$ satisfies a local maximum property on the edges of the tree:

Lemma 1**.**

If $i$ and $j$ are not neighbors, let $(u_{0},u_{1},\dots,u_{d})$ be the path between them, with $u_{0}=i$, $u_{d}=j$, and $d>1$. Then:

[TABLE]

Proof.

We consider the case in which both $i$ and $j$ have been infected. There is a unique source of infection and a unique path between $i$ and $j$. Therefore, all the nodes on the path from $i$ to $j$ must have been infected as well. In particular, both $u_{r}$ and $u_{r+1}$ were infected. This shows $I^{m}_{i}\,\,\&\,\,I^{m}_{j}\Rightarrow I^{m}_{u_{r}}\,\,\&\,\,I^{m}_{u_{r+1}}$, so $\mathbb{P}(I^{m}_{i}\,\,\&\,\,I^{m}_{j})\leq\mathbb{P}(I^{m}_{u_{r}}\,\,\&\,\,I^{m}_{u_{r+1}})$, and therefore $h_{i,j}\leq h_{u_{r},u_{r+1}}$.

What’s more, every time $u_{r}$ and $u_{r+1}$ became infected, at least one more infection along an edge must have occurred in order for $j$ to become infected as well. This occurred with probability at most $p_{max}<1$. Therefore, $h_{i,j}=\mathbb{P}(I^{m}_{i}\,\,\&\,\,I^{m}_{j})\leq p_{max}\cdot\mathbb{P}(I^{m}_{u_{r}}\,\,\&\,\,I^{m}_{u_{r+1}})=p_{max}\cdot h_{u_{r},u_{r+1}}$. We conclude $h_{i,j}<h_{u_{r},u_{r+1}}$.

∎

This simple lemma allows us to design Algorithm 1. Indeed, suppose we have access to all the limits $h_{i,j}$. By ordering them in decreasing order, we can deduce the structure of the tree by greedily adding every edge unless it forms a cycle333This algorithm is very similar in spirit to Kruskal’s algorithm for finding the maximum spanning tree .

We show that if we have access to the limits $h_{i,j}$ of the estimators $\hat{h}_{i,j}$, the algorithm above correctly find the structure of the tree.

Lemma 2**.**

Algorithm 1 correctly finds all the $N-1$ pairs $(i,j)$ such that there exists at least one directed edge between $i$ and $j$.

Proof.

We show that in the for-loop at line 5, we add an edge to $edges\_tree$ if and only if this edge was a real edge in the original tree. We prove it by induction on the elements of the sorted list $pairs\_h\_edge$.

When no element has been selected, the proposition is trivially true.

Suppose now that $t$ elements of $pairs\_h\_edge$ have been examined so far. Let $(\sim,(i,j))$ be the $t+1^{th}$ element. Two cases arise:

$i$ and $j$ are not neighbors. Let $(u_{0},\dots,u_{d})$ be the path between them, with $u_{0}=i$ and $u_{d}=j$. In this case, using Lemma 1, $\forall r,\,h_{u_{r},u_{r+1}}>h_{i,j}$. In other words, all the pairs $(u_{r},u_{r+1})$ have already been considered by the algorithm. By induction, we have kept all of them in $edges\_tree$. Therefore, adding the pair $(i,j)$ would form a cycle. This pair is not kept in $edges\_tree$, which is what we wanted since it is not an edge in the original tree. 2. 2.

$i$ and $j$ are neighbors. Suppose that adding this pair forms a cycle. Then there is a sequence $(v_{0}=i,\dots,v_{d}=j)$ of nodes such that $h_{v_{k},v_{k+1}}$ were all bigger than $h_{i,j}$, and the pairs $(v_{k},v_{k+1})$ were kept by the algorithm for all $k$. However, by uniqueness of paths in a tree, there exists a pair $(v_{a},v_{a+1})$ such that the path connecting $v_{a}$ and $v_{a+1}$ in the original tree goes through $(i,j)$. Using Lemma 1, this means $h_{i,j}>h_{v_{a},v_{a+1}}$, which is a contradiction. Therefore, adding this pair in $edges\_tree$ does not form a cycle. This pair is kept in $edges\_tree$.

Therefore, this algorithm keeps all the edges, and only the edges of the tree, so it recovers the tree structure.

∎

We next quantify how many cascades $M$ are needed for Algorithm 1 to be correct if we replace the $\{h_{i,j}\}_{i,j\in V}$ by their estimates $\{\hat{h}_{i,j}\}_{i,j\in V}$. We note that we do not require $\hat{h}_{i,j}$ to be close to their limit, but only need the order of the $\hat{h}_{i,j}$ to be the same as the order of the $h_{i,j}$. We identify events which guarantee that the order is the same (Corollary 1):

Definition 2**.**

Let $\mathcal{H}_{3}:=\{(i,j,k)\in\{1,\dots,N\}^{3},p_{ij}+p_{ji}>0\,\,\&\,\,p_{jk}+p_{jk}>0\}$ be the set of triplets of nodes such that at least one directed edge exists between the first and the second node, as well as between the second and the third node.

Proposition 1**.**

If:

[TABLE]

then for all paths $(u_{0},\dots,u_{d})$ in the tree, with $d>1$, we have:

[TABLE]

Proof.

For $r\in\{0,\dots,d-2\}$, we have by hypothesis $\hat{h}_{u_{r},u_{r+1}}>\hat{h}_{u_{r},u_{r+2}}$. Now, we recall that $\hat{h}_{u_{0},u_{d}}$ is the number of cascades for which both $u_{0}$ and $u_{d}$ were infected. By uniqueness of paths in the tree, every time both $u_{0}$ and $u_{d}$ were infected, both $u_{r}$ and $u_{r+2}$ must have been infected as well. This shows that $\hat{h}_{u_{0},u_{d}}\leq\hat{h}_{u_{r},u_{r+2}}$. Notice that this is a deterministic property, not an asymptotic property. Therefore, $\hat{h}_{u_{r},u_{r+1}}>\hat{h}_{u_{r},u_{r+2}}\geq\hat{h}_{u_{0},u_{d}}$.

For $r=d-1$, we follow an identical reasoning, but with $\hat{h}_{u_{r},u_{r+1}}>\hat{h}_{u_{r-1},u_{r+1}}$.

Corollary 1**.**

If:

[TABLE]

then the correctness of Algorithm 1 is preserved when given $\hat{h}$ as input instead of h.

In other words, Algorithm 1 outputs a correct set of undirected edges with finite samples.

Proof.

According to Proposition 1, for all paths $(u_{0},\dots,u_{d})$ in the tree, with $d>1$, we have that $\forall r\in\{0,\dots,d-1\},\,\hat{h}_{u_{r},u_{r+1}}>\hat{h}_{u_{0},u_{d}}$. As shown in the proof of Lemma 2, this is the only property of the input needed in order to yield the correct output.

Proposition 2**.**

With $M=\frac{N\left(\log\left(\frac{1}{\delta}\right)+2\log(N)\right)}{p_{min}(1-p_{max})}$ cascades, with probability at least $1-\delta$, we have:

[TABLE]

Proof.

Let us consider one triplet $(i,j,k)$ in $\mathcal{H}_{3}$. We recall that $\hat{h}_{i,k}$ is the number of cascades for which both $i$ and $k$ were infected. Since the only path from $i$ to $k$ is through $j$, we always have that $\hat{h}_{i,j}\geq\hat{h}_{i,k}\text{ and }\hat{h}_{j,k}\geq\hat{h}_{i,k}$. We notice that to obtain $\hat{h}_{i,j}>\hat{h}_{i,k}$, we only need one cascade for which both $i$ and $j$ got infected, but not $k$. We lower bound the probability $P_{\text{triplet identified}}$ of this cascade happening. For each cascade $m$, we have:

[TABLE]

The probability that this event never occurs during the $M$ cascades is upper bounded by:

[TABLE]

Now, there are $N-1$ edges in a tree, therefore $|\mathcal{H}_{3}|\leq(N-1)^{2}<N^{2}$. By union bound:

[TABLE]

Notice that $\mathcal{H}_{3}$ contains both $(i,j,k)$ and $(k,j,i)$. We have therefore proven that with probability at least $1-\delta$, when considering $M=\frac{N\left(\log\left(\frac{1}{\delta}\right)+2\log(N)\right)}{p_{min}(1-p_{max})}$ cascades, we have $\forall(i,j,k)\in\mathcal{H}_{3},\,\,\hat{h}_{i,j}>\hat{h}_{i,k}\text{ and }\hat{h}_{j,k}>\hat{h}_{i,k}.$

Putting together Proposition 2 and Corollary 1, we obtain our first theorem for learning the undirected edges with finite samples:

Theorem 1**.**

With $M=\frac{N\left(\log\left(\frac{1}{\delta}\right)+2\log(N)\right)}{p_{min}(1-p_{max})}$ cascades, with probability at least $1-\delta$, we can learn the structure of a any bidirectional tree in the extreme-noise setting, i.e., when we only have access to the infection status of the nodes.

2.2 Lower bound

In this section, we prove a lower bound for trees in the no-noise setting. With very minor adjustments, we adapt the lower bound of [29]. Since for a general tree, the max degree can be up to $N-1$, we design a lower bound which is independent from the max-degree. Let $G$ be a tree drawn uniformly from $\mathcal{G}$, the set of all possible trees on $N$ nodes, and $\hat{G}$ be the reconstructed graph from the times of infection. $G\leftrightarrow T\leftrightarrow\hat{G}$ therefore forms a Markov chain. We have:

[TABLE]

Since $G$ is drawn uniformly from $\mathcal{G}$, $H(G)=\log(|\mathcal{G}|)$. There are $N^{N-2}$ trees on $N$ nodes, according to Cayley’s formula [5], so $H(G)=(N-2)\cdot\log(N)$.

In conclusion:

[TABLE]

Using the same kind of techniques as in [29], we can assume $H(T^{1}_{i})\sim\frac{\log(N)}{N}$. Therefore:

Theorem 2**.**

In the no-noise setting, we need $M=\Omega\left(N\right)$ cascades to learn the tree structure.

In our extreme-noise setting, when we have only access to the infection status of the nodes, we can learn the tree structure with the same sample complexity (up to log-factors) as the no-noise setting!

2.3 Tree weights

In this section, we assume we are in the limited-noise setting, and we have access to the times of infection. We also assume we have already learned the structure of the tree.

Once we have reduced the set of possible edges by learning the structure of the bidirectional tree, learning the weights of the edges is still non-trivial. Indeed, from $T^{{}^{\prime}m}_{i}$ and $T^{{}^{\prime}m}_{j}$, it is still impossible to know whether this sample is useful for estimating $p_{ij}$ (case when $i$ infected $j$), or whether we should use this sample for estimating $p_{ji}$ instead (case when $j$ infected $i$). What is more, we only get one sample per node and per cascade, so it is impossible to know what really happened during that cascade. However, knowing the distribution of the noise, it is possible to compute the probability that the noise maintained the order of infections. Using this information and the reduced set of known undirected edges, we can compute two sets of $N(N-1)$ estimators, from which it is possible to infer the weights of all edges in the tree.

We introduce these two sets of $N(N-1)$ estimators, or, in other words, two estimators for each directed edge. These estimators tend to multivariate polynomials of the weights of most edges of the tree. Thus in general these polynomials have exponentially many terms; however, when $i$ and $j$ are neighbors, it is possible to express them concisely using a quantity $\mathcal{P}_{\bcancel{j}}(\rightarrow i)$, which we define formally below. This succinct representation is the key idea we exploit to solve the resulting system of equations.

Once we know the structure of the bidirectional tree, we can consider the four estimators for each undirected edge (two estimators for each directed edge). They form a system of four equations and four unknowns, which we solve to obtain the weights of the edges.

Definition 3**.**

$\mathcal{P}_{\bcancel{i}}(\rightarrow j)$* is the probability that $j$ became infected before any node on the path from $j$ to $i$, including $i$, became infected.*

We now introduce the estimators:

Definition 4**.**

We introduce 2 sets of $N(N-1)$ estimators:

[TABLE]

By the law of large numbers, as the number of cascades scales, $\hat{f}_{i<j}$ tends to $f_{i<j}$ and $\hat{g}_{i,\bcancel{j}}$ to $g_{i,\bcancel{j}}$, where

[TABLE]

We now compute the exact values of these two quantities. Let us assume the (unique) path between $i$ and $j$ has length $d$. We call $(u_{0},\dots,u_{d})$ the set of nodes on the path from $i$ to $j$, with $u_{0}=i$ and $u_{d}=j$. We then have:

Lemma 3**.**

Recall $f_{i<j}$ and $g_{i,\bcancel{j}}$ are the expectation of the estimators defined above. We have:

[TABLE]

What’s more, when $i$ and $j$ are neighbors (which implies $d=1$), the expressions simplify to:

[TABLE]

Proof.

[TABLE]

This expression is involved in general. However, if $i$ and $j$ are neighbors, then there are no nodes $u_{l}$ on the path between $i$ and $j$, other than $i$ and $j$ themselves. What’s more, $p_{i\rightarrow j}=p_{ij}$, and $d=1$. Therefore:

[TABLE]

Let us now focus on $g_{i,\bcancel{j}}$:

[TABLE]

As before, this expression is complex in general, but simplifies if $i$ and $j$ are neighbors, in which case:

[TABLE]

∎

Using the simplified expression only for when $i$ and $j$ are neighbors, we obtain:

Proposition 3**.**

If we know $(i,j)$ is an edge in the original tree, then the probability of infection along this edge is given by:

[TABLE]

Proof.

According to Lemma 3, we had four second-order equations, with 4 unknowns: $p_{ij}$, $p_{ji}$, $\mathcal{P}_{\bcancel{j}}(\rightarrow i)$ and $\mathcal{P}_{\bcancel{i}}(\rightarrow j)$. We solve it, and obtain the wanted result. See Appendix A for details.

∎

Combining all the pieces, we obtain our first theorem for infinite samples:

Theorem 3**.**

It is possible to learn the weights of a bidirectional tree in the limited-noise setting.

Now that we have proven the problem is solvable, we establish the number of samples needed to learn the weights with the method above.

Lemma 4**.**

With $M=\frac{N^{2}}{\epsilon^{2}}\log\left(\frac{6}{\delta}\right)\frac{\left((s_{0}^{2}-s_{2}^{2}+s_{0}+s_{2})p_{max}+s_{0}+s_{2}\right)^{2}}{(s_{0}^{2}-s_{2}^{2})^{2}}$ samples, with probability at least $1-\delta$, we have:

[TABLE]

Proof.

Using Hoeffding’s inequality:

[TABLE]

Choosing $M=\frac{1}{\epsilon_{1}^{2}}\log\left(\frac{6}{\delta}\right)$, we have that with probability at least $1-\delta$, all the following hold:

[TABLE]

Hence, with probability at least $1-\delta$, we have (see Appendix A for details):

[TABLE]

We use the results from Lemma 3 to bound the denominator by $\frac{s_{0}^{2}-s_{2}^{2}}{N}$. In the end, we obtain:

[TABLE]

We choose $\epsilon_{1}=\frac{\epsilon}{N}\frac{s_{0}^{2}-s_{2}^{2}}{(s_{0}^{2}-s_{2}^{2}+s_{0}+s_{2})p_{max}+s_{0}+s_{2}}$. Therefore:

With $M=\frac{N^{2}}{\epsilon^{2}}\log\left(\frac{6}{\delta}\right)\frac{\left((s_{0}^{2}-s_{2}^{2}+s_{0}+s_{2})p_{max}+s_{0}+s_{2}\right)^{2}}{(s_{0}^{2}-s_{2}^{2})^{2}}$ samples, with probability at least $1-\delta$, we have $|\hat{p}_{ij}-p_{ij}|\leq\epsilon$.

∎

By a union bound on all the weights of the tree, knowing there are at most $2N(N-1)<2N^{2}$ directed edges in a directed tree, we obtain the following sample complexity:

Theorem 4**.**

With $M=\frac{N^{2}}{\epsilon^{2}}\log\left(\frac{12N^{2}}{\delta}\right)\frac{\left((s_{0}^{2}-s_{2}^{2}+s_{0}+s_{2})p_{max}+s_{0}+s_{2}\right)^{2}}{(s_{0}^{2}-s_{2}^{2})^{2}}$ cascades, with probability $1-\delta$, we can learn all the weights of the edges of a bidirectional tree in the limited-noise setting, i.e., when we only have access to the noisy times of infection.

3 Bounded-degree graphs

In the previous section, the algorithm presented relies heavily on the uniqueness of paths. This property implies that we can deduce the edges from the nodes which are co-infected the most often. However, this is not true for a general bounded-degree graph. In Figure 4, we can see that the two nodes $i$ and $j$ would be co-infected frequently despite not sharing an edge. This makes the task of finding the structure much more challenging than for the bidirectional tree.

In this section, we show how the main ideas for learning the structure of the bidirectional tree can be extended for learning the structure of general bounded-degree graphs, in the extreme-noise setting, with almost optimal sample complexity. The framework for learning the weights of the edges in the limited-noise setting is - to the best of our knowledge - not extendable to general bounded-degree graphs; we therefore develop a new algorithm to learn the weights for general bounded-degree graphs.

3.1 Bounded-degree structure

In the previous section, we introduced the estimator $\hat{h}_{i,j}$, which records the fraction of cascades for which both $i$ and $j$ are infected. From a local maximum property of this estimator, we deduced the structure of the tree, in a sample efficient fashion. Indeed, if there exists a path between $i$ and $k$, and the first edge on this path is $(i,j)$, then if $i$ and $k$ are infected, $j$ must have been infected as well.

We want to build on this idea for a bounded-degree graph of maximum degree $d$. However, for such a graph, there may be multiple paths leading from $i$ to $j$, and we cannot guarantee a single node will be infected each time. However, if $i$ is a node, $\mathcal{N}_{i}$ is its neighborhood, and $k\notin\mathcal{N}_{i}$ is another node of the graph, we can guarantee that if both $i$ and $k$ are infected, there exists a node in $\mathcal{N}_{i}$ which is infected. Moreover, $\mathcal{N}_{i}$ is the set of smallest size for which at least one node is infected at the same time as $i$ the most frequently. This leads us to a new set of estimators:

Definition 5**.**

Let $i$ be a node of the graph, and let $S$ be a set such that $|S|<d$ and $i\notin S$. We define a new set of estimators:

[TABLE]

Let us assume that for each pair $(i,S)$, we have access to the limit $h_{i,S}$ of $\hat{h}_{i,S}$. We now introduce an algorithm showing how to leverage these limits to learn the structure of any bounded-degree graph.

We show this algorithm is correct.

Lemma 5**.**

Algorithm 2 correctly finds the neighborhood of each node.

Proof.

Let us recall that $h_{i,S}$ is the probability that node $i$ and at least one node of $S$ are co-infected. To prove the correctness of this algorithm, it suffices to prove:

[TABLE]

Let pick a set $S$ such that $\mathcal{N}_{i}\setminus S\neq\emptyset$, and let $k$ be a node in $\mathcal{N}_{i}\setminus S$. We know h_{i,S\cup\{k\}}\geq h_{i,S}+\mathbb{P}(\text{i$and$k are the only infected nodes}). Since $i$ and $k$ are neighbors, \mathbb{P}(\text{i$and$k are the only infected nodes})>0, and therefore $h_{i,S\cup\{k\}}>h_{i,S}$. Following this line of reasoning, if $\mathcal{N}_{i}\setminus S\neq\emptyset$, $S$ we can always increase the value of $h_{i,S}$ by adding a node of $\mathcal{N}_{i}$.

However, it is impossible to increase the value of $h_{i,\mathcal{N}_{i}}$, because if $i$ and any other node of the graph are co-infected, we know one node of $\mathcal{N}_{i}$ is also infected. Therefore, the algorithm is correct.

∎

Unfortunately, we do not have direct access to $h_{i,S}$. We therefore study how many samples are needed to replace $h_{i,S}$ by its estimate $\hat{h}_{i,S}$ while preserving the correctness of the algorithm. Just like in Section 2.1, we notice that we do not need the $\{\hat{h}_{i,S}\}_{i\in V}^{|S|\leq d}$ to be close to their limit, we only need the indexes of their ordering to be the same. We notice that the neighborhood $\mathcal{N}_{i}$ of $i$ is the set of smallest size which is the most often infected at the same time as $i$ is ($\mathcal{N}_{i}=\displaystyle\operatorname*{arg\,max}_{|R|\leq d}h_{i,R}$). Therefore, we must have that for every set $S$, $\hat{h}_{i,S}\leq\hat{h}_{i,\mathcal{N}_{i}}$. However, some other sets might achieve the same value if we do not observe enough cascades. This could happen in two cases:

• •

Not all the nodes of the neighborhood were infected, and therefore a subset $T_{1}\subset\mathcal{N}_{i}$ of the neighborhood is such that $\hat{h}_{i,T_{1}}=\hat{h}_{i,\mathcal{N}_{i}}$. Since $|T_{1}|<|\mathcal{N}_{i}|$, the algorithm would return $T_{1}$ and not $\mathcal{N}_{i}$, which would be a failure case.

• •

Some other node $k$ is always infected every time a specific node $j\in\mathcal{N}_{i}$ is infected. The set $T_{2}=\mathcal{N}_{i}\setminus\{j\}\cup\{k\}$ will therefore be such that $\hat{h}_{i,T_{2}}=\hat{h}_{i,\mathcal{N}_{i}}$, and the algorithm would not know which maximum to pick. This is a failure case as well.

We identify events which guarantee that the failure cases above cannot arise. Let $E_{i,j}^{m}$ be the event that $i$ and $j$ were the only infected nodes during cascade $m$. $E_{i,j}=\displaystyle\bigcup_{1\leq m\leq M}E_{i,j}^{m}$ is therefore the event that there exists a cascade for which only $i$ and $j$ were infected. If such a cascade exists, the set $S_{max}=\displaystyle\operatorname*{arg\,max}_{|R|\leq d}\hat{h}_{i,R}$ must contain $j$. If the event $E_{i,j}$ happens for every node $j$ in the neighborhood of $i$, we can therefore guarantee Algorithm 2 is correct. We characterize the sample complexity needed for this below.

Proposition 4**.**

Let $i$ be a node, and let $j$ be one of its neighbors. Let $S$ be a set of size $|S|\leq d$, such that $i\notin S$ and $j\notin S$. With probability at least $1-\frac{\delta}{d\cdot N^{d+2}}$, among $M=\frac{(d+2)\cdot N\log(N)+N\log\left(\frac{d}{\delta}\right)}{p_{min}(1-p_{max})^{2(d-1)}}$ cascades, there exists a cascade in which $i$ and $j$ are infected, but no nodes of $S$ are infected.

Proof.

We notice that if, during cascade $m$, the only infected nodes are $i$ and $j$, no nodes of $S$ are infected. This is exactly the event $E_{i,j}^{m}$ defined above.

[TABLE]

The probability that this never happens during $M$ cascade is exactly the complement of the event $E_{i,j}$ defined above:

[TABLE]

∎

Lemma 6**.**

With probability at least $1-\delta$, if we observe $M=\frac{(d+2)\cdot N\log(N)+N\log\left(\frac{d}{\delta}\right)}{p_{min}(1-p_{max})^{2(d-1)}}$ cascades, Algorithm 2 is correct, and has running time $\mathcal{O}(M\cdot N^{d+2})=\mathcal{O}(d\cdot N^{d+3}\log(N))$.

Proof.

Let $\mathcal{S}=\{S\in\mathcal{P}(V),|S|\leq d\}$ be the set of sets of nodes of size at most $d$, let $\mathcal{S}_{\bcancel{i}}=\{S\in\mathcal{S},i\notin S\}$ be the set of sets of $\mathcal{S}$ which do not contain $i$, and let $\mathcal{N}_{i}=\{j,(i,j)\in E\}$ be the neighborhood of $i$. We pick a set $S\in\mathcal{S}$, such that $S\neq\mathcal{N}_{i}$.

We first prove that $\hat{h}_{i,S}\leq\hat{h}_{i,\mathcal{N}_{i}}$. Since the neighborhood of $i$ separates $i$ from the rest of the graph, and infected nodes are connected, we can conclude that every time $i$ and another node of $S$ are infected, one node in the neighborhood $\mathcal{N}_{i}$ of $i$ is infected as well. Therefore, we cannot increase $\hat{h}_{i,S}$ without also increasing $\hat{h}_{i,\mathcal{N}_{i}}$. In particular, this means that even if $|S|>|\mathcal{N}_{i}|$ (for instance if $\mathcal{N}_{i}\subset S$), we have $\hat{h}_{i,S}\leq\hat{h}_{i,\mathcal{N}_{i}}$. We therefore know that $\mathcal{N}_{i}\in\displaystyle\operatorname*{arg\,max}_{R\in\mathcal{S}_{\bcancel{i}}}\hat{h}_{i,R}$.

We now prove that with probability at least $1-\delta$, $\mathcal{N}_{i}$ is the set of $\displaystyle\operatorname*{arg\,max}_{R\in\mathcal{S}_{\bcancel{i}}}\hat{h}_{i,R}$ of minimal size. To do so, we notice that if there exists a cascade such that $i$ and $j\in\mathcal{N}_{i}$ are infected, but no node of $S$ is infected, then this implies $\hat{h}_{i,S}<\hat{h}_{i,\mathcal{N}_{i}}$. Indeed, as shown above, every time we increase $\hat{h}_{i,S}$, we also increase $\hat{h}_{i,\mathcal{N}_{i}}$, and we know there exists one cascade for which we increased $\hat{h}_{i,\mathcal{N}_{i}}$ without increasing $\hat{h}_{i,S}$. We now calculate the probability $P_{\rm failure}$ that such a cascade does not exist for all nodes $i$ in the graph, all nodes $j$ in their neighborhood, and all sets $S$ which do not include $i$ or $j$.

[TABLE]

We use Proposition 4 to bound this quantity:

[TABLE]

We now know that with probability at least $1-\delta$:

[TABLE]

This implies that no set of $\bigcup_{j\in\mathcal{N}_{i}}\mathcal{S}_{\bcancel{i},\bcancel{j}}$ can belong in $\displaystyle\operatorname*{arg\,max}_{R\in\mathcal{S}_{\bcancel{i}}}\hat{h}_{i,R}$. However, we have:

[TABLE]

In particular, this means that $\mathcal{N}_{i}$ is the only set of $\mathcal{S}_{\bcancel{i}}\setminus\bigcup_{j\in\mathcal{N}_{i}}\mathcal{S}_{\bcancel{i},\bcancel{j}}$ of minimal size. This shows that with probability at least $1-\delta$, $\mathcal{N}_{i}$ is the set of $\displaystyle\operatorname*{arg\,max}_{R\in\mathcal{S}_{\bcancel{i}}}\hat{h}_{i,R}$ of minimal size. This proves Algorithm 2 is correct, and that we can learn the structure of any graph of maximum degree $d$ with $M=\frac{(d+2)\cdot N\log(N)+N\log\left(\frac{d}{\delta}\right)}{p_{min}(1-p_{max})^{2(d-1)}}$ cascades.

Since we do at most one operation by pair of (node, set) and by cascade, the running time is $\mathcal{O}(N\cdot N^{d+1}\cdot M)$, which is what we wanted to prove.

∎

This leads to our theorem for learning the structure of any bounded-degree graph.

Theorem 5**.**

With probability at least $1-\delta$, in the extreme-noise setting, we can learn the structure of any graph of maximum degree $d$ with $M=\mathcal{O}\left(\frac{d\cdot N\log\left(\frac{N}{\delta}\right)}{p_{min}(1-p_{max})^{2d}}\right)$ cascades in polynomial time.

Let us now assume that $p_{max}\sim\frac{1}{d}$. This assumption is reasonable when you expect a constant number of infections by time step. For instance, it makes sense for real diseases, for which carriers have to meet to transmit it (we can only meet a constant number of people each day). It would not make sense for social networks, in which it is possible to reach many followers with each post.

Corollary 2**.**

With probability at least $1-\delta$, in the extreme-noise setting, if we assume $p_{max}\sim\frac{1}{d}$ and $p_{min}$ constant, we can learn the structure of any graph of maximum degree $d$ with $M=\mathcal{O}\left(d\cdot N\log\left(\frac{N}{\delta}\right)\right)$. This sample complexity is optimal up to log-factors, and almost matches the lower bound established in the no-noise setting.

Proof.

We need at least $\mathcal{O}\left(d\cdot N\log\left(N\right)\right)$ samples to learn the structure of a bounded-degree graph with maximum degree $d$, according to the lower bound in [29].

3.2 Bounded-degree weights

For the remainder of this paper, we state results in the limited-noise setting.

If we consider cascades of size $k$, the exact probability of infection between two nodes is a multivariate polynomial of degree $N$ on $N(N-1)$ variables (the variables here would be the weights of the graph), with a sum of up to $2\cdot\displaystyle\sum_{l=1}^{k}\frac{(N-2)!}{(N-k)!}$ terms. If the graph has more than five nodes, the resulting polynomial is of degree more than five.

For our algorithm, we therefore only use cascades of size 1 or 2. This is a waste of the data, since we simply discard cascades of larger size. However, we are not aware of techniques on how to utilize larger cascades in the limited-noise setting. Cascades of size 1 or 2 are simple enough that we can write explicitly their probability. This allows use to:

Design estimators for which we can calculate the exact limit. 2. 2.

Combine these estimators to transform a polynomial system of degree $N$ to a polynomial system of degree 2. 3. 3.

Solve this system exactly and obtain the probabilities of infection.

3.3 Estimators

We start by designing a few estimators:

Definition 6**.**

We introduce two sets of $N(N-1)$ estimators and one set of $N$ estimators. These estimators can be computed even if we only have access to the noisy times of infection.

[TABLE]

To simplify the coming notations, let us introduce $s_{k}$, which is the probability that the noise on $j$ has delay at least $k$ relative to the noise on $i$. Since the noise is i.i.d., this value is independent from $i$ and $j$: $s_{k}=\mathbb{P}(n_{j}-n_{i}\geq k)$444For instance, for geometric noise of parameter $q$, we have: $s_{k}=\displaystyle\sum_{t_{j}=\max(0,k)}^{\infty}\sum_{t_{i}=0}^{t_{j}-k}(1-q)^{t_{i}+t_{j}}=(1-q)^{\max(0,k)}\left(1-\frac{(1-q)^{1-\min(0,k)}}{2-q}\right).$. For instance, if $i$ infected $j$ during cascade $m$, the probability that the noise did not flip the order of infection (i.e. $T^{{}^{\prime}m}_{i}<T^{m}_{j}$) is $\mathbb{P}(n_{j}\geq n_{i})=s_{0}$. In the reverse case, the probability that the noise flipped the order of infection is $\mathbb{P}(T^{m}_{j}+n_{j}<T^{{}^{\prime}m}_{i}+n_{i})=\mathbb{P}(1+n_{j}<n_{i})=\mathbb{P}(n_{i}-n_{j}\geq 2)=s_{2}$.

We now compute the limits of those estimators.

Proposition 5**.**

As the number of cascades $M$ goes to infinity, the estimators introduced above tend to the following limit:

[TABLE]

Proof.

The proof is very similar to 3. See details in Appendix B.2.

∎

3.4 Solving the system

The limit of these estimators, as seen as a function of the probabilities of infection, is a complex polynomial on up to $2(N-1)$ variables. The crux of our algorithm is to combine those estimators in order to cancel out most of these variables, and create $N-1$ systems of two equations of degree 2 and two unknowns, which we then solve.

Proposition 6**.**

Let $\hat{V}_{ij}=\frac{\hat{f}^{2}_{i<j}}{\hat{h}^{2}_{i,j}+N\cdot\hat{e}^{1}_{i}\cdot\hat{e}^{1}_{j}}$. Then the limit of $\hat{V}_{ij}$ as the number of cascades $M$ goes to infinity only depends on the variables $p_{ij}$ and $p_{ji}$ :

[TABLE]

Proof.

Since all the estimators converge towards a constant, we can use Slutsky’s lemma to find the limit of $\hat{V}_{ij}$. Let $V_{ij}$ be the limit of $\hat{V}_{ij}$ as $M$ goes to infinity. We notice that the $\displaystyle\prod_{k\neq i,j}(1-p_{ik})(1-p_{jk})$ parts cancel each other out:

[TABLE]

∎

We can therefore use this equality to deduce the weights of all the edges of the graph:

Theorem 6**.**

For any graph, for any noise distribution having finite values, we can learn the weights of all the edges of the graph. In particular, we can compute a quantity which converges to the true weight of each edge:

[TABLE]

Proof.

We present a sketch of the proof here. The details can be found in Appendix B.1. We know $\hat{V}_{ij}$ tends to $V_{ij}=\frac{p_{ij}\cdot s_{0}+p_{ji}\cdot s_{2}}{1+p_{ij}\cdot p_{ji}}$. Using both $V_{ij}$ and $V_{ji}$, we can establish this second-degree equation:

[TABLE]

We recall that by definition, $s_{0}\geq s_{2}$. We also notice that if $p_{ij}=q_{1}$ and $p_{ji}=q_{2}$ is a pair of solutions of this system, then $p_{ij}=\frac{1}{q_{2}}$ and $p_{ji}=\frac{1}{q_{1}}$ forms the other pair of solution, which implies there is uniqueness of solutions in $[0,p_{max}]$. Since the real probabilities of infection satisfy this system, we also know the solution exists. Let $\Delta=\left(s_{0}^{2}-s_{2}^{2}\right)^{2}-4(V_{ji}s_{2}-V_{ij}s_{0})(V_{ij}s_{2}-V_{ji}s_{0})$. The only solution of this system in $[0,p_{max}]$ is then:

[TABLE]

∎

3.5 Sample complexity

We establish the sample complexity needed to estimate $p_{ij}$ with precision $\epsilon$. To do so, we start by estimating $V_{ij}$. Note that we only consider the pair of nodes $i$ and $j$ if, among the $M$ samples, there exists a cascade of size 2 in which $i$ and $j$ are the only infected nodes (i.e. $h_{i,j}^{2}>0$). Otherwise, we set $\hat{p}_{ij}=\hat{p}_{ji}=0$ as our estimate for $p_{ij}$.

Proposition 7**.**

With probability $1-\frac{\delta}{N^{2}}$, with $M=$ samples, we can estimate $V_{ij}$ with precision $\epsilon_{V}$.

Proof.

We present a sketch of the proof; the details can be found in Appendix B.2. As in Proposition 4, we use Hoeffding’s inequality:

[TABLE]

We use this to bound above $V_{ij}$:

[TABLE]

By bounding below the denominators and bounding above the numerator, we finally obtain:

[TABLE]

Therefore, by union bound, and by choosing $\epsilon_{1}\frac{4N}{p_{min}s_{2}(1-p_{max})^{2d}}=\epsilon_{V}$, and setting $2e^{-2M\epsilon_{1}^{2}}=\frac{\delta}{3N^{2}}$, we obtain:

With $M=\frac{1}{\epsilon_{V}^{2}}\frac{16N^{2}}{p_{min}^{2}s_{2}^{2}(1-p_{max})^{4d}}\frac{2\log(3N)-\log(\delta)}{2}$ samples, we can guarantee $|\hat{V}_{ij}-V_{ij}|\leq\epsilon_{V}$ with probability at least $1-\frac{\delta}{N^{2}}$.

∎

Once we have estimated $V_{ij}$ with precision $\epsilon_{V}$, estimating $p_{ij}$ is unfortunately still not an easy task. Indeed, let $\Delta=\left(s_{0}^{2}-s_{2}^{2}\right)^{2}-4(V_{ji}s_{2}-V_{ij}s_{0})(V_{ij}s_{2}-V_{ji}s_{0})$. We have $p_{ij}=\frac{-\left(s_{0}^{2}-s_{2}^{2}\right)+\sqrt{\Delta}}{2(V_{ij}s_{2}-V_{ji}s_{0})}$, which means that $\Delta$ has to be positive for this quantity to be defined. However, for general values of $V_{ij}$ and $V_{ji}$, $\Delta$ can be negative. We therefore use the framework of constrained optimization to bound $\Delta$ away from 0.

Lemma 7**.**

Let $\Delta=\left(s_{0}^{2}-s_{2}^{2}\right)^{2}-4(V_{ji}s_{2}-V_{ij}s_{0})(V_{ij}s_{2}-V_{ji}s_{0})$. We have:

[TABLE]

Proof.

We find the lower bound on $\Delta$ by reformulating the problem as a constrained optimization problem, and introducing the corresponding Lagrangian multipliers. The details can be found in Appendix B.1.

∎

Now that we have established this bound on $\Delta$, we can give the sample complexity needed to estimate $p_{ij}$.

Proposition 8**.**

Assuming we can estimate $V_{ij}$ within precision $\epsilon_{V}$, then we can estimate $p_{ij}$ within precision $\epsilon=\frac{6\epsilon_{V}(1+p_{max}^{2})}{(s_{0}^{2}-s_{2}^{2})^{2}(1-p_{max})^{2}}$.

Proof.

This is a simple derivation which can be found in Appendix B.2.

∎

We finally piece everything together, and use a union bound on all the $p_{ij}$ to obtain the final sample complexity of our algorithm for learning the weights of general bounded-degree graphs.

Theorem 7**.**

In the limited-noise setting, with probability at least $1-\delta$, with $M=\mathcal{O}\left(\frac{e^{4p_{max}(d+1)}}{p_{min}^{2}s_{2}^{2}(s_{0}^{2}-s_{2}^{2})^{4}}\frac{N^{2}}{\epsilon^{2}}\log\left(\frac{N}{\delta}\right)\right)$ samples, we can learn the weights of any bounded-degree graph up to precision $epsilon$.

Proof.

We obtain the desired bound by combining Proposition 7 and Proposition 8. See details in Appendix B.2.

∎

Once again, if we assume $p_{max}\sim\frac{1}{d}$ and $p_{min}$ constant, we obtain the following sample complexity:

Corollary 3**.**

In the limited-noise setting, with probability at least $1-\delta$, if $p_{max}\sim\frac{1}{d}$ and $p_{min}$ constant, we can learn the weights of any bounded-degree graph up to precision $epsilon$ with $M=\mathcal{O}\left(\frac{1}{s_{2}^{2}(s_{0}^{2}-s_{2}^{2})^{4}}\frac{N^{2}}{\epsilon^{2}}\log\left(\frac{N}{\delta}\right)\right)$ samples.

4 General graphs

In the limited-noise setting, we notice that nothing prevents us from using the algorithm for learning bounded-degree weights for general graph. This proves this problem is solvable for $any$ graph, and $any$ noise distribution. As explained in Section 1.2, this is not an obvious result. However, if we do not assume $p_{max}\sim\frac{1}{N}$, the sample complexity is now exponential.

Theorem 8**.**

In the limited-noise setting, with probability at least $1-\delta$, it is possible to learn all the weights of $any$ graph, for $any$ noise distribution, with finite (but potentially exponential) sample complexity.

5 Discussion and Future work

In this paper, we presented the first results to learn the edges of a graph from noisy times of infection. We showed we learn the structure of any bidirectional tree or any bounded-degree graph (note that not all trees are bounded-degree graphs) with optimal sample complexity (up to log-factors).

However, our results are not tight for learning the weights of bidirectional trees or bounded-degree graphs. In the no-noise setting, [29] proves this can be achieved with $\mathcal{O}(d^{2}N\log(N))$ for graphs of maximum degree $d$ with correlation decay. Our results have sample complexity $\mathcal{O}(N^{2}\log(N))$ without any assumption of correlation decay. It is an open problem to understand whether it is possible to achieve a sample complexity of $\mathcal{O}(d^{2}N\log(N))$ in the limited-noise setting, and whether assuming correlation decay is necessary to obtain such a result.

Moreover, for learning the weights of a general bounded-degree graph, we only use cascades of size 1 or 2. If we are given an infinite number of cascades of size bigger than 2, our current algorithm cannot learn the weights of the graph. Future work could develop an algorithm without such a weakness.

All our results for learning the weights of the edges are in the limited-noise setting. Whether or not it is possible to learn the noise in the extreme-noise setting is an other question of interest for future work.

Finally, we have made no restriction on the distribution of the noise we add, other than it is finite. It would be interesting to study whether stronger restrictions on the noise (for instance Gaussian noise) would lead to stronger results. It would also be interesting to allow infinite noise, and develop algorithms which are robust to errors in the infection status of a node (our current algorithms can return wrong graph structure with only one adversarially chosen false positive).

Appendix A Bidirectional tree

We include here the full calculations for learning the weights of the bidirectional tree.

Proposition 9**.**

If we know $(i,j)$ is an edge in the original tree, then the probability of infection along this edge is given by:

[TABLE]

Proof.

According to Lemma 3, we have:

[TABLE]

We have 4 second-order equations, with 4 unknowns: $p_{ij}$, $p_{ji}$, $\mathcal{P}_{\bcancel{j}}(\rightarrow i)$ and $\mathcal{P}_{\bcancel{i}}(\rightarrow j)$. We solve it:

[TABLE]

∎

Lemma 8**.**

With $M=\frac{N^{2}}{\epsilon^{2}}\log\left(\frac{6}{\delta}\right)\frac{\left((s_{0}^{2}-s_{2}^{2}+s_{0}+s_{2})p_{max}+s_{0}+s_{2}\right)^{2}}{(s_{0}^{2}-s_{2}^{2})^{2}}$ samples, with probability at least $1-\delta$, we have:

[TABLE]

Proof.

Using Hoeffding’s inequality:

[TABLE]

Choosing $M=\frac{1}{\epsilon_{1}^{2}}\log\left(\frac{6}{\delta}\right)$, we have that with probability at least $1-\delta$, all the following hold:

[TABLE]

Hence, with probability at least $1-\delta$, we have:

[TABLE]

Using the results from Lemma 3, we have:

[TABLE]

We use it to simplify the denominator:

[TABLE]

Plugging back above:

[TABLE]

By symmetry, we obtain:

[TABLE]

By choosing $\epsilon_{1}=\frac{\epsilon}{N}\frac{s_{0}^{2}-s_{2}^{2}}{(s_{0}^{2}-s_{2}^{2}+s_{0}+s_{2})p_{max}+s_{0}+s_{2}}$, we therefore have:

With $M=\frac{N^{2}}{\epsilon^{2}}\log\left(\frac{6}{\delta}\right)\frac{\left((s_{0}^{2}-s_{2}^{2}+s_{0}+s_{2})p_{max}+s_{0}+s_{2}\right)^{2}}{(s_{0}^{2}-s_{2}^{2})^{2}}$ samples, with probability at least $1-\delta$, we have $|\hat{p}_{ij}-p_{ij}|\leq\epsilon$.

∎

Appendix B Bounded-degree graphs

B.1 Solving the system

Lemma 9**.**

Let $\Delta=\left(s_{0}^{2}-s_{2}^{2}\right)^{2}-4(V_{ji}s_{2}-V_{ij}s_{0})(V_{ij}s_{2}-V_{ji}s_{0})$. We have:

[TABLE]

Proof.

Finding a lower bound for $\Delta$ can be achieved through minimizing $\Delta$, or maximizing $(V_{ji}s_{2}-V_{ij}s_{0})(V_{ij}s_{2}-V_{ji}s_{0})$. We want to solve:

[TABLE]

To do so, we introduce Lagrangian multipliers. By replacing $V_{ij}$ and $V_{ji}$ with their actual value, the optimization problem above only has affine constraints, so it satisfies the linearity constraint qualification for the Karush-Kuhn-Tucker conditions. In other words, all the partial derivatives of the Lagrangian are equal to 0 for an optimal point.

[TABLE]

We calculate the gradients of $\mathcal{L}$.

[TABLE]

From now on, we find the set $X^{0}$ of points for which all the partial derivatives are null. We know the solution of the maximization problem is the point of $X^{0}$ which maximizes the objective function.

Let us assume an interior point solution exists. For this point, all the gradients of $\mathcal{L}$ are equal to 0. Since it is an interior point, we also have $\mu_{1}=\mu_{2}=\mu_{3}=\mu_{4}=0$ by complementary slackness. Solving this system, we obtain:

[TABLE]

Plugging this in above, the condition $\frac{\partial\mathcal{L}}{\partial p_{ij}}=0$ becomes $p_{ij}p_{ji}(1-p_{ji})=0$. However, this is impossible for an interior point, since $0<p_{ij},p_{ji}<p_{max}<1$. Therefore, the extrema of $\Delta$ are attained when at least one constraint is active.

We notice that if the conditions $p_{ij}=0$ or $p_{ji}=0$ are active, then $(V_{ji}s_{2}-V_{ij}s_{0})(V_{ij}s_{2}-V_{ji}s_{0})=0$. Let us suppose (without loss of generality, by symmetry of the problem) that we have $p_{ij}=p_{max}$. The objective function is then increasing in $p_{ji}$. Therefore, $\Delta$ is minimized when $p_{ij}=p_{ji}=p_{max}$, which implies $v_{ij}=V_{ji}=\frac{p_{max}(s_{0}+s_{2})}{1+p_{max}^{2}}$. In this case:

[TABLE]

This expression is always positive, which is what we wanted.

∎

Theorem 9**.**

For any graph, for any noise distribution having finite values, we can learn the weights of all the edges of the graph. In particular, we can compute a quantity which converges to the true weight of each edge:

[TABLE]

Proof.

[TABLE]

We can plug this in $V_{ji}$:

[TABLE]

After some shuffling around, we obtain the second-degree equation:

[TABLE]

We recall that by definition, $s_{0}\geq s_{2}$. We also notice that if $p_{ij}=q_{1}$ and $p_{ji}=q_{2}$ is a pair of solutions of this system, then $p_{ij}=\frac{1}{q_{2}}$ and $p_{ji}=\frac{1}{q_{1}}$ forms the other pair of solution, which implies there is uniqueness of solutions in $[0,p_{max}]$. Since the real probabilities of infection satisfy this system, we also know the solution exists. Let $\Delta=\left(s_{0}^{2}-s_{2}^{2}\right)^{2}-4(V_{ji}s_{2}-V_{ij}s_{0})(V_{ij}s_{2}-V_{ji}s_{0})$. The only solution of this system in $[0,p_{max}]$ is:

[TABLE]

∎

B.2 Sample complexity

Proposition 10**.**

As the number of cascades $M$ goes to infinity, the estimators below tend to the following limit:

[TABLE]

Proof.

Using the law of large numbers:

[TABLE]

In the same vein, we have:

[TABLE]

∎

Proposition 11**.**

With probability $1-\frac{\delta}{N^{2}}$, with $M=$ samples, we can estimate $V_{ij}$ with precision $\epsilon_{V}$.

Proof.

As in Proposition 4, we use Hoeffding’s inequality:

[TABLE]

We use this to bound above $V_{ij}$:

[TABLE]

We bound below the denominators:

[TABLE]

We bound above the numerator:

[TABLE]

Plugging in above:

[TABLE]

Using $V_{ij}\leq 1$, and by symmetry:

[TABLE]

Therefore, by union bound, and by choosing $\epsilon_{1}\frac{4N}{p_{min}s_{2}(1-p_{max})^{2d}}=\epsilon_{V}$, and setting $2e^{-2M\epsilon_{1}^{2}}=\frac{\delta}{3N^{2}}$, we obtain:

With $M=\frac{1}{\epsilon_{V}^{2}}\frac{16N^{2}}{p_{min}^{2}s_{2}^{2}(1-p_{max})^{4d}}\frac{2\log(3N)-\log(\delta)}{2}$ samples, we can guarantee $|\hat{V}_{ij}-V_{ij}|\leq\epsilon_{V}$ with probability at least $1-\frac{\delta}{N^{2}}$. ∎

Proposition 12**.**

Assuming we can estimate $V_{ij}$ within precision $\epsilon_{V}$, then we can estimate $p_{ij}$ within precision $\epsilon=\frac{6\epsilon_{V}(1+p_{max}^{2})}{(s_{0}^{2}-s_{2}^{2})^{2}(1-p_{max})^{2}}$.

Proof.

If we know $|\hat{V}_{ij}-V_{ij}|<\epsilon_{V}$ and $|\hat{V}_{ji}-V_{ji}|<\epsilon_{V}$:

[TABLE]

We recall $s_{0}+s_{2}\leq 1$, $V_{ij}\leq 1$, $p_{ij}\leq 1$, and $1+p_{max}^{2}\leq\Delta\leq 1$ (Lemma 7). Hence:

[TABLE]

By symmetry, and using the bound on $\Delta$ stated above, we conclude that if we know $V_{ij}$ and $V_{ji}$ up to precision $\epsilon_{V}$, we know $p_{ij}$ up to precision $\epsilon=\frac{6\epsilon_{V}(1+p_{max}^{2})}{(s_{0}^{2}-s_{2}^{2})^{2}(1-p_{max})^{2}}$.

∎

Theorem 10**.**

In the limited-noise setting, with probability at least $1-\delta$, with $M=\mathcal{O}\left(\frac{e^{4p_{max}(d+1)}}{p_{min}^{2}s_{2}^{2}(s_{0}^{2}-s_{2}^{2})^{4}}\frac{N^{2}}{\epsilon^{2}}\log\left(\frac{N}{\delta}\right)\right)$ samples, we can learn the weights of any bounded-degree graph up to precision $epsilon$.

Proof.

With probability at least $1-\frac{\delta}{N^{2}}$, using

$M=\frac{1}{\epsilon_{V}^{2}}\frac{16N^{2}}{p_{min}^{2}s_{2}^{2}(1-p_{max})^{4d}}\frac{2\log(3N)-\log(\delta)}{2}$ samples, we can guarantee $|\hat{V}_{ij}-V_{ij}|\leq\epsilon_{V}$ with probability at least $1-\frac{\delta}{N^{2}}$ samples, knowing $\frac{1}{\epsilon_{V}}=\frac{6(1+p_{max}^{2})}{\epsilon(s_{0}^{2}-s_{2}^{2})^{2}(1-p_{max})^{2}}$. This gives us a sample complexity of:

[TABLE]

∎