Linear-Time Exact Computation of Influence Spread on Bounded-Pathwidth Graphs
Abstract
Given a network and a set of vertices called seeds to initially inject information, influence spread is the expected number of vertices that eventually receive the information under a certain stochastic model of information propagation. Under the commonly used independent cascade model, influence spread is equivalent to the expected number of vertices reachable from the seeds on a directed uncertain graph, and the exact evaluation of influence spread offers many applications, e.g., influence maximization. Although its evaluation is a #P-hard task, there is an algorithm that can precisely compute the influence spread in time, where is the pathwidth of the graph. We improve this by developing an algorithm that computes the influence spread in time. This is achieved by identifying the similarities in the repetitive computations in the existing algorithm and sharing them to reduce computation. Although similar refinements have been considered for the probability computation on undirected uncertain graphs, a greater number of similarities must be leveraged for directed graphs to achieve linear time complexity.
Keywords and phrases:
Influence spread, bounded pathwidth, network reliability, linear time algorithmCopyright and License:
2012 ACM Subject Classification:
Theory of computation Parameterized complexity and exact algorithms ; Networks Network algorithmsFunding:
This work was supported by JSPS KAKENHI Grant Number JP26K02906.Editor:
Pierre FraigniaudSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Given a network and seed set , which is a set of vertices that are initially injected information, influence spread [5] is the expected number of vertices that eventually receives the information under a stochastic model of information propagation. Influence spread is implemented in viral marketing applications with the aim of evaluating the influence of a particular node within a social network. Currently, it is also a keystone for other network applications such as network monitoring [11], rumor control [23], target advertisement [13], and social recommendation [24]. Among several information diffusion models, the most basic and commonly used one is the independent cascade (IC) model [6]. In this model, a network is modeled as a directed graph , where each edge is associated with a probability . When a vertex receives information, it stochastically propagates the information along every outgoing edge independently with a given probability .
The influence spread under the IC model is equivalent to the expected number of vertices reachable from at least one vertex in on a directed uncertain graph. Given directed graph and probability for every edge , we consider an uncertainty in which each edge is present with probability and absent with probability . We assume that each edge’s presence or absence is stochastically independent of the other edges. Accordingly, the probability that a subgraph appears is
| (1) |
Here, a directed path from some to vertex on the subgraph corresponds to the route of information propagation from to . Therefore, given and , the probability that receives information is equal to the probability that can be reached from some vertices in under uncertainty. Here, , where is the family of subsets of edges such that can be reached from some vertices in on . Finally, the influence spread can be represented as .
Example 1.1.
Since evaluating the influence spread is a #P-hard task [3], most studies have relied on Monte Carlo simulation for evaluating [7, 10, 11, 18]. However, exact computation of is important for the following reasons. First, this allows us to more accurately evaluate the influence spread in larger networks, since real networks often consist of small communities; the exact computation of influence spread in each small community will improve overall evaluation quality. Second, this allows us to rank the influential vertices in descending order of influence spread. For this purpose, Monte Carlo simulations are not sufficient because samples are needed to obtain -approximation with high probability [18]; to distinguish every vertex’s influence spread, high accuracy such as is sometimes needed, which is costly for Monte Carlo methods.
Maehara et al. [15] proposed the only non-trivial algorithm to exactly compute under the IC model. Given seed set and , it efficiently computes , i.e., the probability that receives information. Given the path decomposition of whose width is , this probability for a single can be computed in time, where is the number of edges. Hereafter, we mean the pathwidth of a directed graph in the sense of the pathwidth of the underlying undirected graph of as used in the literature [15, 20]. The influence spread can be computed in time, where is the number of vertices.
Here, even for bounded-pathwidth graphs, obtaining the value requires super-linear () time. Since there are similarities in the repetitive computation for different vertices using this algorithm, we investigated the use of these similarities to refine their algorithm and thus improve the running time for computing .
1.1 Our Contribution
In this paper, we propose an algorithm for computing for given under the IC model. Specifically, the proposed algorithm simultaneously computes in an uncertain directed graph for all vertices . Our main result can be expressed as follows.
Theorem 1.2.
Given directed graph , seed set , each edge’s probability of presence, and the path decomposition of whose width is , the probability for every vertex can be computed in time in total.
Since even inputting the entire graph requires linear time, this algorithm is asymptotically optimal for graphs with a bounded pathwidth when the constant factor is ignored. Moreover, the exponential factor of the pathwidth, hidden in the constant, remains the same as in the algorithm of Maehara et al. [15]: the dependence on the graph sizes is improved from to while the dependence on the pathwidth is kept the same.
Our algorithm shares certain ideas with the existing algorithm for simultaneously computing the probabilities of connection in undirected graphs [16] in that both use similarities in the computation of the previous algorithms [8, 15] for different vertices. However, there is a non-trivial gap in extending that algorithm [16] to directed graphs due to the difference between connectivity in undirected graphs and reachability in directed graphs. We fill this gap by finding additional similarities in computing with the previous algorithm [15]; details are discussed in Section 5.
1.2 Related Work
- Influence maximization.
-
The most well-studied problem related to influence spread is influence maximization [10], that is, the problem of choosing a seed set to maximize the influence spread. This has attracted much attention over the past two decades [12, 14, 19]. Although the influence maximization problem under most diffusion models including the IC model is NP-hard [10], a simple greedy algorithm [10] can achieve a -approximation provided that every is computed exactly. Various methods, e.g., the sketch-based methods described in a survey [12], have improved this greedy algorithm. However, if we resorted to using Monte Carlo simulation to evaluate , we could not obtain a deterministic approximation bound for influence maximization, even with greedy or more sophisticated algorithms. Moreover, although many studies have used an alternative proxy for to speed up the computation (e.g., proxy-based methods [12] and learning-based methods [14]), they also lack approximation bounds. This situation accentuates the theoretical importance of an exact evaluation of influence spread.
- Network reliability.
-
Computing the probability that some vertices are connected in an uncertain graph has been traditionally studied as network reliability evaluation in the network community. Most studies on network reliability evaluation have modeled the network as an undirected graph and, given a vertex set and the probability of presence for every edge, they computed the probability that the vertices in are connected. Even for undirected graphs, computing this probability is #P-complete [22]. Nevertheless, Hardy et al. [8] developed an algorithm that could compute this probability in linear time for graphs with bounded pathwidth. Another line of research has attempted to compute the expected number of vertices connected to vertex [17], which is an analogue of the influence spread under the IC model for undirected graphs. Nakamura et al. [16] proposed an algorithm that could compute the probability that a vertex is connected to for every in linear time for an undirected graph with bounded pathwidth. By summing all the probabilities for every , it is also possible to compute the expected number of vertices connected to in linear time. This algorithm uses the similarities in the computation of the probability that and are connected with Hardy’s algorithm [8] for different ; therefore, it shares similar ideas with our work. However, we cannot straightforwardly extend this algorithm to handle directed graphs, as described in Section 1; detailed discussions are given in Section 5. Note that these algorithms [8, 16] also run in polynomial time for graphs with bounded pathwidth, indicating the importance of algorithms dealing with bounded-pathwidth graphs.
2 Preliminaries
For sets of vertices, means that can reach , i.e., can be reached from , for some and in directed graph . If (or ) consists of only a single vertex (), we simply write, e.g., and instead of and . When it is clear from the context, we omit the subscript .
A directed graph is called strongly connected if for every ordered pair of vertices. We say vertex subset is a strongly connected component (SCC) of if the vertex-induced subgraph of induced by is strongly connected but that induced by is not strongly connected for any . It is known that, given directed graph , all SCCs in can be computed in linear time in the size of [21]. Throughout this paper, and denote the number of vertices and edges, respectively, in the input graph .
We formally define the problems to solve as follows.
Problem 2.1.
Given a directed graph , probabilities , and a seed set , compute the probability for every .
For convenience, we assume that contains no self-loops and the underlying undirected graph of is connected. Note that if contains self-loops, we can safely remove it, since it would never affect reachability. If is disconnected, we can solve the problem individually for each connected component.
3 Review of Previous Algorithm
3.1 Decomposition of Probability
In the following, we review Maehara’s algorithm [15] for exactly computing for a given . Although the literature [15] only showed the algorithm for the case , here we show the general case because it can be easily extended.
The basic idea in evaluating is to decompose into terms that can be easily computed. For such that , let be the conditional probability given that the edges in are present and those in are absent. From the case analysis of whether is present or absent,
| (2) |
By ordering edges as , can be decomposed by recursively applying (2):
| (3) | ||||
| where |
This expansion eventually reaches the definition . Therefore, by using this decomposition naively, we have terms, which incurs exponential complexity of the graph size in evaluating it.
To prevent this, we attempt to detect the equality among probabilities, i.e., to find subsets such that . If such equality can be detected, we simply need to further decompose only one among the equal probabilities, which reduces the number of terms. If the following condition (#) holds, we can confirm :
(#) For any , if and only if .
To check condition (#), we focus on the reachability relation on the subgraph . If and are equivalent for any , we can confirm that (#) holds. In brief, this is because, given a path from to on , we can construct a path from to on by using the above equivalence, and vice versa.
Maehara et al. [15] indicated that only a limited subset of vertices called frontier vertices is important for checking (#).
Definition 3.1.
Given edge ordering , (-th) frontier vertices are those appearing in both and .
We consider the reachability relations among on as follows.
Definition 3.2.
Let (frontier vertices reachable from ) and (those that can reach ). A binary matrix is defined as follows: (I) It is indexed by . (II) if and only if . Here, is treated as a special (single) row index, and is treated as a column index. We call a transversal configuration (TC).
We can then prove the following.
Lemma 3.3.
is a sufficient condition for (#), meaning that . Note that means that the indices of matrices as well as their entries are equal.
This can be shown by transforming a - directed path on for some to a - directed path on for some . Now we can rewrite as .
Example 3.4.
Moreover, has the following property: if for , both and hold. Thus, there exist transition functions from to satisfying and for any . By combining this fact and (2), we have, for any ,
| (4) |
Using this decomposition recursively, can be decomposed as follows:
| (5) | ||||
| where | (6) |
In other words, is the probability that TC appears and is the set of all TCs of the subsets of . We later show that is bounded by a constant if the pathwidth is bounded in Lemma 4.15. This is the main reason to achieve time complexity in computing .
For some TCs , we can confirm that must hold or must not hold, i.e., or . For such TCs, we do not need to further decompose with (4). We define such base cases with the following -pruning and -pruning as follows. Let be the largest index such that one of the endpoints of is and let .
-
If , determining the presence of confirms , i.e., . In such a case, we let , a special TC meaning that must hold (-pruning).
-
Suppose that and for any , or that and for any . In these cases, no further vertices can be reached from or reach by determining the absence of , i.e., . Thus, we let , which is a special TC meaning that must not hold (-pruning)111Although the original version [15] uses different pruning rules, they require a pre-computation of transitive closures of , which takes cubic time. We use an alternative pruning rule that can be checked in linear time.. We also let if -pruning does not occur and satisfies the same condition as above.
Eventually, all the TCs are transformed into either or , and (5) reaches . Thus, computing is sufficient for evaluating .
3.2 Procedure and Complexity
Now we describe the procedure to compute . We again use the transition of TCs. By considering the pruning described above, we redefine the set of TCs as and , i.e., we remove the pruned TCs from . Then, from the definition of (Eq. (6)), we have
| (7) |
To compute , we can use a similar formula:
| (8) |
Starting from , we can generate from recursively using transition functions . By recording the transition, we can compute every and with (7) and (8).
Algorithm 1 formally presents the procedures. Lines 1–7 recursively generate the successive TCs using transition functions while executing -pruning. This process can be seen as constructing a diagram of TCs as in Figure 3. Every except for has two outgoing edges heading to and . In Algorithm 1, each has two entries and that store the pointer to and . Here, stores the TCs of the subsets of as a hash map; pruned TCs are not stored. Along this diagram, we can compute every with simple dynamic programming (DP) in lines 8–13; this simulates the formulas (7) and (8). The array for is prepared to store . Note that even if an identical TC appears in and , we distinguish and in computing . After computing all , is stored in .
Next, we analyze the complexity of this algorithm. For each TC , computing and takes time; details are in Lemma 4.14 of Section 4.4. If every is implemented as a hash map, storing or searching a TC also takes time. The number of patterns on can be bounded by ; since this was not rigorously proved [15], we prove it in Lemma 4.15 of Section 4.4. The overall complexity can be bounded by , where .
In fact, is related to the pathwidth of a graph. Given a path decomposition of with width , we can generate an edge ordering with in linear time [9]. Since we can construct a path decomposition in linear time for a graph with bounded pathwidth [2], we have a linear time algorithm for computing on a graph with bounded pathwidth. However, computing requires time by computing for .
4 Linear-Time Influence Spread Computation
We now describe the proposed algorithm for Problem 2.1. First, we explain the high-level concept of the proposed algorithm. In computing with the algorithm described in Section 3, different diagrams of TCs are generated for different in computing . To argue the similarities among these diagrams, we divide each of them into three parts: upper levels, lower levels, and middle levels. More specifically, let be the vertices that only appear in and do not appear in , and be those that only appear in and do not appear in . , , and (Definition 3.1) constitute a partition of . Moreover, since and for , and . Thus, by fixing , the diagram of TCs made from the reachability to can be divided into three parts according to : levels s.t. (upper levels), those s.t. (middle levels), and those s.t. (lower levels).
We first find that upper levels of these diagrams exhibit an identical structure, i.e., diagrams of and exhibit an identical structure as long as (Observation 4.2); we extract the essential information to build this identical diagram as a shared transversal configuration (STC) . We can also confirm that middle levels of these diagrams were also governed by the STCs (Lemma 4.8). Thus, by considering STCs , we can have a similar formula to (5) using the STCs when :
| (9) | |||
For every , there exists such that . Thus, for every , if and are efficiently computed for all with the above , we can compute with (9). Here, since has a similar recursion as (Lemma 4.9), all s can be computed in a manner similar to that used in Section 3 by building a diagram of STCs from to . Since is constant for a graph with bounded pathwidth (Lemma 4.16), it can be performed in time.
Indeed, when (middle levels), for can also be computed efficiently. To compute this, we use the lower levels of the diagram of TCs . Although naively constructing the diagrams of TCs for every costs time, we find that the lower levels of these diagrams have many identical substructures (Lemma 4.5). By using this, we can build all possible substructures of diagrams that appear in the lower level of these diagrams in time. In addition, we again use middle levels’ equivalence (Lemma 4.8) to compute on middle levels in time. Here we use the recursion on (Lemmas 4.11 and 4.12).
Eventually, for every and where , we obtain and for . Thus, by choosing such that , we can compute with (9). Since (9) contains terms, which is constant for bounded-pathwidth graphs, the computation of for every costs time in total. The overall time complexity is bounded by for a graph with bounded pathwidth. Note that, for every , there exists such that if has degree more than . For vertices with degree , such might not exist, but we can easily compute for such vertices, as described later.
In the following, we first identify the similarities in the previous algorithm [15] for different in Section 4.1. Then, we derive DP formulas for computing in Section 4.2. Finally, we explain the main procedures and the complexity in Sections 4.3 and 4.4.
4.1 Equivalence of Diagrams for Different Vertices
We formally state the equivalence of different diagrams of TCs for upper levels (), lower levels (), and middle levels ().
Upper level equivalence.
First, we consider the case . No edges in are incident to , meaning that no vertex in can reach on . Furthermore, no vertex in can reach on . Therefore, for any , for any . This means we need to consider the reachability relations among only , not .
Definition 4.1.
Let be a binary matrix indexed by , where if and only if . Here, is treated as a special (single) row index. We call a shared transversal configuration (STC).
Since , we can recover from by for any as well as and for any . In other words, the diagram structure is completely determined by the transition of instead of when . The above argument also holds for the other . Therefore, the following observation holds.
Observation 4.2.
Consider the diagrams generated using Algorithm 1 with different . If , the diagrams above any TCs and are identical. Moreover, we can instead use STC in building the diagram.
Lower level equivalence.
Next, we consider the case . Recall that captures the reachability among , and captures those among . Since , all edges incident to and are in , meaning that all incident edges are determined when the edges in are determined. Thus, intuitively, if and are “identical,” i.e., the reachability relations are identical by substituting with , and can be regarded as equivalent events. We formally define such an equivalence.
Definition 4.4.
For , consider two TCs and , where . We say these TCs are identical if for any and and for any . This means that and are identical matrices, except for the column indices being different.
Lemma 4.5.
Suppose and are identical for and . Then, for any , if and only if .
Proof.
Fix and suppose that . There is then a directed walk from some to in . The walk can be divided into small walks satisfying the conditions that consists of only the edges in and that consists of only the edges in . Let be the contact vertex of and . Note that may be empty when ; in such a case, we set . Since is incident to both edges in and those in , . If is nonempty, is also in . We can also assume that ; otherwise, we can take a directed walk from some to within and consider a walk instead. With a similar argument, we can assume that . Now, we constitute a directed walk from some to in . First, when is not empty, . Since and are identical, ; thus, there is a directed walk from some to in . This also holds when is empty; in such a case, and is also empty. Next, for , ’s existence and identity indicate , meaning that there is a directed walk from to in . Finally, ’s existence and identity indicate , meaning that there is a directed walk from to in . Now is a directed walk from to in , indicating .
In the same manner, we can show the reverse direction. Thus, the lemma holds. This indicates that when and are identical.
Observation 4.6.
Consider the diagrams generated using Algorithm 1 with different . If and identical TCs appear in each diagram, the diagram structures below and below are identical.
Middle level equivalence.
Finally, we examine the case . In this case, the TC captures the reachability among . In addition, the STC also captures the reachability among . Thus, we can recover from by removing the columns corresponding to . In other words, if , then satisfy condition (#).
For , let be the set of vertices in that can be reached from under , which is determined by the missing row indices of . Consider a graph , where . In other words, when , is the subgraph of the transitive closure of induced by . Then, we can prove the following.
Lemma 4.8.
Suppose for and are in the same SCC of . Then, for any , if and only if .
Proof.
Fix . We can prove the equivalence of and from with almost the same argument as that in the proof of Lemma 4.5. Since and are in the same SCC of , and . Consequently, indicates and vice versa. This concludes .
4.2 New Decomposition and DP Formulas
Decomposition formula.
Using the equivalences described above, we derive a formula for using the STCs. Since we confirmed that can be recovered from when , we can derive the decomposition formula (9). If , it can be further transformed. Based on Lemma 4.8, we can rewrite as , where is the SCC of containing when . If , we immediately have . Now (9) can be further transformed into
| (10) |
If we can obtain and for every STC and every SCC of , we can compute every by choosing such that and then use (10). Note that if all vertices have degree not less than , there must exist index such that , since contains no self-loops. The value for degree vertices can be easily obtained; details are given in Section 4.3.
DP formulas.
Since TCs can be recovered from STCs and admit transition functions , STCs also admit transition functions and satisfying that, for any , and . Here, we set for when and for any , which confirms for any further vertices (-pruning). Now can be computed in the same manner as described in Section 3: From the definition of (Eq. (9)), we have the following.
Lemma 4.9.
For for some , we have
| (11) |
where and , i.e., we remove pruned STCs from .
It remains to be explained how to compute for an SCC of . If there exists such that , we can decompose it using the case analysis of : If is present, equals , where is the SCC of containing . If is absent, equals , where is the SCC of containing . Here, the relation between and can be seen as the transition from to successive SCCs . By considering the pruned cases, we formally define the successive SCCs as follows.
Definition 4.10.
For SCC of , we define successive SCC for as follows. (i) If , and with and , , meaning that can be reached from by determining the presence of . (ii) If (i) does not hold and , , meaning that cannot be reached from . (iii) If neither (i) nor (ii) holds and there exists such that , . (iv) Otherwise, , meaning that there is no successive SCC.
Lemma 4.11.
If there exists such that , i.e., successive SCCs exist, we can decompose for and SCC of as follows:
| (12) |
Note that if , since , we replace in the above formula with . This replacement is reflected in case (i) of Definition 4.10.
What can be done when such a vertex does not exist? In this case, we attempt to use the original TC. We observe in Section 4.1 that if , we can recover from with an appropriate transformation. Thus, by fixing some and letting be a TC recovered from STC , we have the following case analysis: If is present, equals . If is absent, equals . This leads to the following decomposition.
Lemma 4.12.
For and SCC of , suppose that successive SCCs do not exist. Let and be a TC recovered from STC . Then,
| (13) |
To compute the terms in the right-hand-side of (13), we can use the previous algorithm in Section 3. However, naively computing these terms for every requires time, since this amounts to constructing a diagram of the previous algorithm for every .
To overcome this, we use Lemma 4.5. Since we only need to compute for the case , we can share identical TCs, as in Observation 4.6. Accordingly, we do not need to construct different diagrams for every to compute , that is, if identical TCs and from different appear, we share them. This enables us to compute all s in linear time.
4.3 Procedure
We formally describe the proposed method in Algorithm 2. Lines 1–6 construct the diagram of STCs . stores a pointer to . We consider the successive SCCs in lines 7–11. If a successive SCC of exists, stores the pointer to it. Otherwise, following the approach of Section 4.2, we recover the original TC , where , and then carry out transition or on it. recovers the original TC by removing every column satisfying from , that is, we remove columns whose indices can reach . If a pruning occurs by considering , stores or . Otherwise, stores a pointer to , where changes the column index to . Here, is an imaginary vertex that is assumed to be contained within . Since Observation 4.6 confirms that the transitions of identical TCs are identical, we standardize the column index by changing it to . We build a diagram of in Lines 12–15.
Lines 17–19 compute for every in the same manner as Algorithm 1, and lines 20–22 compute for every in a bottom-up manner. Lines 23–26 compute for every and every SCC of . Here, stands for a conditional operator that returns if is satisfied or otherwise. When is either an original TC or , we use the q value; otherwise, we use the r value. Finally, lines 27–31 compute every using (10).
Here, we confirm the correctness of Algorithm 2.
Lemma 4.13.
After executing Algorithm 2, equals .
Proof.
First, we confirm . Starting from for , lines 17–19 compute every value for according to (11).
Second, we confirm , but this is much simpler; with the case analysis of whether is present or absent, we have
| (14) |
Starting from and , lines 20–22 compute every value for according to (14).
Third, we confirm . If there exists such that , i.e., a successive SCC exists, we can apply (12). Otherwise (i.e., a successive SCC does not exist), we can apply (13). Here, without considering the pruning, stores a pointer to if a successive SCC exists or, otherwise, to . Consequently, lines 23–26 correctly compute according to (12) if a successive SCC exists or to (13) otherwise. For the latter case, we use Lemma 4.5; i.e., .
Finally, by choosing such that , is correctly computed using (10) through lines 27–30.
Treatment of degree vertices.
We finally describe how to deal with degree vertices. By obtaining the values for all vertices with degree not less than , we can easily obtain the values for degree vertices. Let be a vertex whose degree is . Let be the unique edge incident to . If for some , i.e., is the tail of , we have because has no incoming edges. Otherwise (i.e., is the head of ), we have because every path from some to must go through , thus . Since is connected and thus has degree at least except for the trivial case where is the only edge of , we can obtain for whose degree is from the value of .
4.4 Complexity
To analyze the complexity, we again use . First, we consider the diagram construction. The key lemma is as follows.
Lemma 4.14.
Given for some , we can compute the transitions and in time. Similarly, given for some , we can also compute and in time.
The full proof is deferred to the full version; here, we describe the ideas for computing transitions. For TC , we build a graph , where is regarded as an individual special vertex and . By adding and removing edges and vertices according to the transition and computing the transitive closure, we can obtain the updated graph, whose adjacency matrix constitutes or . The transition of STC can be computed in very similar way.
Similar to , we can compute the transition of in by recomputing the transitive closure. Note that we can also compute the SCCs and their successive SCCs within this process, as described in the proof of Lemma 4.14. Thus, the total time for diagram construction is bounded by time. Here, we can bound the number of possible patterns on and , i.e., and , as follows. Since the proofs of Lemmas 4.15 and 4.16 are much similar; the proof of Lemma 4.16 is put on the full version.
Lemma 4.15.
is bounded by .
Proof.
If we fix and , some entries of are determined as follows: if or if , and if or if . Therefore, the possible patterns on is bounded by because is a binary matrix of size , and the entries of one row and one column are already determined.
We conduct a case analysis of when fixing and . When , the bound is . When , the bound is , and the number of patterns on is bounded by . When , since (supposing that ), the number of possible patterns is bounded by . The number of possible patterns on is bounded by because . Thus, the total number of patterns on is bounded by .
Lemma 4.16.
is bounded by .
Therefore, , and the total time complexity for diagram construction can be bounded by .
Next, we consider the DP. Each value can be computed in constant time. The number of values to compute for and is bounded by . Thus, the total complexity is .
Finally, computing each using (10) requires time. Thus, it needs time in total for all values.
Proposition 4.17.
Given directed graph , seed set , each edge’s probability of presence, and the edge ordering , the probability for every vertex can be computed in time in total.
Since we can generate an edge ordering with from a path decomposition of width [9] in linear time, we achieve Theorem 1.2. Moreover, with the linear-time path-decomposition algorithm for a bounded-pathwidth graph [2], we have the following.
Theorem 4.18.
Given directed graph , seed set , and each edge’s probability of presence, suppose that ’s pathwidth is bounded by a constant. Then, for every vertex can be computed in time in total.
The previous algorithm [15] requires time for computing , as discussed in Section 3. Thus, it takes time for computing . In contrast, the proposed algorithm takes time. Therefore, in terms of time complexity, our algorithm reduces the dependence on the graph size from to while the dependence on is kept the same.
5 Discussion
Here, we point out the differences between the proposed algorithm and the existing algorithm that computes the probability of connection for undirected graphs [16]. These algorithms basically share the same idea: In computing the probability of reachability (or connectivity in the undirected graphs) of every vertex, the previous top-down style algorithms, like that in Section 3, generate similar diagrams for different vertices , so they attempt to share equivalent structures. The algorithm for undirected graphs uses connected components (CCs) among frontier vertices to efficiently compute the conditional probabilities, similar to in our algorithm. The difference comes from the computation of conditional probability when a successive SCC or CC does not exist. In undirected graphs, if a successive CC does not exist, the current CC is disconnected from any further vertex, so we immediately have the conditional probability (or in an exceptional case). In contrast, in directed graphs, even if a successive SCC does not exist, the current SCC may still reach or be reached from further vertices because it can reach or be reached from the frontier vertices. This makes the computation of the conditional probabilities difficult because we cannot immediately determine them when no successive SCC exists. We resolve this issue by focusing on the equivalence of lower levels of diagrams (Lemma 4.5). This enables us to compute the conditional probabilities using a constant number of diagrams (STCs and TCs of imaginary vertex ) without breaking the linear complexity.
6 Conclusion
We proposed an algorithm for computing the influence spread under IC model exactly in time. For graphs with bounded pathwidth , we improved the complexity from to , linear in the graph size, while the dependence on the pathwidth is kept the same.
Finally, we mention some future directions. First, a more efficient exact evaluation of influence spread, suitable for the greedy algorithm [10], should be investigated. Chen et al. [4] developed an algorithm that simultaneously approximates for all , which corresponds to one iteration of the greedy algorithm. Nakamura et al. [17] developed an algorithm for undirected graphs that exactly and simultaneously computes the expected number of connected vertices for all vertices. This algorithm is promising for adoption with directed graphs as a way to simultaneously compute for all exactly. Second, we should investigate whether a linear time algorithm for computing is possible for graphs with bounded treewidth. A roadmap for achieving this may be to fit the diagram construction method based on tree decomposition [1] to the computation of influence spread and then observe the equivalences. However, such an improvement may not be straightforward due to the complicated nature of these algorithms.
References
- [1] Antoine Amarilli, Pierre Bourhis, Louis Jachiet, and Stefan Mengel. A circuit-based approach to efficient enumeration. In Proc. of the 44th International Colloquium on Automata, Languages, and Programming (ICALP 2017), pages 111:1–111:15, 2017. doi:10.4230/LIPIcs.ICALP.2017.111.
- [2] Hans L. Bodlaender. A linear-time algorithm for finding tree-decompositions of small treewidth. SIAM Journal on Computing, 25(6):1305–1317, 1996. doi:10.1137/S0097539793251219.
- [3] Wei Chen, Chi Wang, and Yajun Wang. Scalable influence maximization for prevalent viral marketing in large-scale social networks. In Proc. of the 16th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD 2010), pages 1029–1038, 2010. doi:10.1145/1835804.1835934.
- [4] Wei Chen, Yajun Wang, and Siyu Yang. Efficient influence maximization in social networks. In Proc. of the 15th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD 2009), pages 199–208, 2009. doi:10.1145/1557019.1557047.
- [5] Pedro Domingos and Matt Richardson. Mining the network value of customers. In Proc. of the 7th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD 2001), pages 57–66, 2001. doi:10.1145/502512.502525.
- [6] Jacob Goldenberg, Barak Libai, and Eitan Muller. Talk of the network: A complex systems look at the underlying process of word-of-mouth. Marketing Letters, 12:211–223, 2001. doi:10.1023/A:1011122126881.
- [7] Amit Goyal, Wei Lu, and Laks V.S. Lakshmanan. CELF++: optimizing the greedy algorithm for influence maximization in social networks. In Proc. of the 20th International Conference Companion on World Wide Web (WWW 2011), pages 47–48, 2011. doi:10.1145/1963192.1963217.
- [8] Gary Hardy, Corinne Lucet, and Nikolaos Limnios. K-terminal network reliability measures with binary decision diagrams. IEEE Transactions on Reliability, 56(3):506–515, 2007. doi:10.1109/TR.2007.898572.
- [9] Yuma Inoue and Shin-ichi Minato. Acceleration of ZDD construction for subgraph enumeration via pathwidth optimization. Technical Report TCS-TR-A-16-80, Division of Computer Science, Hokkaido University, 2016.
- [10] David Kempe, Jon Kleinberg, and Éva Tardos. Maximizing the spread of influence through a social network. In Proc. of the 9th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD 2003), pages 137–146, 2003. doi:10.1145/956750.956769.
- [11] Jure Leskovec, Andreas Krause, Carlos Guestrin, Christos Faloutsos, Jeanne VanBriesen, and Natalie Glance. Cost-effective outbreak detection in networks. In Proc. of the 13th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD 2007), pages 420–429, 2007. doi:10.1145/1281192.1281239.
- [12] Yuchen Li, Ju Fan, Yanhao Wang, and Kian-Lee Tan. Influence maximization on social graphs: A survey. IEEE Transactions on Knowledge and Data Engineering, 30(10):1852–1872, 2018. doi:10.1109/TKDE.2018.2807843.
- [13] Yuchen Li, Dongxiang Zhang, and Kian-Lee Tan. Real-time targeted influence maximization for online advertisements. Proc. of the VLDB Endowment, pages 1070–1081, 2015. doi:10.14778/2794367.2794376.
- [14] Chen Ling, Junji Jiang, Junxiang Wang, My T. Thai, Renhao Xue, James Song, Meikang Qiu, and Liang Zhao. Deep graph representation learning and optimization for influence maximization. In Proc. of the 40th International Conference on Machine Learning (ICML 2023), volume 202 of Proceedings of Machine Learning Research, pages 21350–21361, 2023. URL: https://proceedings.mlr.press/v202/ling23b.html.
- [15] Takanori Maehara, Hirofumi Suzuki, and Masakazu Ishihata. Exact computation of influence spread by binary decision diagrams. In Proc. of the 26th International Conference on World Wide Web (WWW 2017), pages 947–956, 2017. doi:10.1145/3038912.3052567.
- [16] Kengo Nakamura, Takeru Inoue, Masaaki Nishino, and Norihito Yasuda. Efficient network reliability evaluation for client-server model. In Proc. of the 2021 IEEE Global Communications Conference (GLOBECOM 2021), pages 1–6, 2021. doi:10.1109/GLOBECOM46510.2021.9685283.
- [17] Kengo Nakamura, Takeru Inoue, Masaaki Nishino, Norihito Yasuda, and Shin-ichi Minato. A fast and exact evaluation algorithm for the expected number of connected nodes: an enhanced network reliability measure. In Proc. of the 2023 IEEE International Conference on Computer Communications (INFOCOM 2023), pages 1–10, 2023. doi:10.1109/INFOCOM53939.2023.10228897.
- [18] Naoto Ohsaka, Takuya Akiba, Yuichi Yoshida, and Ken-ichi Kawarabayashi. Fast and accurate influence maximization on large networks with pruned monte-carlo simulations. In Proc. of the 28th AAAI Conference on Artificial Intelligence (AAAI 2014), pages 138–144, 2014. doi:10.1609/aaai.v28i1.8726.
- [19] Shashank Sheshar Singh, Divya Srivastva, Madhushi Verma, and Jagendra Singh. Influence maximization frameworks, performance, challenges and directions on social network: A theoretical study. Journal of King Saud University - Computer and Information Sciences, 34(9):7570–7603, 2022. doi:10.1016/j.jksuci.2021.08.009.
- [20] Hirofumi Suzuki, Masakazu Ishihata, and Shin-ichi Minato. Exact computation of strongly connected reliability by binary decision diagrams. In Proc. of the 12th International Conference on Combinatorial Optimization and Applications (COCOA 2018), pages 281–295, 2018. doi:10.1007/978-3-030-04651-4_19.
- [21] Robert Tarjan. Depth-first search and linear graph algorithms. SIAM Journal on Computing, 1(2):146–160, 1972. doi:10.1137/0201010.
- [22] Leslie G. Valiant. The complexity of enumeration and reliability problems. SIAM Journal on Computing, 8(3):410–421, 1979. doi:10.1137/0208032.
- [23] Peng Wu and Li Pan. Scalable influence blocking maximization in social networks under competitive independent cascade models. Computer Networks, 123:38–50, 2017. doi:10.1016/j.comnet.2017.05.004.
- [24] Mao Ye, Xingjie Liu, and Wang-Chien Lee. Exploring social influence for recommendation: a generative model approach. In Proc. of the 35th International ACM SIGIR Conference on Research and Development in Information Retrieval (SIGIR 2012), pages 671–680, 2012. doi:10.1145/2348283.2348373.
