Reachability Queries Research Articles

Answering billion-scale label-constrained reachability queries within microsecond

In this paper, we study the problem of label-constrained reachability (LCR) query which is fundamental in many applications with directed edge-label graphs. Although the classical reachability query (i.e., reachability query without label constraint) has been extensively studied, LCR query is much more challenging because the number of possible label constraint set is exponential to the size of the labels. We observe that the existing techniques for LCR queries only construct partial index for better scalability, and their worst query time is not guaranteed and could be the same as an online breadth-first search (BFS). In this paper, we propose novel label-constrained 2-hop indexing techniques with novel pruning rules and order strategies. It is shown that our worst query time could be bounded by the in-out index entry size. With all these techniques, comprehensive experiments show that our proposed methods significantly outperform the state-of-the-art technique in terms of query response time (up to 5 orders of magnitude speedup), index size and index construction time. In particular, our proposed method can answer LCR queries within microsecond over billion-scale graphs in a single machine.

Mining Spatio-Temporal Reachable Regions With Multiple Sources over Massive Trajectory Data

Given a set of user-specified locations and a massive trajectory dataset, the task of mining spatio-temporal reachable regions aims at finding which road segments are reachable from these locations within a given temporal period based on the historical trajectories. Determining such spatio-temporal reachable regions with high accuracy is vital for many urban applications, such as location-based recommendations and advertising. Traditional approaches to answering such queries essentially perform a distance-based range query over the given road network, which does not consider dynamic travel time at different time of day. By contrast, we propose a data-driven approach to formulate the problem as mining actual reachable regions based on a real historical trajectory dataset. Efficient algorithms for the Single-location spatio-temporal reachability Query (S-Query) and the Union-of-multi-location spatio-temporal reachability Query (U-Query) were presented in our recent work. In this paper, we extend the previous ideas by introducing a new type of reachability query with multiple sources, namely, the Intersection-of-multi-location spatio-temporal reachability Query (I-Query). As we demonstrate, answering I-Queries efficiently is generally more computationally challenging than answering either S-Queries or U-Queries because I-Queries involve complicated intersect conditions. We propose two new algorithms called the Intersection-of-Multi-location Query Maximum Bounding region search (I-MQMB) algorithm and the I-Query Trace Back Search (I-TBS) algorithm to efficiently answer I-Queries, which utilize an indexing schema composed of a spatio-temporal index and a connection index. We evaluate our system extensively by using a large-scale real taxi trajectory dataset that records taxi rides in Shenzhen, China. Our results demonstrate that the proposed approach reduces the running time of I-Queries by 50 percent on average compared to the baseline method.

Efficient distributed reachability querying of massive temporal graphs

Reachability computation is a fundamental graph functionality with a wide range of applications. In spite of this, little work has as yet been done on efficient reachability queries over temporal graphs, which are used extensively to model time-varying networks, such as communication networks, social networks, and transportation schedule networks. Moreover, we are faced with increasingly large real-world temporal networks that may be distributed across multiple data centers. This state of affairs motivates the paper’s study of efficient reachability queries on distributed temporal graphs. We propose an efficient index, called Temporal Vertex Labeling (TVL), which is a labeling scheme for distributed temporal graphs. We also present algorithms that exploit TVL to achieve efficient support for distributed reachability querying over temporal graphs in Pregel-like systems. The algorithms exploit several optimizations that hinge upon non-trivial lemmas. Extensive experiments using massive real and synthetic temporal graphs are conducted to provide detailed insight into the efficiency and scalability of the proposed methods, covering both index construction and query processing. Compared with the state-of-the-art methods, the TVL based query algorithms are capable of up to an order of magnitude speedup with lower index construction overhead.

Modular Decomposition-Based Graph Compression for Fast Reachability Detection

Fast reachability detection is one of the key problems in graph applications. Most of the existing works focus on creating an index and answering reachability based on that index. For these approaches, the index construction time and index size can become a concern for large graphs. More recently query-preserving graph compression has been proposed, and searching reachability over the compressed graph has been shown to be able to significantly improve query performance as well as reducing the index size. In this paper, we introduce a multilevel compression scheme for DAGs, which builds on existing compression schemes, but can further reduce the graph size for many real-world graphs. We propose an algorithm to answer reachability queries using the compressed graph. Extensive experiments with four existing state-of-the-art reachability algorithms and 12 real-world datasets demonstrate that our approach outperforms the existing methods. Experiments with synthetic datasets ensure the scalability of this approach. We also provide a discussion on possible compression for k-reachability.

An efficient incremental strongly connected components algorithm for evolving directed graphs

The strongly connected components (SCC) algorithm can contract a directed graph into a directed acyclic graph and is widely used in directed graph analysis applications, such as reachability queries. A variety of SCC algorithms for static directed graphs have been proposed but such algorithms require non-negligible runtime overheads to repeatedly perform computations on an entire graph in response to the frequent changes in the evolving directed graphs that are ubiquitous in the real world. In general, evolving directed graphs are often evolving with minor changes (less than 5%).It allows us to compute SCC in an evolving directed graph on the basis of incremental computations in order to reduce the response time. This paper proposes Inc-SCC, an efficient incremental SCC algorithm for evolving directed graphs, reducing the data access and computation overhead of the algorithm by eliminating unnecessary computations, and using the disjoint feature of SCC for parallel processing to improve the performance of the SCC algorithm. We propose a heuristic optimization method to further speed up the convergence of Inc-SCC. Experiments show that Inc-SCC can be used to enhance the timeliness for evolving directed graphs. When the number of the changed edges of the entire directed graph is 5%, the speedup of Inc-SCC over the existing algorithm is from 2.8 to 12 times. When the number of thechanged edges of an entire directed graph is 0.5%, the speedup of Inc-SCC over the existing algorithm is from 2.9 to 12 times.

An efficient reachability query based pruning algorithm in e-health scenario.

We propose a Disease-Symptom graph database for our mobile-assisted e-healthcare application. A large Disease-Symptom graph is stored in the cloud and accessed using mobile devices over the Internet. Query and search are the fundamental operations of graph databases. However, while searching the Disease-Symptom graph for making preliminary diagnosis of diseases, queries become complex due to the complex structure of data and also queries are too hard to write and interpret. Moreover, it is not possible to access the graph frequently due to limited bandwidth of the network, transmission delay, and higher cost. Subgraph generation or pruning algorithm for appropriate inputs is one of the solutions to this problem. In this paper, we propose an efficient pruning algorithm by introducing a new approach to decompose the Disease-Symptom graph into a series of symptom trees (ST). All the Symptom trees are merged to build a pruned subgraph which is our requirement. We demonstrate the efficiency and effectiveness of our pruning algorithm both analytically and empirically and validate on Disease-Symptom graph database, as well as other real graph databases. Also a comparison is done with an efficient existing reachability based Chain Cover algorithm after modifying it ChainCoverPrune as pruning algorithm. These two algorithms are tested for storage and access parametric measures for querying the synthetic and real directed databases to show the efficiency of the proposed algorithm.

Sparse Dynamic Programming on DAGs with Small Width

The minimum path cover problem asks us to find a minimum-cardinality set of paths that cover all the nodes of a directed acyclic graph (DAG). We study the case when the size k of a minimum path cover is small, that is, when the DAG has a small width . This case is motivated by applications in pan-genomics , where the genomic variation of a population is expressed as a DAG. We observe that classical alignment algorithms exploiting sparse dynamic programming can be extended to the sequence-against-DAG case by mimicking the algorithm for sequences on each path of a minimum path cover and handling an evaluation order anomaly with reachability queries . Namely, we introduce a general framework for DAG-extensions of sparse dynamic programming. This framework produces algorithms that are slower than their counterparts on sequences only by a factor k . We illustrate this on two classical problems extended to DAGs: longest increasing subsequence and longest common subsequence . For the former, we obtain an algorithm with running time O ( k | E |log | V |). This matches the optimal solution to the classical problem variant when the input sequence is modeled as a path. We obtain an analogous result for the longest common subsequence problem. We then apply this technique to the co-linear chaining problem, which is a generalization of the above two problems. The algorithm for this problem turns out to be more involved, needing further ingredients, such as an FM-index tailored for large alphabets and a two-dimensional range search tree modified to support range maximum queries. We also study a general sequence-to-DAG alignment formulation that allows affine gap costs in the sequence. The main ingredient of the proposed framework is a new algorithm for finding a minimum path cover of a DAG ( V , E ) in O ( k | E |log | V |) time, improving all known time-bounds when k is small and the DAG is not too dense. In addition to boosting the sparse dynamic programming framework, an immediate consequence of this new minimum path cover algorithm is an improved space/time tradeoff for reachability queries in arbitrary directed graphs.

$HT$ : A Novel Labeling Scheme for k-Hop Reachability Queries on DAGs

Given a directed acyclic graph (DAG), a k-hop reachability query u → ?k is used to answer whether there exists a path from u to v with length ≤ k. Answering k-hop reachability queries is a fundamental graph operation and has been extensively studied during the past years. Considering that existing approaches still suffer from inefficiency in practice when processing large graphs, we propose a novel labeling scheme, namely HT, to accelerate k-hop reachability queries answering. HTuses a constrained 2hop distance label to maintain the length of shortest paths between a set of hop nodes and other nodes, and for the remaining reachability information, HT uses a novel topological level to accelerate graph traversal. Further, we propose to enhance HT by two optimization techniques. The experimental results show that compared with the state-of-the-art approaches, HT works best for most graphs when answering k-hop reachability queries with small index size and reasonable index construction time.

Dynamic Complexity under Definable Changes

In the setting of dynamic complexity, the goal of a dynamic program is to maintain the result of a fixed query for an input database that is subject to changes, possibly using additional auxiliary relations. In other words, a dynamic program updates a materialized view whenever a base relation is changed. The update of query result and auxiliary relations is specified using first-order logic or, equivalently, relational algebra. The original framework by Patnaik and Immerman only considers changes to the database that insert or delete single tuples. This article extends the setting to definable changes , also specified by first-order queries on the database, and generalizes previous maintenance results to these more expressive change operations. More specifically, it is shown that the undirected reachability query is first-order maintainable under single-tuple changes and first-order defined insertions, likewise the directed reachability query for directed acyclic graphs is first-order maintainable under insertions defined by quantifier-free first-order queries. These results rely on bounded bridge properties , which basically say that, after an insertion of a defined set of edges, for each connected pair of nodes there is some path with a bounded number of new edges. While this bound can be huge, in general, it is shown to be small for insertion queries defined by unions of conjunctive queries. To illustrate that the results for this restricted setting could be practically relevant, they are complemented by an experimental study that compares the performance of dynamic programs with complex changes, dynamic programs with single changes, and with recomputation from scratch. The positive results are complemented by several inexpressibility results. For example, it is shown that—unlike for single-tuple insertions—dynamic programs that maintain the reachability query under definable, quantifier-free changes strictly need update formulas with quantifiers. Finally, further positive results unrelated to reachability are presented: it is shown that for changes definable by parameter-free first-order formulas, all LOGSPACE-definable (and even AC 1 -definable) queries can be maintained by first-order dynamic programs.

Reachability Is in DynFO

Patnaik and Immerman introduced the dynamic complexity class DynFO of database queries that can be maintained by first-order dynamic programs with the help of auxiliary relations under insertions and deletions of edges. This article confirms their conjecture that the reachability query is in DynFO. As a byproduct, it is shown that the rank of a matrix with small values can be maintained in DynFO. It is further shown that the (size of the) maximum matching of a graph can be maintained in non-uniform DynFO, an extension of DynFO, with non-uniform initialisation of the auxiliary relations.

One-Sided Weak Dominance Drawing

The Weak Dominance Drawing problem can be defined as follows: given a directed acyclic graph G, find two topological sorts, tX and tY, minimizing the size of the intersection between them. The intersection of two topological sorts is defined as the set of ordered pair of vertices (u,v) such that tX(u)<tX(v) and tY(u)<tY(v). In this work we consider a variation of this problem, that we call One-Sided Weak Dominance Drawing, in which one of the topological sorts is given as input and we must find another topological sort minimizing the intersection set with the given one. This problem has been considered in the literature and its applications include index generation of competitive algorithms for reachability queries on very large graphs. In this paper we formalize the problem, describe one of its applications, show how the problem is currently tackled in the literature, prove that its decision version is NP-complete and determine a primal bound for it as a function of the dimension of G.

Efficiently Answering Reachability Queries for Tree-Structured Data in Repetitive Prime Number Labeling Schemes

Reachability queries plays a crucial role in accessing relationships between nodes in tree-structured data. Previous studies have proposed prime number labeling schemes that answer reachability queries using arithmetic operations. However, the prime numbers in these schemes can become very large when a tree contains a considerable number of nodes; thus, it is not scalable. Recently, a repetitive prime number labeling scheme that reduces space requirements was proposed. Unfortunately, it suffers from slow query processing, owing to the complexity of its reachability test. In this paper, we propose a more efficient method for answering reachability queries in a repetitive prime number labeling scheme. The results of experiments using real-world XML datasets show that our approach reduces reachability query processing times.

Accelerating reachability query processing based on $$\varvec{DAG}$$ DAG reduction

Answering reachability queries is one of the fundamental graph operations. The existing approaches build indexes and answer reachability queries on a directed acyclic graph (DAG) $$G$$ , which is constructed by coalescing each strongly connected component of the given directed graph $$\mathcal {G}$$ into a node of $$G$$ . Considering that $$G$$ can still be large to be processed efficiently, there are studies to further reduce $$G$$ to a smaller graph. However, these approaches suffer from either inefficiency in answering reachability queries, or cannot scale to large graphs. In this paper, we study DAG reduction to accelerate reachability query processing, which reduces the size of $$G$$ by computing transitive reduction (TR) followed by computing equivalence reduction (ER). For TR, we propose a bottom-up algorithm, namely buTR, which removes from $$G$$ all redundant edges to get the unique smallest DAG $$G^{t}$$ satisfying that $$G^{t}$$ has the same transitive closure as that of $$G$$ . For ER, we propose a divide-and-conquer algorithm, namely linear-ER. Given the result $$G^{t}$$ of TR, linear-ER gets a smaller DAG $$G^{\varepsilon }$$ in linear time based on equivalence relationship between nodes in $$G$$ . Our DAG reduction approaches (TR and ER) significantly improve the cost of time and space and can be scaled to large graphs. Based on the result of DAG reduction, we further propose a graph decomposition-based algorithm to efficiently answer reachability queries. We confirm the efficiency of our approaches by extensive experimental studies for TR, ER, and reachability query processing using 20 real datasets. The complete source code is available for download at https://pan.baidu.com/s/1skHBXXN .

The Optimization Reachability Query of Large Scale Multi-Attribute Constraints Directed Graph

Today, many applications such as social network and biological network develop rapidly,the graph data will be expanded constantly on a large scale. Some classic methods can not effectively solve this scale of the graph data. In the reachability query, many technologies such as N-Hop, tree, interval labels, uncertain graph processing are emerging, they also solve a lot of questions about reachability query of graph. But, these methods have not put forward the effective solution for the new issues of the multiattribute constraints reachability on directed graph. In this paper, TCRQDG algorithm effectively solves this new problem. Firstly it optimizes the multiattribute constraints with decision making technology; secondly the algorithm achieves fast and accurate query by integrating with the Create virtual vertex expand, conditions filtering, cycles contraction, interval label and other technology. TCRQDG algorithm can not only effectively solve the new problem, but also provide technical support for multiple constraints optimization decisions of network transmission, transport and logistics, software testing and other applications.

Spanners for Directed Transmission Graphs

Let $P \subset \mathbb{R}^2$ be a planar $n$-point set such that each point $p \in P$ has an associated radius $r_p > 0$. The transmission graph $G$ for $P$ is the directed graph with vertex set $P$ such that for any $p, q \in P$, there is an edge from $p$ to $q$ if and only if $d(p, q) \leq r_p$. Let $t > 1$ be a constant. A $t$-spanner for $G$ is a subgraph $H \subseteq G$ with vertex set $P$ so that for any two vertices $p,q \in P$, we have $d_H(p, q) \leq t d_G(p, q)$, where $d_H$ and $d_G$ denote the shortest path distance in $H$ and $G$, respectively (with Euclidean edge lengths). We show how to compute a $t$-spanner for $G$ with $O(n)$ edges in $O(n (\log n + \log \Psi))$ time, where $\Psi$ is the ratio of the largest and smallest radius of a point in $P$. Using more advanced data structures, we obtain a construction that runs in $O(n \log^5 n)$ time, independent of $\Psi$. We give two applications for our spanners. First, we show how to use our spanner to find a BFS tree in $G$ from any given start vertex in $O(n \log n)$ time (in addition to the time it takes to build the spanner). Second, we show how to use our spanner to extend a reachability oracle to answer geometric reachability queries. In a geometric reachability query we ask whether a vertex $p$ in $G$ can "reach" a target $q$ which is an arbitrary point in the plane (rather than restricted to be another vertex $q$ of $G$ in a standard reachability query). Our spanner allows the reachability oracle to answer geometric reachability queries with an additive overhead of $O(\log n\log \Psi)$ to the query time and $O(n \log \Psi)$ to the space.

A Query Algorithm for Heterogeneous Information Network

With the rapid growth of the scale of the graph data, the form of its organization is more complicated. Heterogeneous information network has become an important tool for management and mining of graph data. It has been widely used in Chinese information processing, learning community mining and online shopping. The accessibility problem of heterogeneous information network is the basic problem of its research. Based on the literature [1], this paper proposes a path-based reachability query algorithm based on query preference. The algorithm establishes the path pattern index by preprocessing step, and uses the query preference to update the above indexes to achieve better processing the purpose of online inquiries. The experiment proves the effectiveness of the proposed method.

Human-Powered Data Cleaning for Probabilistic Reachability Queries on Uncertain Graphs

Uncertain graph models are widely used in real-world applications such as knowledge graphs and social networks. To capture the uncertainty, each edge in an uncertain graph is associated with an existential probability that signifies the likelihood of the existence of the edge. One notable issue of querying uncertain graphs is that the results are sometimes uninformative because of the edge uncertainty. In this paper, we consider probabilistic reachability queries, which are one of the fundamental classes of graph queries. To make the results more informative, we adopt a crowdsourcing-based approach to clean the uncertain edges. However, considering the time and monetary cost of crowdsourcing, it is a problem to efficiently select a limited set of edges for cleaning that maximizes the quality improvement. We prove that the edge selection problem is #P-hard. In light of the hardness of the problem, we propose a series of edge selection algorithms, followed by a number of optimization techniques and pruning heuristics for reducing the computation time. Our experimental results demonstrate that our proposed techniques outperform a random selection by up to 27 times in terms of the result quality improvement and the brute-force solution by up to 60 times in terms of the elapsed time.

Reachability querying: an independent permutation labeling approach

Reachability querying: an independent permutation labeling approach

Reachability Querying: Can It Be Even Faster?

As an important graph operator, reachability query has been extensively studied over decades, which is to check whether a vertex can reach another vertex over a large directed graph $G$ with $n$ vertices and $m$ edges. The efforts made in the reported studies have greatly improved the query time of answering reachability queries online, while reducing the offline index construction time to construct an index with a reasonable size given the approach taken, where an entry in an index for a vertex is called a label of the vertex. Among all the work, the recent development of IP (Independent Permutation) employs randomness using $k$ -min-wise independent permutations to process reachability queries, and shows the advantages for both query time and index construction time. In this paper, we propose a new Bloom filter Labeling, denoted as BFL. We show that the probability to answer reachability queries by BFL can be bounded, and BFL has high pruning power to answer more reachability queries directly. We give algorithms and analyze the pruning power of BFL. We conduct extensive studies using 19 large datasets. We show that BFL with an interval label performs best in the index construction time for all 19 cases, and performs best in query time for 16 out of 19 cases.

BFSI-B: An improved K-hop graph reachability queries for cyber-physical systems

Cyber-physical systems, encompass the real physical space and virtual cyber space for providing advanced service for humans, which together, are also namely Internet of Things. The complex and large scale relationships among nodes contain the potential information of user, which is required and essential for providing high quality personalized service. Graph is used to represent, make fusion and process the relationships data, which has been used in many domains with traditional small data sets. K-hop reachability query answering in graphs is seeing a growing number of applications, such as ranked keyword search in databases, social networking, ontology reasoning and bioinformatics. Currently, techniques for efficient evaluation of such queries are based on vertex-cover technology. These methods suffer from a lack of scalability; that is, they cannot be applied to very large graphs. To solve these problems, we propose the compound-index method, namely BFSI-B, which uses the special index to decrease the k-hop reachability query time and improve pruning efficiency. The theoretical analysis and experiment results demonstrate that our method has a smaller index size and a faster query time than the k-reach method, in both dense graphs and very large graphs.