Accelerating (k,l,η)-Core Query Processing in Directed Uncertain Graphs

Abstract

Uncertain graphs are commonly used to model the uncertain relationships between entities that arise from experimental or measurement errors. In recent years, the analysis of uncertain graphs has attracted significant research attention, with the computation of $(k,\eta )$-cores emerging as a fundamental problem. However, existing studies on $(k,\eta )$-cores often neglect edge directions, resulting in weak correlations among vertices in the resulting subgraph. To address this limitation, we propose a direction-aware $(k,l,\eta )$-core model. Specifically, a $(k,l,\eta )$-core is defined as a maximal connected subgraph in which every vertex has a probability of at least $\eta$ of having in-degree $\ge k$ and out-degree $\ge l$. We first present an online algorithm based on a peeling strategy to compute $(k,l,\eta )$-cores. To improve query performance, we develop two indexing mechanisms, DUCS-E and DUCS, that accelerate query processing. DUCS-E stores probability information for all possible $(k,l,\eta )$-cores, enabling it to completely avoid redundant computations during query processing, but at the cost of large storage space. To mitigate this issue, we propose the lightweight DUCS index, which stores directional probability information separately, reducing storage overhead while still pruning many irrelevant vertices; however, it requires additional verification. To balance efficiency and storage, we further design a hybrid index that combines the strengths of both approaches. Finally, experimental evaluations on real-world datasets demonstrate the effectiveness of the proposed $(k,l,\eta )$-core model as well as the efficiency and scalability of our methods.

1. Introduction

In practical applications, graphs are commonly used to represent relationships among different entities, such as social networks [1,2], transportation networks [3], and biological networks [4,5]. Due to experimental errors or measurement inaccuracies, the relationships between entities often exhibit uncertainty and are typically modeled as uncertain graphs [6,7,8,9,10]. For example, in protein–protein interaction (PPI) networks [11], the probabilities associated with edges indicate the likelihood of interaction between protein molecules. In sensor networks [12], edge probabilities represent the reliability of information transmission between nodes. In social networks [13], edge probabilities reflect the degree of attention between users.

Cohesive subgraph mining is an important method for analyzing uncertain graphs, among which the $(k,\eta )$-core is one of the most popular uncertain cohesive subgraph models [14,15]. Compared with other uncertain cohesive subgraph models, such as the $(k,\tau )$-clique [16,17] and the $(k,\gamma )$-truss [3,18,19,20], the $(k,\eta )$-core model is simple and easy to compute. It can serve as a basis for uncertain graph analysis or as an input for other complex operations to simplify computation and improve efficiency, which has garnered widespread attention from researchers [12]. The $(k,\eta )$-core is a maximal subgraph that ensures that the probability that the degree of each vertex is at least k is at least $\eta$ [12].

In practical applications, relationships between entities often exhibit directionality. The existing $(k,\eta )$-core model overlooks the directionality of edges, making it incapable of capturing dense subgraphs based on directional constraints. For example, Figure 1a depicts a social network in a real-world application, where the vertices represent users and the edges denote the attention among users. When using the $(k,\eta )$-core model without considering directions, only the 2-core subgraph in Figure 1b can be obtained, i.e., $\{v_1,v_2,v_3,v_4,v_5\}$. However, in practical scenarios, relationships between vertices are often unidirectional, as shown in Figure 1a. It can be seen that no other user pays attention to $v_3$, and $v_3$ may be a zombie user (a virtual user manipulated by the software); $v_5$ does not actively pay attention to other users in this subgraph. Obviously, $v_3$ and $v_5$ do not have the same attention preference as other users in the subgraph, and they should not form a 2-core subgraph with $v_1$, $v_2$, and $v_4$.

To address the above problem, we propose the $(k,l,\eta )$-core model to obtain cohesive subgraphs in directed graphs by considering the directions of the edges. Given a directed uncertain graph, a $(k,l,\eta )$-core is a maximal connected subgraph that satisfies that the probability that the in-degree of each vertex is at least k and the out-degree of each vertex is at least l is at least $\eta$. For instance, given $k=2$, $l=2$, and a probability threshold $\eta =0.3$, the $(2,2,0.3)$-core that satisfies the condition in Figure 1a is $\{v_1,v_2,v_4\}$. Compared to the 2-core in Figure 1b, the $(k,l,\eta )$-core exhibits higher interactivity and tighter connections among vertices, excluding zombie users who are not followed by others and those who do not follow anyone within the subgraph.

While previous research has explored directed k-core queries [21,22,23], these studies did not take into account the probability information on edges. Additionally, existing methods for the $(k,\eta )$-core and directed k-core cannot be easily combined to solve the problem of $(k,l,\eta )$-core queries, necessitating the design of specialized solutions. Recently, Teng et al. [24] has explored the $(k,l,\eta )$-core model in the context of topic-aware most influential community search (TAMICS), their primary focus is on identifying the most influential community under a specific topic vector. To the best of our knowledge, there is no existing work that focuses solely on the fundamental problem of efficient and exact $(k,l,\eta )$-core query processing itself. Our work is orthogonal and complementary to [24]; we provide the first comprehensive study on efficiently answering ad-hoc $(k,l,\eta )$-core queries with a suite of indexing solutions, without the additional complexity of influence maximization.

In this paper, we first propose an online query algorithm based on the peeling idea. Similar to the algorithm for determining the k-core on deterministic graphs, it iteratively removes vertices that do not meet the constraints and updates the probability information of associated vertices. This process continues until every vertex in the induced subgraph satisfies the constraints. While this algorithm can solve $(k,l,\eta )$-core queries, it requires frequent computation and updating of vertex probability information, leading to lower query efficiency. To address this issue, we propose an index-based method to accelerate the computation of $(k,l,\eta )$-cores, called DUCS-E (Directed Uncertain Core Sequence Enhanced). DUCS-E uses a single array to simultaneously maintain the probability information for both the in-degree and out-degree of each vertex. During query processing, it can directly return the results. To address the excessive storage space of the DUCS-E index, we further propose an index that considers the constraints of vertex in-degree and out-degree separately: DUCS (Directed Uncertain Core Sequence). This index uses two arrays to store the subgraph probability information. During query processing, there is no need for frequent computation and updating of vertex probability information in the uncertain graph. It can prune many unsatisfied vertices, but it requires further validation, leading to a less noticeable improvement in efficiency. Finally, to deal with this problem, a hybrid index structure named Hybrid is proposed. The Hybrid index combines the advantages of DUCS and DUCS-E. It uses a single array to store the subgraph probability information for $(k,l,\eta )$-cores when parameters k and l are small. When parameters k and l are large, it employs two arrays to separately store subgraph probability information for each direction. Based on different query parameters, it selects an appropriate solving strategy. The Hybrid algorithm ensures efficient query performance while reducing the time and space overhead of index construction.

We clarify that the efficiency claim in this paper refers to the online query processing stage, where the goal is to answer a given $(k,l,\eta )$-core query as fast as possible. To achieve this, we shift the heavy computation to an offline preprocessing phase, during which the index structures are constructed. Although the offline index construction may take considerable time on large datasets, it is a one-time investment. Once built, the index enables rapid query responses for arbitrary ad-hoc queries. This design is particularly beneficial in real-world applications where the number of queries is large or the query workload is unpredictable. Our main contributions are summarized as follows:

• We propose a family of algorithms for $(k,l,\eta )$-core computation. The first is a baseline online algorithm. To improve performance, we further propose three index-based algorithms: DUCS-E, DUCS, and Hybrid. The DUCS-E index stores probability information related to all $(k,l,\eta )$-cores, achieving the best query performance. However, DUCS-E suffers from a large index size. Considering this, we provide a lightweight index, DUCS, which maintains $(k,\eta )$-cores for forward and backward directions, respectively. Although it can reduce computation cost by pruning useless vertices, it still requires verification of the remaining vertices. Finally, we propose the Hybrid index, which utilizes the benefits of both DUCS and DUCS-E to make a trade-off between query performance, index construction time, and index size.
• We conduct extensive experiments on large real-world datasets. The experimental results indicate that the three index-based approaches achieve a four-order-of-magnitude improvement in query efficiency compared to the online query algorithm.

The rest of this paper is organized as follows. Section 2 introduces basic knowledge and problem definitions. Section 3 presents the online query algorithm. Section 4, Section 5 and Section 6 provide detailed descriptions of the DUCS-E index, the DUCS index, and the Hybrid index, respectively, along with their associated algorithms. Section 7 primarily analyzes and summarizes the complexity of the various algorithms. Section 8 validates the proposed algorithms through experiments. Section 9 introduces related work. Finally, conclusions are presented.

2. Preliminaries

2.1. Uncertain Graphs

Given a deterministic graph $G=(V,E)$, where V and E represent the sets of vertices and edges, respectively. For a vertex $u\in V$, the set of neighbors of u in G is denoted as $N(u,G)=\{v\in V\mid (u,v)\in E\}$, and the degree of u is $\mathrm{d}\mathrm{e}\mathrm{g}(u,G)=\left|N\right(u,G\left)\right|$. When the context is clear, we abbreviate the neighbor set and degree as $N\left(u\right)$ and $\mathrm{d}\mathrm{e}\mathrm{g}\left(u\right)$. For any subset $V^{\prime }\subseteq V$, the induced subgraph of $V^{\prime }$ is denoted by $G\left[V^{\prime }\right]=(V^{\prime },\{(u,v)\in E\mid u,v\in V^{\prime }\})$.

Definition 1 

(k-core). Given a deterministic graph $G=(V,E)$ and a positive integer k, a k-core is a maximal connected induced subgraph $G\left[V^{\prime }\right]$ such that every vertex has degree at least k, i.e., for all $u\in V^{\prime }$, $\mathrm{d}\mathrm{e}\mathrm{g}(u,G\left[V^{\prime }\right])\ge k$.

Definition 2 

(Core number). Given a deterministic graph $G=(V,E)$, the core number of a vertex $u\in V$, denoted by $\mathrm{c}\mathrm{o}\mathrm{r}\mathrm{e}\left(u\right)$, is the maximum value of k for which u belongs to a k-core.

Let $\mathcal{G}=(V,E,p)$ be an uncertain graph, where p is a function that assigns to each edge $e\in E$ a probability value in $[0,1]$. For each edge $e=(u,v)\in E$, $p_e$ denotes its probability. The neighbor set and degree of a vertex $u\in V$ in $\mathcal{G}$ are denoted by $\mathcal{N}(u,\mathcal{G})$ and $\mathrm{D}\mathrm{e}\mathrm{g}(u,\mathcal{G})$, respectively.

Following the literature [12], we assume that the edge probabilities are mutually independent. Under this assumption, the uncertain graph can be analyzed using possible-world semantics. There are $2^{\left|E\right|}$ possible instances $G=(V,E^{\prime })$ with $E^{\prime }\subseteq E$. The probability of a particular instance graph G is given by

$$\mathrm{P}\mathrm{r}\left(G\right)=\prod _{e\in E^{\prime }}{p}_e\prod _{e\in E\setminus E^{\prime }}(1-p_e).$$

(1)

Definition 3 

($(k,\eta )$-core). Given an uncertain graph $\mathcal{G}=(V,E,p)$, a positive integer k, and a probability threshold $\eta \in [0,1]$, the $(k,\eta )$-core is a maximal connected induced subgraph $\mathcal{G}\left[V^{\prime }\right]$ such that for every vertex $u\in V^{\prime }$, the probability that the degree of u in $\mathcal{G}\left[V^{\prime }\right]$ is at least k is not less than η:

$$\forall u\in V^{\prime },\mathrm{P}\mathrm{r}[\mathrm{D}\mathrm{e}\mathrm{g}(u,\mathcal{G}\left[V^{\prime }\right])\ge k]\ge \eta .$$

For a vertex v, define ${\mathcal{G}}_v^{\ge k}$ as the set of all possible world subgraphs of $\mathcal{G}$ in which the degree of v is at least k:

$${\mathcal{G}}_v^{\ge k}=\{G\subseteq \mathcal{G}\mid \mathrm{d}\mathrm{e}\mathrm{g}(v,G)\ge k\}.$$

Then, the probability that $\mathrm{D}\mathrm{e}\mathrm{g}(v,\mathcal{G})\ge k$ is computed as

$$\mathrm{P}\mathrm{r}[\mathrm{D}\mathrm{e}\mathrm{g}(v,\mathcal{G})\ge k]=\sum _{G\in {\mathcal{G}}_v^{\ge k}}\mathrm{P}\mathrm{r}\left(G\right).$$

(2)

Definition 4 

($\eta$-degree). Given an uncertain graph $\mathcal{G}=(V,E,p)$ and a probability threshold $\eta \in [0,1]$, the η-degree of a vertex $v\in V$ is the maximum integer k such that $\mathrm{P}\mathrm{r}\left[\mathrm{D}\mathrm{e}\mathrm{g}\right(v,\mathcal{G})\ge k]\ge \eta$.

From Definition 4, the $\eta$-degree can be obtained via

$$\mathrm{P}\mathrm{r}[\mathrm{D}\mathrm{e}\mathrm{g}(v,\mathcal{G})\ge k]=1-{\displaystyle \sum _{i=0}^{k-1}}\mathrm{P}\mathrm{r}[\mathrm{D}\mathrm{e}\mathrm{g}(v,\mathcal{G})=i].$$

(3)

Reference [12] proposes a dynamic programming (DP) method for computing $(k,\eta )$-cores. Using Equation (3) and the DP approach, we can compute $\mathrm{P}\mathrm{r}\left[\mathrm{D}\mathrm{e}\mathrm{g}\right(v,\mathcal{G})=i]$ for each vertex v. Let $E(v,\mathcal{G})=\{e_1,e_2,\dots ,e_s\}$, where $s=\mathrm{D}\mathrm{e}\mathrm{g}\left(v\right)$, and let $E_s^r(v,\mathcal{G})=\{e_1,e_2,\dots ,e_r\}$ for $r\le s$. Define ${\mathcal{G}}_v^r=(V,E\setminus (E(v,\mathcal{G})\setminus E_s^r(v,\mathcal{G})),p)$ as the subgraph obtained by removing the edges $E(v,\mathcal{G})\setminus E_s^r(v,\mathcal{G})$. The degree of v in ${\mathcal{G}}_v^r$ is $\mathrm{D}\mathrm{e}\mathrm{g}(v,{\mathcal{G}}_v^r)$. If the degree of v equals i, there are two possibilities: (i) $e_s$ exists and $\mathrm{D}\mathrm{e}\mathrm{g}(v,{\mathcal{G}}_v^{s-1})=i-1$; (ii) $e_s$ does not exist and $\mathrm{D}\mathrm{e}\mathrm{g}(v,{\mathcal{G}}_v^{s-1})=i$. Let $Y_v(r,i)$ denote the probability that the degree of v is exactly i in the subgraph ${\mathcal{G}}_v^r\subseteq \mathcal{G}$. The DP recurrence is

$$Y_v(r,i)=p_{e_r}·Y_v(r-1,i-1)+(1-p_{e_r})·Y_v(r-1,i).$$

(4)

The boundary conditions are

$$\left\{\begin{array}{cc}\hfill Y(0,0)& =1,\hfill \\ \hfill Y(r,-1)& =0,\mathrm{for}r=0,\dots ,\mathrm{D}\mathrm{e}\mathrm{g}\left(v\right),\hfill \\ \hfill Y(r,j)& =0,\mathrm{for}r=0,\dots ,\mathrm{D}\mathrm{e}\mathrm{g}\left(v\right),j=r+1,\dots ,i.\hfill \end{array}\right.$$

(5)

After removing an edge $e\in E\left(v\right)$, the updated probability that the degree of v equals i in the reduced graph is given by

$$\mathrm{P}\mathrm{r}[\mathrm{D}\mathrm{e}\mathrm{g}(v\mid E\left(v\right)\setminus \left\{e\right\})=i]={\displaystyle \frac{\mathrm{P}\mathrm{r}[\mathrm{D}\mathrm{e}\mathrm{g}\left(v\right)=i]-p_e\mathrm{P}\mathrm{r}[\mathrm{D}\mathrm{e}\mathrm{g}(v\mid E\left(v\right)\setminus \left\{e\right\})=i-1]}{1-p_e}}.$$

(6)

For the special case $i=0$, we have

$$\mathrm{P}\mathrm{r}[\mathrm{D}\mathrm{e}\mathrm{g}(v\mid E\left(v\right)\setminus \left\{e\right\})=0]={\displaystyle \frac{\mathrm{P}\mathrm{r}\left[\mathrm{D}\mathrm{e}\mathrm{g}\right(v)=0]}{1-p_e}}.$$

2.2. Directed Uncertain Graphs

When dealing with directed uncertain graphs, we must revisit the previous definitions to incorporate edge directions.

Let ${\mathcal{G}}_d=(V,E,p)$ be a directed uncertain graph. For a vertex $u\in V$, the out-neighbor set is ${\mathcal{N}}_{\mathrm{out}}(u,{\mathcal{G}}_d)=\{v\in V\mid (u,v)\in E\}$ and the in-neighbor set is ${\mathcal{N}}_{\mathrm{in}}(u,{\mathcal{G}}_d)=\{v\in V\mid (v,u)\in E\}$. We abbreviate these as ${\mathcal{N}}_{\mathrm{out}}\left(u\right)$ and ${\mathcal{N}}_{\mathrm{in}}\left(u\right)$ when the context is clear. The out-degree and in-degree of u are denoted by ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}(u,{\mathcal{G}}_d)$ and ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}(u,{\mathcal{G}}_d)$, respectively. The underlying deterministic graph is $G_d=(V,E)$.

Definition 5 

(k-core_in, l-core_out). Given a directed deterministic graph $G_d=(V,E)$ and two positive integers k and l, a k-core_in (resp. l-core_out) is a maximal connected induced subgraph $G_d^{\prime }$ on $V^{\prime }$ such that every vertex has in-degree (resp. out-degree) at least k (resp. l). That is,

$$\forall u\in V^{\prime },{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}(u,G_d^{\prime })\ge k(\mathit{resp}.{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}(u,G_d^{\prime })\ge l).$$

Definition 6 

(${\mathrm{core}}_{\mathrm{in}}$, ${\mathrm{core}}_{\mathrm{out}}$). Given a directed deterministic graph $G_d=(V,E)$, the in-degree core number ${\mathit{core}}_{\mathit{in}}\left(u\right)$ is the maximum k such that u belongs to a k-core_in. Similarly, the out-degree core number ${\mathit{core}}_{\mathit{out}}\left(u\right)$ is the maximum l such that u belongs to an l-core_out.

Based on Definitions 5 and 6, we now define the $(k,l,\eta )$-core.

Definition 7 

($(k,l,\eta )$-core). Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, two positive integers k and l, and a probability threshold $\eta \in [0,1]$, the $(k,l,\eta )$-core is a maximal connected induced subgraph ${\mathcal{G}}_d^{\prime }$ on $V^{\prime }$ such that every vertex has probability at least η of having in-degree $\ge k$ and out-degree $\ge l$:

$$\forall u\in V^{\prime },\min \left(\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}(u,{\mathcal{G}}_d^{\prime })\ge k],\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}(u,{\mathcal{G}}_d^{\prime })\ge l]\right)\ge \eta .$$

Remark 1. 

The in-degree and out-degree of a vertex are determined by two disjoint edge sets. Under the independent edge probability model, the random variables ${\mathrm{Deg}}_{in}\left(v\right)$ and ${\mathrm{Deg}}_{out}\left(v\right)$ are independent. However, for a vertex to be considered a cohesive part of a directed core, it must play a significant role in both directions. Therefore, we impose constraints on both marginal probabilities. The min operator is deliberately employed to enforce the “shortboard effect”: the overall reliability of a vertex in the core is limited by its weakest direction. This guarantees that every vertex in the resulting subgraph is statistically significant as both a source and a target of connections, ensuring strong mutual engagement within the community.

Example 1. 

Consider the directed uncertain graph in Figure 1a. For $k=2$, $l=2$, and $\eta =0.3$, the connected subgraph ${\mathcal{G}}_d^{\prime }={\mathcal{G}}_d\left[\{v_1,v_2,v_4\}\right]$ satisfies the $(2,2,0.3)$-core condition. In this subgraph:

• Vertex $v_1$ has two in-edges and two out-edges; $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}(v_1,{\mathcal{G}}_d^{\prime })\ge 2]=0.4$, $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}(v_1,{\mathcal{G}}_d^{\prime })\ge 2]=0.42$, and $\min (0.4,0.42)=0.4\ge 0.3$.
• Vertex $v_2$: $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}(v_2,{\mathcal{G}}_d^{\prime })\ge 2]=0.54$, $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}(v_2,{\mathcal{G}}_d^{\prime })\ge 2]=0.3$, $\min (0.3,0.54)=0.3\ge 0.3$.
• Vertex $v_4$: $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}(v_4,{\mathcal{G}}_d^{\prime })\ge 2]=0.42$, $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}(v_4,{\mathcal{G}}_d^{\prime })\ge 2]=0.72$, $\min (0.42,0.72)=0.42\ge 0.3$.

Moreover, ${\mathcal{G}}_d^{\prime }$ is maximal: adding $v_3$ would give $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}(v_3,{\mathcal{G}}_d^{\prime })\ge 2]=0.48>0.3$ but $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}(v_3,{\mathcal{G}}_d^{\prime })\ge 2]=0$, so $\min (0.48,0)=0<0.3$; thus $v_3$ does not satisfy the constraint.

Problem Definition. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, two positive integers k and l, and a probability threshold $\eta \in [0,1]$, return all $(k,l,\eta )$-cores in ${\mathcal{G}}_d$.

3. The Online Algorithm

The online query algorithm is based on the peeling idea. It iteratively removes vertices that do not meet the constraints and updates the probability information of the associated vertices until every vertex in the induced subgraph satisfies the constraints, at which point the execution terminates and returns the results. For directed uncertain graphs, however, the in-degree and out-degree of vertices must be considered separately to solve the corresponding core decomposition problem. We introduce the following definitions.

Definition 8 

($(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$, $(l,\eta )$-${\mathrm{core}}_{\mathrm{out}}$). Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$ and a probability threshold $\eta \in [0,1]$, a $(k,\eta )$-${\mathit{core}}_{\mathit{in}}$ (resp. $(l,\eta )$-${\mathit{core}}_{\mathit{out}}$) is a maximal connected induced subgraph ${\mathcal{G}}_d^{\prime }$ on vertex set $V^{\prime }$ such that for every vertex $u\in V^{\prime }$, the probability that its in-degree (resp. out-degree) is at least k (resp. l) is at least η. That is,

$$\forall u\in V^{\prime },\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}(u,{\mathcal{G}}_d^{\prime })\ge k]\ge \eta (\mathit{resp}.\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}(u,{\mathcal{G}}_d^{\prime })\ge l]\ge \eta ).$$

Definition 9 

($\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}$, $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}$). Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$ and a probability threshold $\eta \in [0,1]$, the η-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}$ and η-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}$ of a vertex $v\in V$ are the maximum integers k and l, respectively, satisfying

$$\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}(v,{\mathcal{G}}_d)\ge k]\ge \eta \mathit{and}\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}(v,{\mathcal{G}}_d)\ge l]\ge \eta .$$

Definition 10 

($\eta$-${\mathrm{core}}_{\mathrm{in}}$, $\eta$-${\mathrm{core}}_{\mathrm{out}}$). Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$ and a probability threshold $\eta \in [0,1]$, the η-${core}_{\mathit{in}}$ and η-${core}_{\mathit{out}}$ of a vertex $u\in V$ are the maximum values of k and l, respectively, such that u belongs to a $(k,\eta )$-${core}_{\mathit{in}}$ and an $(l,\eta )$-${core}_{\mathit{out}}$.

According to Definitions 9 and 10, together with Equations (3) and (6), we can compute and update the values of $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}$ and $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}$ for each vertex in the directed uncertain graph.

The $(k,l,\eta )$-core online query algorithm is presented in Algorithm 1. Before checking whether a vertex satisfies the $(k,l,\eta )$-core constraint, we iteratively remove vertices that do not meet the structural constraints ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}<l$ or ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}<k$ (lines 1–8). Then, we compute $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}$ and $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}$ for the remaining vertices using Equation (3) (lines 9–10). The algorithm continues by iteratively removing vertices and their incident edges that do not satisfy the $(k,l,\eta )$-core constraint, updating the $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}$ and $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}$ of neighboring vertices according to Equation (6) (lines 11–18). Finally, all connected subgraphs that satisfy the constraints are stored in the result set $\mathcal{S}$ (lines 19–22).

Example 2. 

Consider the directed uncertain graph shown in Figure 1a. Suppose $k=1$, $l=1$, and the probability threshold $\eta =0.7$ (lines 1-8). First, we compute ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v_3\right)=0<1$, thus remove $v_3$. The remaining vertices have ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}$ and ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}$ satisfying the conditions (lines 9–10). Next, we calculate

$$\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v_5\right)\ge 1]=1-{\displaystyle \sum _{i=0}^1}\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v_5\right)=0]=1-0.4\times 0.1=0.96\ge 0.7,$$

and

$$\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v_5\right)\ge 2]=0.6\times 0.9=0.54<0.7.$$

Therefore, $0.7$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v_5\right)=1$. Similarly, we obtain $0.7$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}\left(v_5\right)=0$ and the corresponding values for the remaining vertices (lines 11–18). Although the in-degree probability of $v_5$ satisfies the condition, its out-degree does not. Hence, we remove $v_5$ and its incident edges. We then update the out-degree probabilities of $v_2$ and $v_4$, and the in-degree probability of $v_6$ using Equation (6). After updating, all vertices in the remaining two maximal connected induced subgraphs $C_1=\{v_1,v_2,v_4\}$ and $C_2=\{v_6,v_7\}$ satisfy the constraint. We store these final subgraphs that satisfy the $(1,1,0.7)$-core condition in the result set $\mathcal{S}=\{\{v_1,v_2,v_4\},\{v_6,v_7\}\}$ (lines 19–22).

Theorem 1. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the time complexity of Algorithm 1 is

$$O\left(\left|V\right|+\sum _{v\in V}\left(\max \left(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}\left(v\right)\right)·\max \left({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}\left(v\right)\right)\right)\right).$$

Proof. 

First, Algorithm 1 takes $O\left(\right|V\left|\right)$ time to iteratively delete vertices whose in-degree or out-degree does not satisfy the structural constraint (lines 1–8). Then, according to [12], the time to compute $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}$ and $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}$ for each remaining vertex is $O\left({\sum }_{v\in V}(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right)·{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right))\right)$ and $O\left({\sum }_{v\in V}(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)·{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)$ (lines 9–10). Finally, we need to delete all vertices that do not satisfy the query conditions and iteratively update the $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}$ and $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}$ values. According to [12], the time to update these values is $O\left({\sum }_{v\in V}\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)$ (lines 11–19). Therefore, the overall time complexity of Algorithm 1 is

$$O\left(\left|V\right|+\sum _{v\in V}\left(\max \left(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)\right)·\max \left({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)\right)\right)\right).$$

   □

The $(k,l,\eta )$-core online query algorithm produces accurate result sets, but it is highly dependent on the parameter settings, which limits its universality. Although the online algorithm can be optimized using dynamic programming, the cost of computing and updating the $\eta$-degree for each vertex remains high.

4. DUCS-E Index

4.1. Index Structure

The online query algorithm repeatedly calculates the probability values of vertices, leading to low query efficiency. To avoid redundant calculations, we consider maintaining the probability information of each vertex.

Definition 11. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$ and two positive integers k and l, the value ${\eta }_{(k,l)}(v,{\mathcal{G}}_d)$ for a vertex $v\in V$ is defined as the maximum probability η such that v belongs to a $(k,l,\eta )$-core.

Thus, ${\eta }_{(k,l)}(v,{\mathcal{G}}_d)$ represents the highest probability threshold for which vertex v satisfies the constraints k and l. Given k, l, and $\eta$, if ${\eta }_{(k,l)}(v,{\mathcal{G}}_d)\ge \eta$, then v belongs to the $(k,l,\eta )$-core.

Lemma 1. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, two positive integers k and l, and probability thresholds $0\le \eta \le {\eta }^{\prime }\le 1$, if there exist subgraphs ${\mathcal{G}}_{d_1}^{\prime }=(k,l,\eta )$-core and ${\mathcal{G}}_{d_2}^{\prime }=(k,l,{\eta }^{\prime })$-core, then ${\mathcal{G}}_{d_2}^{\prime }\subseteq {\mathcal{G}}_{d_1}^{\prime }$.

Proof. 

Consider a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$. Suppose ${\mathcal{G}}_{d_1}^{\prime }$ is a $(k,l,\eta )$-core and ${\mathcal{G}}_{d_2}^{\prime }$ is a $(k,l,{\eta }^{\prime })$-core with $\eta \le {\eta }^{\prime }$. According to Definition 5, for every $v\in V_{{\mathcal{G}}_{d_2}^{\prime }}$,

$$\min \left(\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}(v,{\mathcal{G}}_d)\ge k],\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}(v,{\mathcal{G}}_d)\ge l]\right)\ge {\eta }^{\prime }\ge \eta .$$

Hence, ${\mathcal{G}}_{d_2}^{\prime }$ also satisfies the constraints of a $(k,l,\eta )$-core, implying $V_{{\mathcal{G}}_{d_2}^{\prime }}\subseteq V_{{\mathcal{G}}_{d_1}^{\prime }}$. Therefore, ${\mathcal{G}}_{d_2}^{\prime }\subseteq {\mathcal{G}}_{d_1}^{\prime }$.    □

According to Lemma 1 and Definition 11, we can determine whether a vertex $v\in V$ belongs to a $(k,l,\eta )$-core based on the value of ${\eta }_{(k,l)}(v,{\mathcal{G}}_d)$. Thus, by storing ${\eta }_{(k,l)}(v,{\mathcal{G}}_d)$ for all vertices, we can efficiently answer all possible $(k,l,\eta )$-core queries.

The DUCS-E index stores information for all $(k,l,\eta )$-core combinations with $k\in [1,k_{\max }]$ and $l\in [1,l_{\max }]$. By Lemma 1, the subgraphs corresponding to different $\eta$ values are nested. Therefore, we can process vertices in ascending order of $\eta$ values step by step, avoiding simultaneous storage of all satisfying nodes and thus saving memory.

Example 3. 

Consider the directed uncertain graph ${\mathcal{G}}_d$ shown in Figure 1a. The DUCS-E index is illustrated in Figure 2. Take vertex $v_1$ as an example. For $k=1$ and $l=1$, we have ${\eta }_{(1,1)}(v_1,{\mathcal{G}}_d)=0.8$, meaning that $v_1$ satisfies the constraints of a $(1,1,0.8)$-core. If $\eta >0.8$, then $v_1$ does not satisfy the $(1,1,\eta )$-core constraints.

4.2. Query Processing

The DUCS-E index simultaneously accounts for both in-degree and out-degree constraints of each vertex, eliminating the need to recompute vertex probabilities during query processing.

The DUCS-E index-based query algorithm is presented in Algorithm 2. We first initialize the storage array (line 1). Then, we invoke the DUCS-E index construction algorithm to store all potential $(k,l,\eta )$-cores in the array (line 2). Next, we traverse the array to identify vertices satisfying the query conditions (lines 5–7). Finally, we return the maximal connected subgraph induced by these vertices (lines 8–10).

Example 4. 

Based on the DUCS-E index shown in Figure 2, consider the query parameters $k=2$, $l=1$, and $\eta =0.4$. First, from the stored array we identify the set of vertices $\{v_1,v_2,v_3,v_4,v_5,v_6,v_7\}$ that satisfy the conditions $k=2$ and $l=1$. Within this set, we then select the subset $\{v_1,v_2,v_4\}$ where the stored probability values are at least $0.4$. Finally, we output the maximal connected induced subgraph ${\mathcal{G}}_d\left[\{v_1,v_2,v_4\}\right]$ that satisfies the given constraints.

Theorem 2. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the time complexity of Algorithm 2 is $O\left({\sum }_{v\in V}\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v\right))+\left|V\right|\right)$.

Proof. 

Traversing the index array to find vertices satisfying the conditions takes $O\left(\right|V\left|\right)$ time. Then, obtaining the vertex sets of each connected component requires $O\left({\sum }_{v\in V}\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right))\right)$ time. Therefore, the total time complexity of Algorithm 2 is $O\left({\sum }_{v\in V}\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right))+\left|V\right|\right)$.    □

4.3. Index Construction

According to Definition 11, all information of $(k,l,\eta )$-cores for $k\in [1,k_{\max }]$ and $l\in [1,l_{\max }]$ is stored in the sequence array ${\mathit{Seq}}_{\eta }$ using a bottom-up approach. Algorithm 3 details the construction of the DUCS-E index.

First, we perform core decomposition on the deterministic graph to obtain $k_{\max }$ and $l_{\max }$ (line 1). Then, for each pair $(k,l)$, we construct an index covering all relevant information (lines 5–24). For each $(k,l)$ combination, dynamic programming is used to compute ${\mathrm{P}\mathrm{r}}_{\mathrm{in}}\left(v\right)$ and ${\mathrm{P}\mathrm{r}}_{\mathrm{out}}\left(v\right)$ for every vertex v, and we store the minimum in $\mathrm{P}\mathrm{r}\left(v\right)$ (lines 8–11). We identify the vertex v with the smallest $\mathrm{P}\mathrm{r}\left(v\right)$, delete v and its incident edges (lines 13–15), and iteratively update ${\mathrm{P}\mathrm{r}}_{\mathrm{in}}$ and ${\mathrm{P}\mathrm{r}}_{\mathrm{out}}$ for the neighbors of v (lines 17–22). The value $\min ({\mathrm{P}\mathrm{r}}_{\mathrm{in}}\left(v\right),{\mathrm{P}\mathrm{r}}_{\mathrm{out}}\left(v\right))$ for vertices satisfying the constraints is stored in the temporary array Pr (lines 23–24). This process continues until all $(k,l)$ pairs are processed, storing ${\eta }_{(k,l)}(v,{\mathcal{G}}_d)$ for each vertex. Finally, the DUCS-E index is obtained.

Theorem 3. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the time complexity of Algorithm 3 is

$$O\left((k_{\max }·l_{\max })·\left(\max (k_{\max },l_{\max })·\left(\right|V|log|V|+\left|E\right|)\right)\right).$$

Proof. 

Computing ${\mathrm{core}}_{\mathrm{in}}$ and ${\mathrm{core}}_{\mathrm{out}}$ for each vertex in the deterministic graph takes $O\left(\max \right(|E_{\mathrm{in}}|,|E_{\mathrm{out}}\left|\right))$, where $|E_{\mathrm{in}}|$ and $|E_{\mathrm{out}}|$ are the total in-degree and out-degree of ${\mathcal{G}}_d$ (line 1). According to [12], calculating $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}$ and $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}$ requires $O\left({\sum }_{v\in V}(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right)·{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right))\right)$ and $O\left({\sum }_{v\in V}(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)·{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)$ time (lines 8–11). Finding the vertex with the minimum value and deleting it costs $O\left(\right|V|log|V\left|\right)$ (lines 13–14). Updating ${\mathrm{P}\mathrm{r}}_{\mathrm{in}}$ and ${\mathrm{P}\mathrm{r}}_{\mathrm{out}}$ takes $O\left({\sum }_{v\in V}\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)$ (lines 17–22). Since $\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\le \max (k_{\max },l_{\max })$, the overall time complexity follows.    □

Theorem 4. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the space complexity of Algorithm 3 is $O\left({\sum }_{v\in V}({\mathrm{core}}_{\mathit{in}}\left(v\right)·{\mathrm{core}}_{\mathit{out}}\left(v\right))\right)$.

Proof. 

For each vertex $v\in V$, the storage space $\mathit{Seq}\left(v\right)$ depends on both ${\mathrm{core}}_{\mathrm{in}}\left(v\right)$ and ${\mathrm{core}}_{\mathrm{out}}\left(v\right)$. In the worst case, the space consumed per vertex is ${\mathrm{core}}_{\mathrm{in}}\left(v\right)·{\mathrm{core}}_{\mathrm{out}}\left(v\right)$. Thus, the total space complexity is $O\left({\sum }_{v\in V}({\mathrm{core}}_{\mathrm{in}}\left(v\right)·{\mathrm{core}}_{\mathrm{out}}\left(v\right))\right)$.    □

5. DUCS Index

5.1. Index Structure

While the query algorithm based on the DUCS-E index significantly improves query efficiency, its index size is prohibitively large because it stores probability thresholds for all combinations of k and l values. We can substantially reduce the index storage by storing probability thresholds for the two directions separately. To this end, based on Definition 11, we first define probability thresholds for directional constraints.

Definition 12 

(${\eta }_k(v,{\mathcal{G}}_d)$ and ${\eta }_l(v,{\mathcal{G}}_d)$). Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$ and two positive integers k and l, ${\eta }_k(v,{\mathcal{G}}_d)$ denotes the maximum η such that v belongs to a $(k,\eta )$-${core}_{\mathit{in}}$, and ${\eta }_l(v,{\mathcal{G}}_d)$ denotes the maximum η such that v belongs to a $(l,\eta )$-${core}_{\mathit{out}}$.

Thus, ${\eta }_k(v,{\mathcal{G}}_d)$ (resp. ${\eta }_l(v,{\mathcal{G}}_d)$) is the highest probability value for which v can be part of a $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$ (resp. $(l,\eta )$-${\mathrm{core}}_{\mathrm{out}}$). If for given k (or l) and $\eta$ we have ${\eta }_k(v,{\mathcal{G}}_d)\ge \eta$ (or ${\eta }_l(v,{\mathcal{G}}_d)\ge \eta$), then v certainly belongs to the corresponding core.

Lemma 2. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, two positive integers $k,l$, and probability thresholds $0\le \eta \le {\eta }^{\prime }\le 1$,

• If there exist subgraphs ${\mathcal{G}}_{d_1}^{\prime }=(k,\eta )$-${\mathit{core}}_{\mathit{in}}$ and ${\mathcal{G}}_{d_2}^{\prime }=(k,{\eta }^{\prime })$-${\mathit{core}}_{\mathit{in}}$, then ${\mathcal{G}}_{d_2}^{\prime }\subseteq {\mathcal{G}}_{d_1}^{\prime }$;
• If there exist subgraphs ${\mathcal{G}}_{d_3}^{\prime }=(l,\eta )$-${\mathit{core}}_{\mathit{out}}$ and ${\mathcal{G}}_{d_4}^{\prime }=(l,{\eta }^{\prime })$-${\mathit{core}}_{\mathit{out}}$, then ${\mathcal{G}}_{d_4}^{\prime }\subseteq {\mathcal{G}}_{d_3}^{\prime }$.

Proof. 

Consider a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$. Suppose ${\mathcal{G}}_{d_1}^{\prime }$ is a $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$ and ${\mathcal{G}}_{d_2}^{\prime }$ is a $(k,{\eta }^{\prime })$-${\mathrm{core}}_{\mathrm{in}}$ with $\eta \le {\eta }^{\prime }$. By Definition 8, for every $v\in V_{{\mathcal{G}}_{d_2}^{\prime }}$, we have $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right)\ge k]\ge {\eta }^{\prime }\ge \eta$. Hence, ${\mathcal{G}}_{d_2}^{\prime }$ also satisfies the $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$ constraints, so $V_{{\mathcal{G}}_{d_2}^{\prime }}\subseteq V_{{\mathcal{G}}_{d_1}^{\prime }}$ and consequently ${\mathcal{G}}_{d_2}^{\prime }\subseteq {\mathcal{G}}_{d_1}^{\prime }$. The proof for out-degree cores is analogous.    □

According to Lemma 2 and Definition 12, we can test whether a vertex v belongs to a $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$ or $(l,\eta )$-${\mathrm{core}}_{\mathrm{out}}$ using the stored values ${\eta }_k(v,{\mathcal{G}}_d)$ and ${\eta }_l(v,{\mathcal{G}}_d)$. Thus, we only need to store these values for all vertices to answer all possible queries.

The DUCS index comprises two sequence arrays ${\mathit{Seq}}_{\eta }^{\mathrm{in}}$ and ${\mathit{Seq}}_{\eta }^{\mathrm{out}}$. They store, for each vertex, all possible values of ${\eta }_k(v,{\mathcal{G}}_d)$ and ${\eta }_l(v,{\mathcal{G}}_d)$, which correspond to all possible $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$ and $(l,\eta )$-${\mathrm{core}}_{\mathrm{out}}$. Since k and l are bounded, we only need to consider $1\le k\le k_{\max }$ and $1\le l\le l_{\max }$, where $k_{\max }={\max }_{v\in V}{\mathrm{core}}_{\mathrm{in}}\left(v\right)$ and $l_{\max }={\max }_{v\in V}{\mathrm{core}}_{\mathrm{out}}\left(v\right)$. Following the nesting property from Lemma 2, the values are stored in increasing order of ${\eta }_k(v,{\mathcal{G}}_d)$ and ${\eta }_l(v,{\mathcal{G}}_d)$ to reduce redundant storage.

Example 5. 

Consider the directed uncertain graph ${\mathcal{G}}_d$ in Figure 1a. The DUCS index is shown in Figure 3. Take vertex $v_1$ as an example. For $k=1$, ${\eta }_1(v_1,{\mathcal{G}}_d)=0.9$, meaning $v_1$ satisfies the $(1,0.9)$-${\mathit{core}}_{\mathit{in}}$ constraint. If $\eta >0.9$, $v_1$ does not satisfy the $(1,\eta )$-${\mathit{core}}_{\mathit{in}}$ constraint. For $l=1$, ${\eta }_1(v_1,{\mathcal{G}}_d)=0.8$, so $v_1$ satisfies the $(1,0.8)$-${\mathit{core}}_{\mathit{out}}$ constraint; if $\eta >0.8$, it does not. From Figure 3, we see that the $(1,0.8)$-${\mathit{core}}_{\mathit{in}}$ is $\{v_1,v_2,v_4,v_5,v_6,v_7\}$ and the $(2,0.3)$-${\mathit{core}}_{\mathit{out}}$ is $\{v_1,v_2,v_3,v_4\}$.

5.2. Query Processing

In a directed uncertain graph, edge probabilities may differ between directions for the same vertex. Therefore, we must analyze the inclusion relationships among the $(k,l,\eta )$-core, $(l,\eta )$-${\mathrm{core}}_{\mathrm{out}}$, and $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$.

Theorem 5. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$ and query parameters k, l, η, suppose there exist subgraphs ${\mathcal{G}}_{d_1}^{\prime }=(k,l,\eta )$-core, ${\mathcal{G}}_{d_2}^{\prime }=(k,\eta )$-${\mathit{core}}_{\mathit{in}}$, and ${\mathcal{G}}_{d_3}^{\prime }=(l,\eta )$-${\mathit{core}}_{\mathit{out}}$. Then:

1. 

${\mathcal{G}}_{d_1}^{\prime }\subseteq {\mathcal{G}}_{d_2}^{\prime }$ and ${\mathcal{G}}_{d_1}^{\prime }\subseteq {\mathcal{G}}_{d_3}^{\prime }$;

2. 

$V_{{\mathcal{G}}_{d_1}^{\prime }}\subseteq (V_{{\mathcal{G}}_{d_3}^{\prime }}\cap V_{{\mathcal{G}}_{d_2}^{\prime }})$;

3. 

${\mathcal{G}}_{d_2}^{\prime }$ and ${\mathcal{G}}_{d_3}^{\prime }$ are not necessarily subsets of ${\mathcal{G}}_{d_1}^{\prime }$.

Proof. 

If ${\mathcal{G}}_{d_1}^{\prime }$ is a $(k,l,\eta )$-core, then for every $v\in V_{{\mathcal{G}}_{d_1}^{\prime }}$,

$$\min \left(\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}(v,{\mathcal{G}}_d^{\prime })\ge k],\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}(v,{\mathcal{G}}_d^{\prime })\ge l]\right)\ge \eta .$$

In particular, $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}(v,{\mathcal{G}}_d^{\prime })\ge k]\ge \eta$, so ${\mathcal{G}}_{d_1}^{\prime }$ satisfies the $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$ constraints. Similarly, it satisfies the $(l,\eta )$-${\mathrm{core}}_{\mathrm{out}}$ constraints. Thus, $V_{{\mathcal{G}}_{d_1}^{\prime }}\subseteq (V_{{\mathcal{G}}_{d_3}^{\prime }}\cap V_{{\mathcal{G}}_{d_2}^{\prime }})$, establishing (i) and (ii).

Now consider (iii) by contradiction. Suppose ${\mathcal{G}}_{d_2}^{\prime }$ (a $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$) is a subset of ${\mathcal{G}}_{d_1}^{\prime }$ (a $(k,l,\eta )$-core). Then, for every $v\in V_{{\mathcal{G}}_{d_2}^{\prime }}$,

$$\min \left(\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}(v,{\mathcal{G}}_d^{\prime })\ge k],\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}(v,{\mathcal{G}}_d^{\prime })\ge l]\right)\ge \eta ,$$

but the definition of a $(k,\eta )$-${\mathrm{core}}_{\mathrm{in}}$ only guarantees $\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}(v,{\mathcal{G}}_d^{\prime })\ge k]\ge \eta$, not necessarily the out-degree condition. Hence, ${\mathcal{G}}_{d_2}^{\prime }$ may not be contained in ${\mathcal{G}}_{d_1}^{\prime }$. The same holds for ${\mathcal{G}}_{d_3}^{\prime }$.    □

According to Theorem 5, the result obtained directly from the DUCS index is only an upper bound of the true $(k,l,\eta )$-core. Therefore, further verification using the online algorithm (Algorithm 1) is required to obtain the exact result.

The DUCS-based query algorithm is presented in Algorithm 4. We first initialize the storage arrays and invoke the DUCS index construction to store vertices satisfying ${\eta }_k(v,{\mathcal{G}}_d)\ge \eta$ and ${\eta }_l(v,{\mathcal{G}}_d)\ge \eta$ (lines 1–3). Then, we collect the candidate vertices (lines 4–7). Finally, we call Algorithm 1 to verify the candidate set and obtain the exact result (line 8).

Example 6. 

Consider ${\mathcal{G}}_d$ in Figure 1a with $k=2$, $l=1$, $\eta =0.4$. The online algorithm yields the connected induced subgraph ${\mathcal{G}}_d\left[\{v_1,v_2,v_4\}\right]$. From the DUCS index in Figure 3, vertex $v_5$ belongs to both $(2,0.4)$-${\mathit{core}}_{\mathit{in}}$ and $(1,0.6)$-${\mathit{core}}_{\mathit{out}}$ (which is a subset of $(1,0.4)$-${\mathit{core}}_{\mathit{out}}$), but $v_5$ does not satisfy the $(2,1,0.4)$-core constraints. The set of vertices satisfying both $(2,0.4)$-${\mathit{core}}_{\mathit{in}}$ and $(1,0.4)$-${\mathit{core}}_{\mathit{out}}$ is $V_c=\{v_1,v_2,v_4\}$, a subset of $\{v_1,v_2,v_4,v_5\}$.

Theorem 6. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$ and parameters k, l, η, the time complexity of Algorithm 4 is

$$O\left(\left|V\right|+\sum _{v\in V^{\prime }}\left(\max \left(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}\left(v\right)\right)·\max \left({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathit{out}}\left(v\right)\right)\right)\right),$$

where $V^{\prime }$ is the set of vertices that require further validation by Algorithm 1.

Proof. 

Searching the arrays $re{s}_{\mathrm{in}}$ and $re{s}_{\mathrm{out}}$ for vertices satisfying the conditions takes $O\left(\right|V\left|\right)$ time (lines 5–7). By Theorem 1, validating the candidate vertex set $V^{\prime }$ using the online algorithm costs $O\left(\left|V\right|+{\sum }_{v\in V^{\prime }}\left(\max (\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))·\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)\right)$. Hence, the total complexity follows.    □

5.3. Index Construction

Following Definition 12, we construct the sequences ${\mathit{Seq}}_{\eta }^{\mathrm{in}}$ and ${\mathit{Seq}}_{\eta }^{\mathrm{out}}$ in a bottom-up manner for $k\in [1,k_{\max }]$ and $l\in [1,l_{\max }]$.

Algorithm 5 presents the DUCS index construction. For clarity, we denote ${\mathrm{P}\mathrm{r}}_{\mathrm{in}}\left(v\right)=\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}(v,\mathcal{G})\ge k]$ and ${\mathrm{P}\mathrm{r}}_{\mathrm{out}}\left(v\right)=\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}(v,\mathcal{G})\ge l]$. First, we compute ${\mathrm{core}}_{\mathrm{in}}$ and ${\mathrm{core}}_{\mathrm{out}}$ for each vertex (line 1). Then, we initialize arrays ${\mathit{Seq}}_{\eta }^{\mathrm{in}}\left(v\right)$ and ${\mathit{Seq}}_{\eta }^{\mathrm{out}}\left(v\right)$ (line 2). Next, we compute ${\mathrm{P}\mathrm{r}}_{\mathrm{in}}\left(v\right)$ and ${\mathrm{P}\mathrm{r}}_{\mathrm{out}}\left(v\right)$ based on the k-core and l-core decompositions, and use the SEQ procedure to obtain the index arrays (lines 3–10). We then compute ${\eta }_k(v,{\mathcal{G}}_d)$ and ${\eta }_l(v,{\mathcal{G}}_d)$ for each vertex (lines 12–26). Specifically, we repeatedly remove the vertex v with the smallest ${\mathrm{P}\mathrm{r}}_{\mathrm{in}}$ or ${\mathrm{P}\mathrm{r}}_{\mathrm{out}}$, delete its incident edges, and update the probabilities of affected neighbors. Finally, we return the stored values (line 27).

Theorem 7. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the time complexity of Algorithm 5 is

$$O\left(k_{\max }^2|E_{\mathit{in}}|+l_{\max }^2|E_{\mathit{out}}|+(k_{\max }+l_{\max })·\left|V\right|log\left|V\right|\right),$$

where $|E_{\mathit{in}}|$ and $|E_{\mathit{out}}|$ are the total in-degree and out-degree of ${\mathcal{G}}_d$.

Proof. 

Computing ${\mathrm{core}}_{\mathrm{in}}$ and ${\mathrm{core}}_{\mathrm{out}}$ takes $O\left(\max \right(|E_{\mathrm{in}}|,|E_{\mathrm{out}}\left|\right))$ (line 1). According to [12], calculating $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}$ and $\eta$-${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}$ costs $O\left({\sum }_{v\in V}(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right)·{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right))\right)$ and $O\left({\sum }_{v\in V}(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)·{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)$ (lines 5–6 and 8–9). Selecting the minimum value and deleting a vertex costs $O\left(\right|V|log|V\left|\right)$ (lines 15–18). Updating ${\mathrm{P}\mathrm{r}}_{\mathrm{in}}$ and ${\mathrm{P}\mathrm{r}}_{\mathrm{out}}$ for vertices costs $O\left({\sum }_{v\in V}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right)\right)$ and $O\left({\sum }_{v\in V}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)\right)$ (lines 20–26). Since $\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right)\le k_{\max }$ and ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)\le l_{\max }$, the total complexity follows.    □

Theorem 8. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the space complexity of Algorithm 5 is

$$O\left(\sum _{v\in V}\left({\mathrm{core}}_{\mathit{in}}\left(v\right)+{\mathrm{core}}_{\mathit{out}}\left(v\right)\right)\right).$$

Proof. 

For each $v\in V$, we maintain two arrays ${\mathit{Seq}}_{\eta }^{\mathrm{in}}\left(v\right)$ and ${\mathit{Seq}}_{\eta }^{\mathrm{out}}\left(v\right)$ whose lengths are at most ${\mathrm{core}}_{\mathrm{in}}\left(v\right)$ and ${\mathrm{core}}_{\mathrm{out}}\left(v\right)$, respectively. Hence, the total space is bounded by the sum over all vertices of these two core numbers.    □

6. Hybrid Index

6.1. Index Structure

As discussed in the previous sections, the DUCS-E index suffers from prohibitively large construction overhead, while the DUCS index requires additional verification, limiting its efficiency gains. Both issues are closely related to the query parameters k and l. To further analyze this, we introduce Lemma 3.

Lemma 3. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, let $V_{(k,l,\eta )}$ denote the vertex set of a $(k,l,\eta )$-core. Then:

1. 

if $k_1<k_2$, then $V_{(k_2,l,\eta )}\subseteq V_{(k_1,l,\eta )}$;

2. 

if $l_1<l_2$, then $V_{(k,l_2,\eta )}\subseteq V_{(k,l_1,\eta )}$.

Proof. 

For case (i): suppose ${\mathcal{G}}_{d_1}^{\prime }=(k_1,l,\eta )$-core and ${\mathcal{G}}_{d_2}^{\prime }=(k_2,l,\eta )$-core with $k_1<k_2$. By Definition 5, for every $v\in V_{{\mathcal{G}}_{d_2}^{\prime }}$,

$$\min \left(\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}(v,V_{{\mathcal{G}}_{d_2}^{\prime }})\ge k_2\ge k_1],\mathrm{P}\mathrm{r}[{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}(v,V_{{\mathcal{G}}_{d_2}^{\prime }})\ge l]\right)\ge \eta .$$

Hence, ${\mathcal{G}}_{d_2}^{\prime }$ also satisfies the $(k_1,l,\eta )$-core constraints, so $V_{{\mathcal{G}}_{d_2}^{\prime }}\subseteq V_{{\mathcal{G}}_{d_1}^{\prime }}$, i.e., $V_{(k_2,l,\eta )}\subseteq V_{(k_1,l,\eta )}$. Case (ii) is proved similarly.    □

According to Lemma 3, decreasing either k or l enlarges the vertex set of the $(k,l,\eta )$-core. Consequently, as shown in Theorem 2, smaller k and l lead to a larger upper bound when using the DUCS index, incurring higher verification cost. Moreover, Theorems 7 and 8 indicate that the DUCS-E index construction is time-consuming and memory-intensive. To overcome these drawbacks, we propose a hybrid index that combines DUCS and DUCS-E.

Example 7. 

Both DUCS and DUCS-E indices are built for all $k\in [1,k_{\max }]$ and $l\in [1,l_{\max }]$. We choose two threshold parameters ${\epsilon }_{\mathit{in}}$ and ${\epsilon }_{\mathit{out}}$ to partition the ranges, as illustrated in Figure 4. Specifically,

$$k\in [1,{\epsilon }_{\mathit{in}}]\cup [{\epsilon }_{\mathit{in}}+1,k_{\max }],l\in [1,{\epsilon }_{\mathit{out}}]\cup [{\epsilon }_{\mathit{out}}+1,l_{\max }].$$

For $k\in [1,{\epsilon }_{\mathit{in}}]$ and $l\in [1,{\epsilon }_{\mathit{out}}]$, only the DUCS-E index is stored; for $k\in [{\epsilon }_{\mathit{in}}+1,k_{\max }]$ and $l\in [{\epsilon }_{\mathit{out}}+1,l_{\max }]$, only the DUCS index is stored.

Obviously, the Hybrid index is a generalization of the previously proposed DUCS-E and DUCS indexes: by adjusting the thresholds ${\epsilon }_{\mathrm{in}}$ and ${\epsilon }_{\mathrm{out}}$ to their extreme values, Hybrid reduces to DUCS-E when ${\epsilon }_{\mathrm{in}}=k_{\max }$ and ${\epsilon }_{\mathrm{out}}=l_{\max }$, and reduces to DUCS when ${\epsilon }_{\mathrm{in}}=0$ and ${\epsilon }_{\mathrm{out}}=0$. For intermediate threshold values, Hybrid achieves a tunable balance between query efficiency and index overhead. Thus, DUCS-E and DUCS can be viewed as two extreme points on the time-space trade-off spectrum, with Hybrid providing a practical and flexible solution that covers the entire spectrum.

6.2. Query Processing

Given query parameters k, l and thresholds ${\epsilon }_{\mathrm{in}}$, ${\epsilon }_{\mathrm{out}}$, three query types arise:

$$\begin{array}{cc}\hfill \left(\mathrm{a}\right)& k\le {\epsilon }_{\mathrm{in}}\mathrm{and}l\le {\epsilon }_{\mathrm{out}};\hfill \\ \hfill \left(\mathrm{b}\right)& k>{\epsilon }_{\mathrm{in}}\mathrm{and}l>{\epsilon }_{\mathrm{out}};\hfill \\ \hfill \left(\mathrm{c}\right)& (k\le {\epsilon }_{\mathrm{in}}\mathrm{and}l>{\epsilon }_{\mathrm{out}})\mathrm{or}(k>{\epsilon }_{\mathrm{in}}\mathrm{and}l\le {\epsilon }_{\mathrm{out}}).\hfill \end{array}$$

Different strategies are applied:

• Type (a): directly use the DUCS-E index to obtain the exact result.
• Type (b): use the DUCS index to obtain an upper bound set, then apply the online algorithm for verification.
• Type (c): first use the DUCS-E index to obtain a vertex set containing the result; then use the DUCS index to obtain another vertex set; prune based on containment; finally verify the pruned set with the online algorithm.

Example 8. 

Consider a type (c) query with $k\le {\epsilon }_{\mathit{in}}$ and $l>{\epsilon }_{\mathit{out}}$. The DUCS index stores subgraphs for $k_1\ge {\epsilon }_{\mathit{in}}$, $l_1\ge {\epsilon }_{\mathit{out}}$, while the DUCS-E index stores subgraphs for $k_2<{\epsilon }_{\mathit{in}}$, $l_2<{\epsilon }_{\mathit{out}}$. Thus, there exists $l_1^{\prime }=l_1$ such that $({\epsilon }_{\mathit{in}},l_1^{\prime },\eta )$-core $\subseteq (k,l,\eta )$-core, and $k_2^{\prime }=k_2$ such that $(k,l,\eta )$-core $\subseteq (k_2^{\prime },{\epsilon }_{\mathit{out}},\eta )$-core. As shown in Figure 5, let V, $V_1$, and $V_2$ be the vertex sets of $(k,l,\eta )$-core, $({\epsilon }_{\mathit{in}},l_1^{\prime },\eta )$-core, and $(k_2^{\prime },{\epsilon }_{\mathit{out}},\eta )$-core, respectively. Then, the result set $V_c=V_1^{\prime }\cup V_2^{\prime }$, where $V_1^{\prime }$ is obtained by removing vertices from $V_1$ that do not satisfy the $({\epsilon }_{\mathit{in}},l_1^{\prime },\eta )$-core constraint (verified online), and $V_2^{\prime }$ is obtained by validating $V_2\setminus V_1^{\prime }$ online. The case $k>{\epsilon }_{\mathit{in}}$ and $l\le {\epsilon }_{\mathit{out}}$ is handled symmetrically.

The hybrid index query algorithm is presented in Algorithm 6. It first obtains the hybrid index (line 1), then selects the appropriate query method based on the three cases (line 4), and finally returns the connected components of the resulting vertex set (lines 5–7).

Theorem 9. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the worst-case time complexity of Algorithm 6 is

$$O\left(\sum _{v\in V^{\prime }}\max \left(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)\right)·\max \left({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)\right)\right),$$

where $V^{\prime }$ is the pruned vertex set in type (c) queries.

Proof. 

For type (a), Theorem 6 gives complexity $O({\sum }_{v\in V}\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right))+|V\left|\right)$. For type (b), Theorem 3 gives $O\left(\right|V|+{\sum }_{v\in V^{\prime }}(\max (\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))·\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))))$. For type (c), we first use the DUCS-E query (Theorem 6) to obtain $V_2$ in $O({\sum }_{v\in V}\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right))+|V\left|\right)$. Then, the DUCS index query gives a pruned set $V_1^{\prime }$ with complexity $O({\sum }_{v\in V^{\prime }}(\max (\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))·\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right)$, ${\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right)\left)\right))$. Finally, verifying $V_2\setminus V_1^{\prime }$ online (Theorem 1) costs $O({\sum }_{v\in V_2\setminus V_1^{\prime }}\left(\max \right(\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right)$, $\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))·\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\left)\right)$. Thus, type (c) dominates, yielding the stated bound.    □

6.3. Index Construction

The hybrid index consists of a DUCS-E part for $k\in [1,{\epsilon }_{\mathrm{in}}]$, $l\in [1,{\epsilon }_{\mathrm{out}}]$ and a DUCS part for $k\in [{\epsilon }_{\mathrm{in}}+1,k_{\max }]$, $l\in [{\epsilon }_{\mathrm{out}}+1,l_{\max }]$. This significantly reduces construction time and space.

Lemma 4. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, if $k_1<k_2$, $l_1<l_2$, and ${\eta }_1<{\eta }_2$, then for any vertex v in the $(k_2,l_2,{\eta }_2)$-core, ${\eta }_{(k_2,l_2)}(v,{\mathcal{G}}_d)>{\eta }_1$.

Proof. 

From the nesting property of k-cores, $(k_2,l_2,{\eta }_2)$-core $\subseteq (k_1,l_1,{\eta }_2)$-core. Every vertex v in the latter satisfies ${\eta }_{(k_1,l_1)}(v,{\mathcal{G}}_d)\ge {\eta }_2>{\eta }_1$. Since ${\eta }_{(k_2,l_2)}(v,{\mathcal{G}}_d)\ge {\eta }_{(k_1,l_1)}(v,{\mathcal{G}}_d)$ by definition, the claim follows.    □

Yang et al. [14] proposed a top-down index construction exploiting subgraph nesting. Building on this, Lemma 4 allows pruning: when computing $(k,l,\eta )$-core, vertices satisfying ${\eta }_{(k+1,l)}(v,{\mathcal{G}}_d)>\eta$ can be skipped. Thus, we adopt a top-down approach instead of bottom-up, reducing redundant computations.

Algorithm 7 details the hybrid index construction. First, we obtain $k_{\max }$ and $l_{\max }$ for the deterministic graph $G_d$ (line 1). Then, we initialize thresholds ${\epsilon }_{\mathrm{in}}$, ${\epsilon }_{\mathrm{out}}$ and the index arrays (lines 2–4). Neighbors are sorted by $\min ({\mathrm{core}}_{\mathrm{in}},{\mathrm{core}}_{\mathrm{out}})$ (line 5). Next, we construct the DUCS-E part (lines 6–10) and the DUCS part (lines 11–18). For DUCS-E, we identify vertices satisfying both in-degree and out-degree structural constraints (line 8), compute ${\mathrm{P}\mathrm{r}}_{\mathrm{in}}$ and ${\mathrm{P}\mathrm{r}}_{\mathrm{out}}$ (line 9), then iteratively delete the vertex with minimum Pr, updating and storing results (line 10). For DUCS, we sort neighbors separately by ${\mathrm{core}}_{\mathrm{in}}$ and ${\mathrm{core}}_{\mathrm{out}}$ (line 11), then for each k (lines 12–14) and each l (lines 15–17) we apply the corresponding procedures from Algorithm 3 and Algorithm 5 to build ${\mathit{Seq}}_{\eta }^{\mathrm{in}}$ and ${\mathit{Seq}}_{\eta }^{\mathrm{out}}$.

Theorem 10. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the time complexity of Algorithm 7 is

$$O\left(\max \left(\right|E_{\mathrm{in}}|,|E_{\mathrm{out}}\left|\right)+k_{\max }^2|E_{\mathrm{in}}|+l_{\max }^2|E_{\mathrm{out}}|+(k_{\max }+l_{\max })·\left|V\right|log\left|V\right|\right).$$

Proof. 

The complexity is dominated by the DUCS-E and DUCS index constructions. By Theorem 7, top-down DUCS-E construction costs $O(\left({\epsilon }_{\mathrm{in}}{\epsilon }_{\mathrm{out}}\right)·(\max ({\epsilon }_{\mathrm{in}},{\epsilon }_{\mathrm{out}})·\left|V\right|log\left|V\right|+{\epsilon }_{\mathrm{in}}|E_{\mathrm{in}}|+{\epsilon }_{\mathrm{out}}|E_{\mathrm{out}}\left|\right))$. By Theorem 4, DUCS construction costs $O\left(k_{\max }^2\right|E_{\mathrm{in}}|+l_{\max }^2|E_{\mathrm{out}}|+(k_{\max }+l_{\max })|V|log|V\left|\right)$. Since ${\epsilon }_{\mathrm{in}}\le k_{\max }$ and ${\epsilon }_{\mathrm{out}}\le l_{\max }$, the total simplifies to the stated bound.    □

Theorem 11. 

Given a directed uncertain graph ${\mathcal{G}}_d=(V,E,p)$, the space complexity of Algorithm 7 is

$$O\left(\sum _{v\in V}\left(k_{\max }-{\epsilon }_{\mathrm{in}}+l_{\max }-{\epsilon }_{\mathrm{out}}+{\epsilon }_{\mathrm{in}}·{\epsilon }_{\mathrm{out}}\right)\right).$$

Proof. 

The DUCS index stores information for $k\in [{\epsilon }_{\mathrm{in}}+1,k_{\max }]$ and $l\in [{\epsilon }_{\mathrm{out}}+1,l_{\max }]$. From Theorem 5 (adapted to per-vertex sums), its space complexity is $O\left({\sum }_{v\in V}(k_{\max }-{\epsilon }_{\mathrm{in}}+l_{\max }-{\epsilon }_{\mathrm{out}})\right)$. The DUCS-E index stores information for $k\in [1,{\epsilon }_{\mathrm{in}}]$ and $l\in [1,{\epsilon }_{\mathrm{out}}]$. By Theorem 8, its space complexity is $O\left({\sum }_{v\in V}({\epsilon }_{\mathrm{in}}·{\epsilon }_{\mathrm{out}})\right)$. Summing gives the result.    □

7. Algorithm Comparison

We now compare the time and space complexities of the Baseline, DUCS, DUCS-E, and Hybrid algorithms.

Table 1. Comparison of query time across different algorithms.

Algorithm	Time Complexity
Baseline	$O\left(\left|V\right|+{\sum }_{v\in V}\left(\max (\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))·\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)\right)$
DUCS-E	$O\left({\sum }_{v\in V}\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right))+\left|V\right|\right)$
DUCS	$O\left(\left|V\right|+{\sum }_{v\in V^{\prime }}\left(\max (\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))·\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)\right)$
Hybrid	$O\left({\sum }_{v\in V^{\prime }}\left(\max (\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),\eta \text{-}{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))·\max ({\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{in}}\left(v\right),{\mathrm{D}\mathrm{e}\mathrm{g}}_{\mathrm{out}}\left(v\right))\right)\right)$

shows that the Baseline algorithm has the highest query time due to exhaustive computation. DUCS-E is the most efficient, while DUCS and Hybrid trade off some efficiency for lower index size.

Table 2. Comparison of index construction time across different algorithms.

Algorithm	Time Complexity
DUCS-E	$O\left((k_{\max }·l_{\max })·\left(\max (k_{\max },l_{\max })·\left(\right|V|log|V|+\left|E\right|)\right)\right)$
DUCS	$O\left(k_{\max }^2|E_{\mathrm{in}}|+l_{\max }^2|E_{\mathrm{out}}|+(k_{\max }+l_{\max })·\left|V\right|log\left|V\right|\right)$
Hybrid	$O\left(\max \left(\right|E_{\mathrm{in}}|,|E_{\mathrm{out}}\left|\right)+k_{\max }^2|E_{\mathrm{in}}|+l_{\max }^2|E_{\mathrm{out}}|+(k_{\max }+l_{\max })·\left|V\right|log\left|V\right|\right)$

indicates that DUCS-E incurs the highest construction cost, while DUCS and Hybrid are more scalable, especially Hybrid which balances between the two.

Table 3. Index size comparison across different algorithms.

Algorithm	Space Complexity
DUCS-E	$O\left({\sum }_{v\in V}\left({\mathrm{core}}_{\mathrm{in}}\left(v\right)·{\mathrm{core}}_{\mathrm{out}}\left(v\right)\right)\right)$
DUCS	$O\left({\sum }_{v\in V}\left({\mathrm{core}}_{\mathrm{in}}\left(v\right)+{\mathrm{core}}_{\mathrm{out}}\left(v\right)\right)\right)$
Hybrid	$O\left({\sum }_{v\in V}\left(k_{\max }-{\epsilon }_{\mathrm{in}}+l_{\max }-{\epsilon }_{\mathrm{out}}+{\epsilon }_{\mathrm{in}}{\epsilon }_{\mathrm{out}}\right)\right)$

highlights the storage trade-offs. DUCS-E requires the most space, DUCS the least, and Hybrid offers a middle ground, making it suitable for large-scale applications.

In summary, DUCS-E provides the fastest queries but at high construction cost and memory usage. DUCS is lightweight but requires additional verification. Hybrid combines the strengths of both, achieving a practical balance between query efficiency, construction time, and index size.

8. Experiments

8.1. Experimental Setup

All experiments were conducted on a Linux server equipped with a 2.10 GHz Intel(R) Xeon(R) Gold 5218R CPU and 1 TB of DDR4 RAM. The algorithms under comparison fall into two main categories: query algorithms and index construction algorithms.

In the experimental evaluation, the Baseline algorithm refers to Algorithm 1. The query algorithm and index construction algorithm based on the DUCS-E index are denoted as Algorithms 2 and 3, respectively. Similarly, the DUCS-based query and construction algorithms are Algorithms 4 and 5, and the Hybrid-based ones are Algorithms 6 and 7.

All algorithms were implemented in C++ and compiled with the g++ compiler using the -O3 optimization level. Experiments that ran for more than 24 h were terminated prematurely.

Evaluation Metrics. (1) $(k,l,\eta )$-core query efficiency; (2) index size and construction efficiency; (3) community member similarity comparison; (4) scalability.

Datasets. We use six real-world datasets from SNAP (https://snap.stanford.edu/ (accessed on 7 July 2025)).

Table 4. Dataset statistics.

Dataset	$\left|\mathit{V}\right|$	$\left|\mathit{E}\right|$	${\mathit{k}}_{\max }$	${\mathit{l}}_{\max }$
wiki-Vote	8297	103,689	19	15
web-Stanford	281,903	2,312,497	41	41
web-Google	875,713	5,105,039	32	32
web-BerkStan	685,230	7,600,595	162	162
soc-Pokec	1,632,803	30,622,564	32	31
soc-LiveJournal1	4,847,571	68,993,773	252	253

summarizes the number of vertices, edges, maximum in-degree, maximum out-degree, maximum in-core number, and maximum out-core number for each dataset.

• wiki-Vote: a voting network on Wikipedia, where nodes represent users and edges represent voting relationships. We assign each edge a uniformly random probability in $[0,1]$ to indicate the likelihood of one user voting for another.
• web-Stanford, web-Google, web-BerkStan: web graphs where nodes represent web pages and edges represent hyperlinks. Each edge is assigned a uniformly random probability in $[0,1]$ representing the likelihood of a hyperlink from one page to another.
• soc-Pokec, soc-LiveJournal1: social networks where nodes represent users and edges represent social connections. Again, we assign a uniformly random probability in $[0,1]$ to each edge to indicate the probability of a friendship or connection.

8.2. Parameters Setting

Setting ${\epsilon }_{\mathrm{in}}$ and ${\epsilon }_{\mathrm{out}}$. The key to the Hybrid index is choosing appropriate ${\epsilon }_{\mathrm{in}}$ and ${\epsilon }_{\mathrm{out}}$. Figure 6 shows how the construction time of the Hybrid index and the query time vary with ${\epsilon }_{\mathrm{in}},{\epsilon }_{\mathrm{out}}$. The x-axis represents the percentage of $k_{\max }$ and $l_{\max }$ (e.g., 10% means ${\epsilon }_{\mathrm{in}}=0.1k_{\max }$, ${\epsilon }_{\mathrm{out}}=0.1l_{\max }$). The left y-axis is the construction time, the right y-axis is the query time for type-(b) queries (both parameters larger than the thresholds). As ${\epsilon }_{\mathrm{in}},{\epsilon }_{\mathrm{out}}$ increase, construction time rises while query time falls.

Figure 6a (smaller datasets) shows that query time stabilizes when ${\epsilon }_{\mathrm{in}},{\epsilon }_{\mathrm{out}}$ reach 30%. Hence, we set ${\epsilon }_{\mathrm{in}}=0.3k_{\max }$, ${\epsilon }_{\mathrm{out}}=0.3l_{\max }$. For web-Google, this yields construction time 324 s and query time 0.004 s; increasing to 40% increases construction time to 416 s with negligible improvement in query time.

Figure 6b (larger datasets) indicates that query time stabilizes when ${\epsilon }_{\mathrm{in}},{\epsilon }_{\mathrm{out}}$ are around 30%. For web-BerkStan, setting them to 32 gives construction time 4049 s and query time 0.004 s; increasing to 30% of $k_{\max },l_{\max }$ raises construction time to 15,399 s with no improvement in query time. For soc-LiveJournal1, exceeding 30% leads to construction time over 24 h. Therefore, we set ${\epsilon }_{\mathrm{in}}=\min \{0.3k_{\max },30\}$ and ${\epsilon }_{\mathrm{out}}=\min \{0.3l_{\max },30\}$ in practice.

We follow the $\eta$ settings of [14], namely $0.1,0.3,0.5,0.7,0.9$, with a default value of $0.5$. Given ${\epsilon }_{\mathrm{in}}$ and ${\epsilon }_{\mathrm{out}}$, three types of queries are defined in below, where k and l for each dataset are given in

Table 5. Query parameters k and l settings.

Dataset	Query Type	k	l
wiki-Vote	a	3	4
	b	8	10
	c	4	8
web-Stanford	a	4	8
	b	20	25
	c	5	16
web-Google	a	4	5
	b	15	20
	c	5	15
web-BerkStan	a	5	10
	b	40	40
	c	10	35
soc-Pokec	a	4	5
	b	15	20
	c	5	15
soc-LiveJournal1	a	5	10
	b	40	40
	c	10	35

, due to that different datasets have different $k_{\max }$ and $l_{\max }$.

(a)

$k<{\epsilon }_{\mathrm{in}}$ and $l<{\epsilon }_{\mathrm{out}}$;

(b)

$k\ge {\epsilon }_{\mathrm{in}}$ and $l\ge {\epsilon }_{\mathrm{out}}$;

(c)

($k<{\epsilon }_{\mathrm{in}}$ and $l\ge {\epsilon }_{\mathrm{out}}$) or ($k\ge {\epsilon }_{\mathrm{in}}$ and $l<{\epsilon }_{\mathrm{out}}$).

8.3. Query Efficiency Comparison and Analysis

Effect of $\eta$ on query efficiency. Figure 7, Figure 8 and Figure 9 compare the query efficiency of Baseline, DUCS, DUCS-E, and Hybrid for the three query types, varying $\eta$ while keeping k and l fixed.

Figure 7 shows the query time for type-(a) queries. The Hybrid and DUCS-E algorithms achieve the best performance, being at least four orders of magnitude faster than Baseline. On most datasets, they are at least two orders of magnitude faster than DUCS. For example, on soc-LiveJournal1, Baseline exceeds 50 s, DUCS exceeds 10 s, while Hybrid and DUCS-E both stay below 0.1 s. The high cost of Baseline stems from recomputing vertex probabilities for every query. DUCS is slower because it still requires an online verification step. In contrast, Hybrid and DUCS-E directly return results using the precomputed index.

Figure 8 presents the query time for type-(b) queries. The DUCS, DUCS-E, and Hybrid algorithms have essentially the same performance, all about five orders of magnitude faster than Baseline. This is because type-(b) queries produce a small result set, minimizing the verification overhead for DUCS and Hybrid. For instance, on wiki-Vote with $k=8$, $l=10$, no vertex satisfies the conditions. On denser datasets such as soc-LiveJournal1, DUCS and Hybrid still have query times above 0.1 s, while DUCS-E remains below 0.1 s due to the larger verification cost.

Figure 9 shows the query time for type-(c) queries. The DUCS-E algorithm exhibits stable query times. On smaller datasets, the query times of DUCS and Hybrid decrease significantly as $\eta$ increases. On larger datasets, Hybrid is considerably faster than DUCS, because Hybrid prunes unnecessary vertices before the validation step.

Effect of k and l on query efficiency. Figure 10 (varying k) and Figure 11 (varying l) illustrate the impact of k and l on query time, with $\eta =0.5$.

DUCS-E consistently outperforms the other methods, being three to five orders of magnitude faster than Baseline. For example, on web-BerkStan with $(k,l,\eta )=(10,10,0.5)$, Baseline takes 187 s while DUCS-E takes only 7 ms. The query time of Baseline and DUCS-E remains relatively stable as k or l increases, because these algorithms are less sensitive to parameter changes.

As k (or l) increases, the query time of DUCS gradually decreases, because the size of the query subgraph shrinks, reducing verification cost. On soc-LiveJournal1, DUCS takes 8.74 s for $(k,l)=(10,10)$ but only 0.18 s for $(10,50)$.

The Hybrid algorithm’s query time first increases and then decreases. When k and l are below the thresholds ${\epsilon }_{\mathrm{in}},{\epsilon }_{\mathrm{out}}$, the query is type-(a) and results are obtained directly from the index, resulting in low time. When k or l exceeds the thresholds, the query becomes type-(c) and requires verification, increasing the time. As k or l further increases, the number of qualifying vertices drops, and the verification cost falls again. For instance, on soc-Pokec with ${\epsilon }_{\mathrm{in}}={\epsilon }_{\mathrm{out}}=10$, Hybrid takes 0.04 s for $(6,6)$, 0.54 s for $(6,12)$, and 0.06 s for $(6,30)$ (no vertices meet the criteria).

In summary, Baseline is unsuitable for efficient query processing. DUCS is generally slower than DUCS-E and Hybrid. DUCS-E and Hybrid achieve the best query efficiency, especially on larger datasets: for type-(a), DUCS-E and Hybrid are optimal; for type-(b), all three index-based algorithms perform well; for type-(c), DUCS-E maintains the most stable and best performance.

8.4. Index Size and Index Construction Time

Index size comparison. From Figure 12a, the DUCS-E index is the largest, followed by Hybrid, and DUCS is the smallest. DUCS-E stores all $(k,l)$ combinations, requiring the most space. DUCS stores only two approximate indices for in-degree and out-degree separately, thus the smallest. Hybrid stores both a partial precise index and partial approximate indices, resulting in moderate space. For soc-LiveJournal1, DUCS-E exceeds 9000 MB, Hybrid uses 4210 MB, and DUCS uses 1006 MB.

Index construction time comparison. Figure 12b shows that DUCS-E has the longest construction time, especially on large datasets (e.g., soc-LiveJournal1 exceeds 24 h). DUCS is the fastest. On wiki-Vote, Hybrid takes only 1.3 s, ten times faster than DUCS-E. On soc-LiveJournal1, Hybrid finishes in 7.8 h, while DUCS-E exceeds 24 h (at least three times slower).

8.5. Model Comparison

If edge directions are ignored, a directed graph becomes an undirected graph with fewer edges (bidirectional edges become a single edge). To evaluate effectiveness, we follow [21] and set the $(k,\eta )$-core query parameter k to $0.7·(k+l)$. We choose different $(k,l)$ pairs for different datasets to ensure a fair comparison. We use community member similarity (CMS) as the quality metric.

Community Member Similarity (CMS). A cohesive community should have high internal similarity. We use the Jaccard index to measure similarity between two vertices based on common in-neighbors and out-neighbors. For a vertex set C, we define

$$\mathrm{CMS}{\left(C\right)}^{\mathrm{in}}={\displaystyle \frac{1}{{\left|C\right|}^2}}\sum _{u\in C}\sum _{v\in C}{\displaystyle \frac{\left|\mathrm{in}\right(u)\cap \mathrm{in}(v\left)\right|}{\left|\mathrm{in}\right(u)\cup \mathrm{in}(v\left)\right|}},$$

(7)

$$\mathrm{CMS}{\left(C\right)}^{\mathrm{out}}={\displaystyle \frac{1}{{\left|C\right|}^2}}\sum _{u\in C}\sum _{v\in C}{\displaystyle \frac{\left|\mathrm{out}\right(u)\cap \mathrm{out}(v\left)\right|}{\left|\mathrm{out}\right(u)\cup \mathrm{out}(v\left)\right|}}.$$

(8)

Both measures lie in $[0,1]$, with larger values indicating higher cohesion. Figure 13 shows that the $(k,l,\eta )$-core model yields substantially higher CMS values than the $(k,\eta )$-core model on undirected graphs. For example, on soc-LiveJournal1, $(k,\eta )$-core gives ${\mathrm{CMS}}^{\mathrm{in}}=0.00002$ and ${\mathrm{CMS}}^{\mathrm{out}}=0.00001$, while our model gives $0.0018$ and $0.0014$, respectively—an improvement of over two orders of magnitude.

8.6. Scalability Testing

Due to space limitations, we only report scalability tests on the largest dataset, soc-LiveJournal1. As shown in Figure 14, we sampled nodes and edges from 20% to 100% uniformly at random. For node sampling, we take the induced subgraph of the sampled nodes; for edge sampling, we include all incident nodes. The figure shows the index construction time and space consumption for DUCS, DUCS-E, and Hybrid as the graph size increases.

All three methods exhibit increasing construction time and space with larger $\left|V\right|$ or $\left|E\right|$. Hybrid consistently requires less time and space than DUCS-E. These results demonstrate that the proposed Hybrid index construction and DUCS construction scale well.

8.7. Experiments on Software Engineering and Electronics-Related Datasets

Here, we conducted additional experiments on two publicly available datasets, which are related to software engineering and electronics. We present the results separately, due to their relatively small sizes.

The first dataset is the linux kernel function call graph (https://zenodo.org/record/2652487 (accessed on 18 July 2026)) with 3973 vertices and 30,500 edges, where each vertex represents a C source file in the Linux kernel, and each directed edge $(u,v)$ indicates that source file u calls one or more functions defined in source file v. The direction is naturally irreversible, representing the static dependency relationship between files. The graph captures the inter-file function call dependencies extracted through static analysis of the Linux kernel v4.21 source code. Due to the presence of conditional compilation (e.g., #ifdef CONFIG_XXX), the same function call may be included or excluded depending on the compilation configuration, which naturally introduces uncertainty into the dependency graph. The edge probability $p(u,v)$ is computed by counting the frequency of calls from file u to file v in the raw data, and then mapping the frequency to a probability value using a log-scaled transformation. A higher call frequency indicates that the dependency exists under more compilation paths, and thus has a higher probability.

The second dataset is MIT reality mining human contact network (https://ieee-dataport.org/open-access/crawdad-mitreality (accessed on 18 July 2026)) with 96 vertices and 5078 edges, where each vertex represents a participant (student or faculty member) at MIT Media Lab who carried a Nokia 6600 smartphone equipped with logging software, and each directed edge $(u,v)$ exists if participant u was within Bluetooth range of participant v on at least one day during the 234-day observation period. As physical proximity is symmetric, we assign the same probability to both directions. The dataset captures human physical proximity patterns through Bluetooth device scans, which are representative of wireless sensor networks and IoT communication scenarios. The probability of an edge reflects the frequency and regularity of contact between two individuals over time. The observation period is divided into 234 daily windows. If person A appears within person B’s Bluetooth scan range at least once on a given day, that day is counted as a valid contact day. The edge probability $p(u,v)$ is then computed as the number of valid contact days divided by the total number of days (234). This models the inherent uncertainty in human mobility and interaction patterns.

The experimental results on these two datasets are summarized in

Table 6. Average query time and index overhead on additional datasets.

Dataset	Method	Index Size (MB)	Build Time (ms)	Avg. Query Time ($\times {10}^{-2}$ ms)
linux	Baseline	–	–	43.20
	DUCS-E	1.09	47.40	2.53
	DUCS	0.36	3.02	42.40
	Hybrid	0.48	7.95	42.20
mit	Baseline	–	–	18.90
	DUCS-E	0.21	552.00	0.71
	DUCS	0.02	0.19	17.00
	Hybrid	0.04	13.00	16.80

, where parameters are chosen in the same way as Section 8.2. We emphasize that these datasets are considerably smaller than the six large-scale benchmarks (wiki-Vote, web-Stanford, web-Google, web-BerkStan, soc-Pokec, and soc-LiveJournal1) used above. As shown in Table 4 of the main paper, the largest dataset (soc-LiveJournal1) contains over 4.8 million vertices and 68 million edges. Due to the significant scale difference, we present these results separately rather than integrating them into the main experimental section, to maintain the focus on the scalability and efficiency of our methods on large graphs.

The experimental results on both datasets are fully consistent with the main findings reported in this paper:

• Index-based methods significantly outperform the online baseline: On linux, DUCS-E achieves a 17× speed-up over Baseline; on mit, DUCS-E achieves a 26× speed-up.
• DUCS-E achieves the fastest query response: 2.53 $\times {10}^{-2}$ ms on linux and 0.71 $\times {10}^{-2}$ ms on mit.
• DUCS requires the smallest index storage: 0.36 MB on linux and 0.02 MB on mit.
• Hybrid provides the best trade-off: It achieves query times close to DUCS-E (42.20 vs. 2.53 on linux; 16.80 vs. 0.71 on mit) while requiring significantly less storage than DUCS-E (0.48 MB vs. 1.09 MB on linux; 0.04 MB vs. 0.21 MB on mit).

8.7.1. Implications for Software Engineering Applications

The linux dataset demonstrates the practical applicability of our methods to software engineering scenarios:

• Dependency Analysis: The $(k,l,\eta )$-core can identify a core set of mutually dependent source files in large software systems. Files with both high in-degree (many files depend on them) and high out-degree (they depend on many others) represent the most critical and tightly coupled components.
• Conditional Compilation Uncertainty: The edge probabilities derived from conditional compilation frequencies naturally model the uncertainty in build-time dependencies. Our index-based methods enable fast, on-the-fly identification of stable dependency cores under different compilation configurations.
• Maintenance Prioritization: By querying different $(k,l,\eta )$ parameter combinations, software engineers can identify modules that are critical for system stability and should be prioritized for testing, refactoring, and security auditing.

8.7.2. Implications for Electronics/Sensor Network Applications

The mit dataset validates the applicability to wireless sensor networks and IoT scenarios:

• Contact Pattern Analysis: The $(k,l,\eta )$-core can identify stable and reliable communication clusters in mobile ad-hoc networks, where contacts are probabilistic and time-varying.
• Network Reliability: The edge probabilities reflect communication reliability or contact frequency. Our methods enable fast identification of subgraphs where both sending and receiving capabilities exceed desired thresholds with high probability, which is crucial for routing and topology control.
• Scalability to Larger Sensor Networks: Although the mit dataset is small (96 nodes), the consistency of our results with large-scale graph experiments suggests that the proposed methods can scale to larger IoT deployments.

These results further strengthen the generalizability of our contributions and confirm the relevance of our work to the software engineering and electronics communities.

8.8. Discussion

8.8.1. Lazy Caching vs. Exhaustive Precomputation

We discuss an alternative strategy suggested: lazy caching (memoization), where the result of a $(k,l,\eta )$-core query is computed only upon its first occurrence and cached for subsequent queries. This approach can be efficient when the number of distinct queries is small or the query workload is highly repetitive. However, it has several limitations compared to our exhaustive precomputation strategy.

First, in the worst case where all possible $(k,l)$ combinations are queried at least once, lazy caching degenerates to the online algorithm and incurs the same total computation cost as running all queries from scratch. In contrast, DUCS-E guarantees constant-time response for any query after a single offline construction phase, regardless of the query workload.

Second, the Hybrid index proposed in this paper already bridges the gap between exhaustive precomputation and on-demand computation. By selectively storing DUCS-E for small $k,l$ and DUCS for large $k,l$, Hybrid avoids the high storage cost of full precomputation while still providing fast query processing for most practical scenarios.

Third, implementing and benchmarking a memoization strategy would require defining a specific query workload distribution (e.g., Zipfian, uniform, or repeated patterns), which is highly application-dependent and may not lead to generally applicable conclusions. Since the focus of this paper is on the algorithmic design of exact $(k,l,\eta )$-core query processing, we believe that the systematic comparison among the online algorithm, DUCS, DUCS-E, and Hybrid is sufficient to demonstrate the effectiveness and efficiency of our proposals.

8.8.2. Index Trade-Offs

We highlight the relationship among the three indexing structures from an empirical perspective. As shown in Figure 7, Figure 8, Figure 9 and Figure 10, DUCS-E consistently achieves the fastest query response time across all settings, at the cost of the largest index size and longest construction time. In contrast, DUCS requires significantly less storage and construction overhead but incurs higher query latency due to the need for online verification. The Hybrid index, by tuning ${\epsilon }_{\mathrm{in}}$ and ${\epsilon }_{\mathrm{out}}$, seamlessly interpolates between these two extremes, offering a flexible and practical solution that balances query efficiency and index overhead. This confirms that DUCS-E and DUCS represent the upper and lower bounds of both query time and index size, with Hybrid falling in between and providing the best overall trade-off for most application scenarios.

9. Related Work

This section briefly reviews related work on core decomposition in deterministic and uncertain graphs.

9.1. Core Decomposition on Deterministic Graphs

The concept of k-core was introduced by Seidman [25] as a maximal subgraph where each vertex has degree at least k. Core decomposition aims to find all k-cores.

k-core decomposition on undirected graphs. Many algorithms have been proposed, notably peeling-based methods [26,27,28] that iteratively remove minimum-degree vertices. Parallel and distributed solutions have also been developed, e.g., using MapReduce [27,28] or Spark [29,30].

D-core decomposition on directed graphs. To account for edge direction, the directed core (D-core) or $(k,l)$-core model was proposed [21,22,31]. Peeling-based algorithms remove vertices that do not satisfy in-degree or out-degree constraints. Later, a distributed D-core decomposition algorithm was introduced [32] using the concept of skyline coreness and H-index to improve efficiency.

9.2. Core Decomposition on Uncertain Graphs

Bonchi et al. [12] first defined the $(k,\eta )$-core in uncertain graphs, a maximal subgraph where each vertex has probability at least $\eta$ of having degree $\ge k$. They proposed a peeling algorithm based on $\eta$-degree. Esfahani et al. [33] accelerated the computation using the Lyapunov central limit theorem. Yang et al. [14] designed an index-based optimal algorithm for $(k,\eta )$-core queries. Wen et al. [34] extended the index to external memory. Dai et al. [15] addressed precision issues and proposed an exact algorithm.

Existing work on core decomposition for directed graphs does not consider uncertainty, and existing probabilistic core decomposition ignores edge directions. Therefore, none of these methods can be directly applied to $(k,l,\eta )$-core queries, motivating our specialized solution.

9.3. Topic-Aware Most Influential Community Search

Teng et al. [24] recently introduced the TAMICS problem, which also utilizes the $(k,l,\eta )$-core model for cohesiveness. However, their work differs from ours in two fundamental aspects. First, their goal is to find the community with the maximum influence score for a given topic, whereas we aim to answer arbitrary $(k,l,\eta )$-core queries efficiently. Second, their indexing strategies (TUC-list and TIE-tree) are tailored for influence and topic estimation, while our proposed DUCS, DUCS-E, and Hybrid indexes are specifically designed to optimize core computation and verification. Therefore, our work provides the first dedicated solution for the core problem of efficient $(k,l,\eta )$-core query processing.

9.4. Other Related Work

Beyond $(k,\eta )$-core, other problems have been studied in uncertain graphs, including influence community search [35], butterfly counting and bitruss decomposition on bipartite graphs [17,36], maximal clique mining [16], reliable clustering [37,38], and k-truss computation [19,20,39].

10. Conclusions

In this paper, we presented the first in-depth study on efficient $(k,l,\eta )$-core queries in directed uncertain graphs. Distinct from the concurrent work on TAMICS [24], which focuses on topic-aware influence maximization, our work establishes the foundational building blocks for core decomposition in this setting, providing a family of algorithms and indexes that enable fast, exact core queries. We first present an online query algorithm based on the $(k,l,\eta )$-core decomposition. To further optimize query efficiency, we develop two indexing structures, the DUCS-E index and the DUCS index, leading to the DUCS-E Query and DUCS Query algorithms. Furthermore, to enhance query efficiency while reducing index overhead, we propose a hybrid index structure called the Hybrid index, which combines the advantages of DUCS and DUCS-E. The Hybrid index ensures efficient query processing while lowering index construction time and space consumption. Experimental results demonstrate that the index-based query algorithms achieve a four-order-of-magnitude improvement in query speed compared to the online query algorithm, validating the effectiveness and scalability of our proposed methods.

As lazy caching could be beneficial in environments with skewed query distributions, an interesting direction for future work is extending our indexing framework to support workload-aware caching and dynamic index updates.