GraphTwin: Cache-Centric Bit-Level Graph Representation for Fast and Exact Graph Queries

The graph model enables a broad range of analysis, thus graph processing is an invaluable tool in data analytics. At the heart of every graph-processing system lies a concurrent graph data structure storing the graph. Such a data structure needs to be highly efficient for both graph algorithms and queries. Due to the continuous evolution, the sparsity, and the scale-free nature of real-world graphs, graph-processing systems face the challenge of providing an appropriate graph data structure that enables both fast analytical workloads and low-memory graph mutations. Existing graph structures offer a hard trade-off between read-only performance, update friendliness, and memory consumption upon updates. In this paper, we introduce CSR++, a new graph data structure that removes these trade-offs and enables both fast read-only analytics and quick and memory-friendly mutations. CSR++ combines ideas from CSR, the fastest read-only data structure, and adjacency lists to achieve the best of both worlds. We compare CSR++ to CSR, adjacency lists from the Boost Graph Library, and LLAMA, a state-of-the-art update-friendly graph structure. In our evaluation, which is based on popular graph-processing algorithms executed over real-world graphs, we show that CSR++ remains close to CSR in read-only concurrent performance (within 10% on average), while significantly outperforming CSR (by an order of magnitude) and LLAMA (by almost 2×) with frequent updates.

A graph consists of a finite set of vertices and edges. Graphs are used to represent a significant number of real life applications. For example, in computer science, graphs are employed for the representation of networks of communication, organisation of data, flow of computation, computational devices, etc. Several data structures have been proposed for representing graphs among which the adjacency matrix, adjacency list and edge list are the most important and widely used ones. The choice of a graph representation is mainly situation-specific and depends on the type of operations required to be performed on a given graph as well as the ease of use. In this research, a specialised graph representation is proposed, specifically designed for use when coping with graph-based optimisation problems (e.g., graph layout problems) through heuristic search methods with the aim of speeding up the search. The results of numerical experiments show that for the purpose of this study, the proposed approach performs extremely well compared to well-known graph representation approaches.

Subgraph isomorphism counting is an important problem on graphs, as many graph-based tasks exploit recurring subgraph patterns. Classical methods usually boil down to a backtracking framework that needs to navigate a huge search space with prohibitive computational cost. Some recent studies resort to graph neural networks (GNNs) to learn a low-dimensional representation for both the query and input graphs, in order to predict the number of subgraph isomorphisms on the input graph. However, typical GNNs employ a node-centric message passing scheme that receives and aggregates messages on nodes, which is inadequate in complex structure matching for isomorphism counting. Moreover, on an input graph, the space of possible query graphs is enormous, and different parts of the input graph will be triggered to match different queries. Thus, expecting a fixed representation of the input graph to match diversely structured query graphs is unrealistic. In this paper, we propose a novel GNN called Count-GNN for subgraph isomorphism counting, to deal with the above challenges. At the edge level, given that an edge is an atomic unit of encoding graph structures, we propose an edge-centric message passing scheme, where messages on edges are propagated and aggregated based on the edge adjacency to preserve fine-grained structural information. At the graph level, we modulate the input graph representation conditioned on the query, so that the input graph can be adapted to each query individually to improve their matching. Finally, we conduct extensive experiments on a number of benchmark datasets to demonstrate the superior performance of Count-GNN.

The two-terminal shortest-path problem asks for the shortest directed path from a specified nodes to a specified noded in a complete directed graphG onn nodes, where each edge has a nonnegative length. We show that if the length of each edge is chosen independently from the exponential distribution, and adjacency lists at each node are sorted by length, then a priority-queue implementation of Dijkstra's unidirectional search algorithm has the expected running time Θ(n logn). We present a bidirectional search algorithm that has expected running time Θ(√n logn). These results are generalized to apply to a wide class of edge-length distributions, and to sparse graphs. If adjacency lists are not sorted, bidirectional search has the expected running time Θ(a√n) on graphs of average degreea, as compared with Θ(an) for unidirectional search.

In this paper, we explore the ways to represent big social graphs using adjacency lists and edge lists. Furthermore, we describe a list-based algorithm for graph folding that makes possible to analyze conditionally infinite social graphs on resource constrained mobile devices. The steps of the algorithm are (a) to partition, in a certain way, the graph into clusters of different levels, (b) to represent each cluster of the graph as an edge list, and (c) to absorb the current cluster by the cluster of the next level. The proposed algorithm is illustrated by the example of a sparse social graph.

In this paper we consider two families of competing algorithms for finding the shortest paths between all pairs of vertices (APSP) in directed weighted large graphs with different edge densities: Dijkstra and Floyd-Warshall. For comparison, we have taken Dijkstra's algorithm with dynamically varying binary heap, which solves the APSP prob-lem purely in parallel by repeatedly executing on all vertices of the graph considered as source vertices, and we have taken blocked Floyd-Warshall algorithm, which is also well-parallelizable. It is known that in terms of computational complexity, the first algorithm is preferable on sparse graphs and the second algorithm is preferable on dense graphs. At the same time, it is not clear what are the ranges of graph densities at which the first algorithm will consume less CPU time than the second algorithm. This paper describes multithreaded implementations of parallel algorithms on multicore processors that make different usage of synchronization primitives such as mutex, conditional variable, lock-ing, and atomic operation. By conducting computational experiments on an 8-core Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz, we found that each algorithm has a preferred graph density. In the case of multi-threaded parallel imple-mentation, the blocked Floyd-Warshall algorithm has lower running time than Dijkstra's algorithm if the graph densi-ty is greater than 0.5. Otherwise, Dijkstra's algorithm runs faster. In the case of single-threaded implementation, the split point is 0.43.

We describe algorithms, based on Avis and Fukuda's reverse search paradigm, for listing all maximal independent sets in a sparse graph in polynomial time and delay per output. For bounded degree graphs, our algorithms take constant time per set generated; for minor-closed graph families, the time is O ( n ) per set, and for more general sparse graph families we achieve subquadratic time per set. We also describe new data structures for maintaining a dynamic vertex set S in a sparse or minor-closed graph family, and querying the number of vertices not dominated by S ; for minor-closed graph families the time per update is constant, while it is sublinear for any sparse graph family. We can also maintain a dynamic vertex set in an arbitrary m -edge graph and test the independence of the maintained set in time O (√m) per update. We use the domination data structures as part of our enumeration algorithms.

Query planning is essential for graph query execution performance. In distributed graph processing, data partitioning and messaging significantly influence performance. However, these aspects are difficult to model analytically, which makes query planning especially challenging. This paper introduces scouting queries, a lightweight mechanism to gather runtime information about different query plans, which can then be used to choose the "best" plan. In a pipelined, depth-first-oriented graph processing engine, scouting queries typically execute for a brief amount of time with negligible overhead. Partial results can be reused to avoid redundant work. We evaluate scouting queries and show that they bring speedups of up to 8.7× for heavy queries, while adding low overhead for those queries that do not benefit.

The article is devoted to the problem of representing graphs in the form that is most suitable for their recording in relational databases and for subsequent efficient extracting and processing. The article analyzes various ways to describe graphs, such as adjacency and, incidence matrices, and adjacency lists. Each of them is reviewed from the point of view of their compliance with normal forms to assess the possibility of using a particular method when developing databases for storing graphs. It is shown that for such a task, each of these methods has a large number of disadvantages that lead to low efficiency of both data storing and processing. The article suggests the way to represent graphs in the form of a relational list of edges corresponding to the third normal form and allowing to eliminate the disadvantages of other methods.

We investigate sublinear-time algorithms that take partially erased graphs represented by adjacency lists as input. Our algorithms make degree and neighbor queries to the input graph and work with a specified fraction of adversarial erasures in adjacency entries. We focus on two computational tasks: testing if a graph is connected or ε-far from connected and estimating the average degree. For testing connectedness, we discover a threshold phenomenon: when the fraction of erasures is less than ε, this property can be tested efficiently (in time independent of the size of the graph); when the fraction of erasures is at least ε, then a number of queries linear in the size of the graph representation is required. Our erasure-resilient algorithm (for the special case with no erasures) is an improvement over the previously known algorithm for connectedness in the standard property testing model and has optimal dependence on the proximity parameter ε. For estimating the average degree, our results provide an “interpolation” between the query complexity for this computational task in the model with no erasures in two different settings: with only degree queries, investigated by Feige (SIAM J. Comput. ‘06), and with degree queries and neighbor queries, investigated by Goldreich and Ron (Random Struct. Algorithms ‘08) and Eden et al. (ICALP ‘17). We conclude with a discussion of our model and open questions raised by our work.

Static or dynamic graphs are typically visualized by either node-link diagrams, adjacency matrices, adjacency lists, orhybrids thereof. In particular, for the case of a changing graphstructure a viewer wishes to be able to visually compare thegraphs in a sequence. Doing such a comparison task rapidlyand reliably can give support to visually analyze the dynamicgraph for certain dynamic patterns. In this paper we describe a novel dynamic graph visualization that is based on the concept of smooth density fields generated by first splatting the links of a given graph in a certain layout. To further visually enhance the time-varying graph structures we add user-adaptable isolines to the resulting dynamic graph representation. The computed visual encoding of the dynamic graph is aesthetically appealing due to its smooth curves and can additionally be used to do comparisons in a long graph sequence, i.e., from an information visualization perspective it serves as an overview representation supporting to start more detailed analyses processes. To demonstrate theusefulness of the technique we explore real-world dynamic graph data by taking into account visual parameters like node-link layouts, smoothing iterations, number of isolines, and different color codings.

In this thesis we explore extremal graph theory, focusing on new methods which apply to different notions of regular graph. The first notion is dregularity, which means each vertex of a graph is contained in exactly d edges, and the second notion is Szemeredi regularity, which is a strong, approximate version of this property that relates to pseudorandomness. We begin with a novel method for optimising observables of Gibbs distributions in sparse graphs. The simplest application of the method is to the hard-core model, concerning independent sets in d-regular graphs, where we prove a tight upper bound on an observable known as the occupancy fraction. We also cover applications to matchings and colourings, in each case proving a tight bound on an observable of a Gibbs distribution and deriving an extremal result on the number of a relevant combinatorial structure in regular graphs. The results relate to a wide range of topics including statistical physics and Ramsey theory. We then turn to a form of Szemeredi regularity in sparse hypergraphs, and develop a method for embedding complexes that generalises a widely-applied method for counting in pseudorandom graphs. We prove an inheritance lemma which shows that the neighbourhood of a sparse, regular subgraph of a highly pseudorandom hypergraph typically inherits regularity in a natural way. This shows that we may embed complexes into suitable regular hypergraphs vertex-by-vertex, in much the same way as one can prove a counting lemma for regular graphs. Finally, we consider the multicolour Ramsey number of paths and even cycles. A well-known density argument shows that when the edges of a complete graph on kn vertices are coloured with k colours, one can find a monochromatic path on n vertices. We give an improvement to this bound by exploiting the structure of the densest colour, and use the regularity method to extend the result to even cycles.

We present a tool called GiS for indexing and querying a large database of labeled, undirected graphs. Such graphs can model chemical compounds, represent contact maps constructed from 3D structure of proteins, and so forth. GiS supports exact subgraph matching and approximate graph matching queries. It adopts a suite of new techniques and algorithms for (a) fast construction of disk-based indexes with small index sizes, and (b) efficient query processing with high precision of matching. During the demo, the user can index real graph datasets using a recommendation facility in GiS, pose exact subgraph matching and approximate graph matching queries, and view matching graphs using the Jmol browser.

Kneser graphs are like Swiss cheese, Discrete Analysis 2018:2, 18 pp. This paper relates two very interesting areas of research in extremal combinatorics: removal lemmas, and of variables. A _removal lemma_ is a result that states that if $S$ is a set that contains only few copies of a certain structure, then one can remove just a few elements from $S$ to create a set $S'$ that has no copies of that structure. For instance, the triangle removal states that a graph with few triangles can be approximated by a graph with no triangles. Removal lemmas play a very important role in extremal and additive combinatorics. As for the of variables, the aspect that is of interest here is that there are many interesting theorems that state that if a function has a certain property, it must be because in a certain sense it depends on only a few variables. For example, a famous result of the first author shows that if a monotone graph property fails to have a sharp threshold, then the property can be approximated by one for which the minimal graphs that satisfy it are all small, with the result that the influence of individual edges on whether the graph has the property is substantial. The main result of this paper is an removal lemma for various families of graphs. It states that if $G$ is a graph in one of these families, then for every set $X$ of vertices in $G$ that spans only a few edges one can throw away just a small proportion of $X$ to obtain a subset $X'$ that is independent. Of course, a result like this is completely false in general: one has only to take a sparse random graph, and then every subset will span few edges but no large subset will be independent. But it is true, for example, for complete bipartite graphs, since a set of vertices that spans a sparse subgraph will have to be contained almost entirely in one of the two vertex sets, and then one can throw away the vertices that are in the other set. One of the families for which the authors prove an edge-removal is that of Kneser graphs. For $0<m<n/2$, the Kneser graph $K(n,m)$ has as its vertex set the set of all subsets of $\{1,2,\dots,n\}$ of size $m$, with two such subsets joined by an edge if and only if they are disjoint. Kneser graphs have large sparse sets, but the natural examples seem to depend on just a few variables: for example, one can take all sets that contain a particular element. (Note that an independent set in $K(n,m)$ is just an intersecting family of $m$-sets.) The authors wanted to prove a precise conjecture that would say that every set of vertices that spans a sparse subgraph can be approximated by a set of vertices that (i) depends on just a few variables and (ii) spans an independent set. Before this paper a weaker statement was known where instead of (ii) one had a sparse set. In this paper the authors settle the conjecture completely by showing that a sparse set of vertices can be approximated by an independent set of vertices. The other family of graphs for which the authors prove an edge removal is that of product graphs. If $H$ is a graph, then the product $G=H^n$ is the graph where $x$ and $y$ are joined if for every coordinate $i$ we have that $x_iy_i$ is an edge of $H$. (There are different definitions of product graphs, but this is the one to which the result applies: note that it makes it quite hard for two vertices to be joined.) For example, if $H$ is a complete graph on $r$ coordinates, then $G=[r]^n$ with two vertices joined if and only if they differ in every coordinate. The proof of the removal uses ideas from Jacob Fox's proof of the triangle removal lemma, which obtains the best known bound for that result. Finally, what has this to do with Swiss cheese? The rough idea is that these graphs have large and highly structured independent sets, and a part of the graph is sparse if and only if it has a big intersection with one of these independent sets. Likewise a Swiss cheese contains lots of large holes, and a region of space contained within the boundary of the cheese will contain only a small amount of cheese if and only if it is almost entirely contained in one of the holes. Article image [by G. J. Wanderer](https://www.flickr.com/photos/106561245@N07/13515457313/in/photolist-mAjfA6-f7mF8i-Tf5Ler-7i4FtY-bi74Nt-gWVXdj-7XoC4N-okRvp5-77HxiZ-7xt4hx-RSUt3B-qeB17D-as2aAc-7K64uq-oL2GMj-6trVsK-UDq452-SP1xSX-d4u57o-fATSUi-8Km2Qs-dJeLzb-qu9Z4Z-dNNvQ2-7eVY4b-6mtCks-frWJEF-aCerNx-7tyjAW-haiMTG-oysrog-9LJVj8-fzno-4VuER1-b5n85M-Jka6K5-a7vHJZ-5S7Yyt-Uwa6kC-dNU7Mm-5AWGod-YSE7a-bzagV7-8tV58z-8YW1XL-5nvECU-QAdC69-8wG84t-TSsHP4-9eoj6S) and distributed under a [CC-BY-NC-SA licence](https://creativecommons.org/licenses/by-nc-sa/2.0/).

The existing single depth image super-resolution (SR) methods suppose that the image to be interpolated is noise free. However, the supposition is invalid in practice because noise will be inevitably introduced in the depth image acquisition process. In this paper, we address the problem of image denoising and SR jointly based on designing sparse graphs that are useful for describing the geometric structures of data domains. In our method, we first cluster similar patches in a noisy depth image and compute an average patch. Different from the majority of the graph Fourier transform (GFT) that assumed an underlying 4-connected graph structure with vertical and horizontal edges only, we select more general sparse graph structures and edges weights based on the difference of the blocks' structure tensors. For the average patch, a graph template with edges orthogonal to the principal gradient is designed. Finally, the graph based transform (GBT) dictionary is learned from the derived correlation graph for signal representation. As shown in our experimental results, the proposed method obtains a lot of improvement in performance.