Search

Background Ongoing improvements in throughput of the next-generation sequencing technologies challenge the current generation of de novo sequence assemblers. Most recent sequence assemblers are based on the construction of a de Bruijn graph. An alternative framework of growing interest is the assembly string graph, not necessitating a division of the reads into k-mers, but requiring fast algorithms for the computation of suffix-prefix matches among all pairs of reads. Results Here we present efficient methods for the construction of a string graph from a set of sequencing reads. Our approach employs suffix sorting and scanning methods to compute suffix-prefix matches. Transitive edges are recognized and eliminated early in the process and the graph is efficiently constructed including irreducible edges only. Conclusions Our suffix-prefix match determination and string graph construction algorithms have been implemented in the software package Readjoiner. Comparison with existing string graph-based assemblers shows that Readjoiner is faster and more space efficient. Readjoiner is available at http://www.zbh.uni-hamburg.de/readjoiner.

Semi-supervised learning is a machine learning framework where learning from data is conducted by utilizing a small amount of labeled data as well as a large amount of unlabeled data (Chapelle et al., 2006). It has been intensively studied in data mining and machine learning communities recently. One of the reasons is that, it can alleviate the time-consuming effort to collect “ground truth” labeled data while sustaining relatively high performance by exploiting a large amount of unlabeled data. (Blum & Mitchell, 1998) showed the PAC learnability of semi-supervised learning, especially in classification problem.

A well-known connection between n strings winding around a circle and permutations of n objects plays a fundamental role in the string theory of large N two dimensional Yang Mills theory and elsewhere in topological and physical string theories. Basic questions in the enumeration of Feynman graphs can be expressed elegantly in terms of permutation groups. We show that these permutation techniques for Feynman graph enumeration, along with the Burnside counting lemma, lead to equalities between counting problems of Feynman graphs in scalar field theories and Quantum Electrodynamics with the counting of amplitudes in a string theory with torus or cylinder target space. This string theory arises in the large N expansion of two dimensional Yang Mills and is closely related to lattice gauge theory with S_n gauge group. We collect and extend results on generating functions for Feynman graph counting, which connect directly with the string picture. We propose that the connection between string combinatorics and permutations has implications for QFT-string dualities, beyond the framework of large N gauge theory., Comment: 55 pages + 10 pages Appendices, 23 figures ; version 2 - typos corrected

String diagrams are a powerful tool for reasoning about physical processes, logic circuits, tensor networks, and many other compositional structures. Dixon, Duncan and Kissinger introduced string graphs, which are a combinatoric representations of string diagrams, amenable to automated reasoning about diagrammatic theories via graph rewrite systems. In this extended abstract, we show how the power of such rewrite systems can be greatly extended by introducing pattern graphs, which provide a means of expressing infinite families of rewrite rules where certain marked subgraphs, called !-boxes ("bang boxes"), on both sides of a rule can be copied any number of times or removed. After reviewing the string graph formalism, we show how string graphs can be extended to pattern graphs and how pattern graphs and pattern rewrite rules can be instantiated to concrete string graphs and rewrite rules. We then provide examples demonstrating the expressive power of pattern graphs and how they can be applied to study interacting algebraic structures that are central to categorical quantum mechanics., Comment: In Proceedings DCM 2012, arXiv:1403.7579

In this paper, we visit the problem of approximate string matching allowing for translocations. We study the graph theoretic model proposed by [5] and extending the model, devise an efficient algorithm to solve the approximate string matching allowing for translocations. The resulting algorithm is an adaptation of the classic shift-and algorithm. For patterns having length similar to the word-size of the target machine, the algorithm runs in O(n + mk 2) time for fixed length translocation where n, m and k are the length of the text, pattern and the translocation respectively.

LetHbe a graph onnvertices and let the blow-up graphG[H] be defined as follows. We replace each vertexviofHby a clusterAiand connect some pairs of vertices ofAiandAjif (vi,vj) is an edge of the graphH. As usual, we define the edge density betweenAiandAjasWe study the following problem. Given densities γijfor each edge (i,j) ∈E(H), one has to decide whether there exists a blow-up graphG[H], with edge densities at least γij, such that one cannot choose a vertex from each cluster, so that the obtained graph is isomorphic toH,i.e., noHappears as a transversal inG[H]. We calldcrit(H) the maximal value for which there exists a blow-up graphG[H] with edge densitiesd(Ai,Aj)=dcrit(H) ((vi,vj) ∈E(H)) not containingHin the above sense. Our main goal is to determine the critical edge density and to characterize the extremal graphs.First, in the case of treeTwe give an efficient algorithm to decide whether a given set of edge densities ensures the existence of a transversalTin the blow-up graph. Then we give general bounds ondcrit(H) in terms of the maximal degree. In connection with the extremal structure, the so-called star decomposition is proved to give the best construction forH-transversal-free blow-up graphs for several graph classes. Our approach applies algebraic graph-theoretical, combinatorial and probabilistic tools.

Let A={C1, C2,…, Cn} be an arrangement of Jordan curves in the plane lying in general position, i.e., every properly intersects at least one other curve, no two curves touch each other and no three meet at a common intersection point. The Jordan-curve arrangement graph of A has as its vertices the intersection points of the curves in A, and two vertices are connected by an edge if their corresponding intersection points are adjacent on some curve in A. We further assume A is such that the resulting graph has no multiple edges. Under these conditions it is shown that determining whether Jordan-curve arrangement graphs are Hamiltonian is NP-complete.

The n-star graph, denoted by S/sub n/, is one of the graph networks that have been recently proposed as attractive alternatives to the n-cube topology for interconnecting processors in parallel computers. We present a parallel algorithm for the computation of the Fourier transform on the star graph. The algorithm requires O(n/sup 2/) multiply-add steps for an input sequence of n! elements, and is hence cost-optimal with respect to the sequential algorithm on which it is based. This is believed to be the first algorithm, and the only one to date, for the computation of the Fourier transform on the star graph. >

Given a real world graph, how should we lay-out its edges? How can we compress it? These questions are closely related, and the typical approach so far is to find clique-like communities, like the `cavemen graph', and compress them. We show that the block-diagonal mental image of the `cavemen graph' is the wrong paradigm, in full agreement with earlier results that real world graphs have no good cuts. Instead, we propose to envision graphs as a collection of hubs connecting spokes, with super-hubs connecting the hubs, and so on, recursively. Based on the idea, we propose the Slash Burn method (burn the hubs, and slash the remaining graph into smaller connected components). Our view point has several advantages: (a) it avoids the `no good cuts' problem, (b) it gives better compression, and (c) it leads to faster execution times for matrix-vector operations, which are the back-bone of most graph processing tools. Experimental results show that our Slash Burn method consistently outperforms other methods on all datasets, giving good compression and faster running time.

International audience; Next-generation de novo short reads assemblers typically use the following strategy: (1) assemble unpaired reads using heuristics leading to contigs; (2) order contigs from paired reads information to produce scaffolds. We propose to unify these two steps by introducing localized assembly: direct construction of scaffolds from reads. To this end, the paired string graph structure is introduced, along with a formal framework for building scaffolds as paths of reads. This framework leads to the design of a novel greedy algorithm for memory-efficient, parallel assembly of paired reads. A prototype implementation of the algorithm has been developed and applied to the assembly of simulated and experimental short reads. Our experiments show that our methods yields longer scaffolds than recent assemblers, and is capable of assembling diploid genomes significantly better than other greedy methods.

Relaxation is applied to the segmentation of closed boundary curves of shapes. The ambiguous segmentation of the boundary is represented by a directed graph structure whose nodes represent segments, where two nodes are joined by an arc if the segments are consecutive along the boundary. A probability vector is associated with each node; each component of this vector provides an estimate of the probability that the corresponding segment is a particular part of the object. Relaxation is used to eliminate impossible sequences of parts, or reduce the probabilities of unlikely ones. In experiments involving airplane shapes, this almost always results in a drastic simplification of the graph with only good interpretations surviving. The approach is also extended to include curve linking and gap filling. A chain coded input image is broken into segments based on a measure of local curvature. Gap completions linking pairs of segments are then proposed and represented in a graph structure. A second graph, whose nodes consist of paths in the above graph, is constructed, and the nodes of the second graph are probabilistically classified as various object parts. Relaxation is then applied to increase the probability of mutually supporting classifications, and decrease the probability of unsupported decisions. A modified relaxation process using information about the size, spatial position, and orientation of the object parts yielded a high degree of disambiguation.

This paper addresses the problem of sparse recovery with graph constraints in the sense that we can take additive measurements over nodes only if they induce a connected subgraph. We provide explicit measurement constructions for several special graphs. A general measurement construction algorithm is also proposed and evaluated. For any given graph $G$ with $n$ nodes, we derive order optimal upper bounds of the minimum number of measurements needed to recover any $k$-sparse vector over $G$ ($M^G_{k,n}$). Our study suggests that $M^G_{k,n}$ may serve as a graph connectivity metric.

Motivation: Exact-match overlap graphs have been broadly used in the context of DNA assembly and the shortest super string problem where the number of strings n ranges from thousands to billions. The length ℓ of the strings is from 25 to 1000, depending on the DNA sequencing technologies. However, many DNA assemblers using overlap graphs suffer from the need for too much time and space in constructing the graphs. It is nearly impossible for these DNA assemblers to handle the huge amount of data produced by the next-generation sequencing technologies where the number n of strings could be several billions. If the overlap graph is explicitly stored, it would require Ω(n 2) memory, which could be prohibitive in practice when n is greater than a hundred million. In this article, we propose a novel data structure using which the overlap graph can be compactly stored. This data structure requires only linear time to construct and and linear memory to store. Results: For a given set of input strings (also called reads), we can informally define an exact-match overlap graph as follows. Each read is represented as a node in the graph and there is an edge between two nodes if the corresponding reads overlap sufficiently. A formal description follows. The maximal exact-match overlap of two strings x and y, denoted by ov max(x, y), is the longest string which is a suffix of x and a prefix of y. The exact-match overlap graph of n given strings of length ℓ is an edge-weighted graph in which each vertex is associated with a string and there is an edge (x, y) of weight ω=ℓ−|ov max(x, y)| if and only if ω≤λ, where |ov max(x, y)| is the length of ov max(x, y) and λ is a given threshold. In this article, we show that the exact-match overlap graphs can be represented by a compact data structure that can be stored using at most (2λ−1)(2⌈logn⌉+⌈logλ⌉)n bits with a guarantee that the basic operation of accessing an edge takes O(log λ) time. We also propose two algorithms for constructing the data structure for the exact-match overlap graph. The first algorithm runs in O(λℓnlogn) worse-case time and requires O(λ) extra memory. The second one runs in O(λℓn) time and requires O(n) extra memory. Our experimental results on a huge amount of simulated data from sequence assembly show that the data structure can be constructed efficiently in time and memory. Availability: Our DNA sequence assembler that incorporates the data structure is freely available on the web at http://www.engr.uconn.edu/~htd06001/assembler/leap.zip Contact: hdinh@engr.uconn.edu; rajasek@engr.uconn.edu

Many spectral algorithms that are routinely applied to spectral imagery are based on the following models: statistical, linear mixture, and linear subspace. As a result, assumptions are made about the underlying distribution of the data such as multivariate normality or other geometric restrictions. Here we present a graph based model for spectral data that avoids these restrictive assumptions and apply graph based metrics to quantify certain aspects of the resulting graph. The construction of the spectral graph begins by connecting each pixel to its k-nearest neighbors with an undirected weighted edge. The weight of each edge corresponds to the spectral Euclidean distance between the adjacent pixels. The number of nearest neighbors, k, is chosen such that the graph is connected i.e., there is a path from each pixel x i to every other. This requirement ensures the existence of inter-cluster connections which will prove vital for our application to change detection. Once the graph is constructed, we calculate a metric called the Normalized Edge Volume (NEV) that describes the internal structural volume based on the vertex connectivity and weighted edges of the graph. Finally, we demonstrate a graph based change detection method that applies this metric.

We present a novel approach to graph partitioning based on the notion of \emph{natural cuts}. Our algorithm, called PUNCH, has two phases. The first phase performs a series of minimum-cut computations to identify and contract dense regions of the graph. This reduces the graph size, but preserves its general structure. The second phase uses a combination of greedy and local search heuristics to assemble the final partition. The algorithm performs especially well on road networks, which have an abundance of natural cuts (such as bridges, mountain passes, and ferries). In a few minutes, it obtains the best known partitions for continental-sized networks, significantly improving on previous results.

Since hand vein patterns are assumed not to change over time except in size and they are unique to each individual, researchers aim to construct a biometric control system based on hand vein patterns. Each hand vein pattern defines a graph structure. According to this, we converted each hand vein pattern to a graph and to match these graphs, we developed an algorithm based on (Graph Edit Distance) GED. GED is defined as the least cost graph edit operation sequence which is used to transform one graph to another. Our initial results confirm the utility of GED-based hand vein verification.

We formalize a problem of closed and maximal pattern discovery in internally and externally weighted graph databases. We introduce two weights, internal weights and external weights, which represent utility and significance of each edge in the graph, and importance and reliability of the graph itself, respectively. In our formulation, graphs with the two sets of weights describe the target data to be mined precisely. As an extension of traditional sub graph miners, we develop a mining algorithm called "wgMiner" for discovering all closed and maximal patterns in the weighted graph databases. With wgMiner, experiments demonstrate the effectiveness of our formulation in pattern mining from communication networks.

In many applications, for example, in data integration scenarios, strings must be matched if they are similar. String similarity joins, which match all pairs of similar strings from two datasets, are of particular interest and have recently received much attention in the database research community. Most approaches, however, assume a global similarity threshold; all string pairs that exceed the threshold form a match in the join result. The global threshold approach has two major problems: (a) the threshold depends on the (mostly unknown) data distribution, (b) often there is no single threshold that is good for all string pairs. In this paper we propose the PG-Join algorithm, a novel string similarity join that requires no configuration and uses an adaptive threshold. PG-Join computes a so-called proximity graph to derive an individual threshold for each string. Computing the proximity graph efficiently is essential for the scalability of PG-Join. To this end we develop a new and fast algorithm, PG-I, that computes the proximity graph in two steps: First an efficient approximation is computed, then the approximation error is fixed incrementally until the adaptive threshold is stable. Our extensive experiments on real-world and synthetic data show that PGI is up to five times faster than the state-of-the-art algorithm and suggest that PG-Join is a useful and effective join paradigm.

This paper introduces a skeletal representation, called Point Cloud Graph, that generalizes the definition of the Reeb graph to arbitrary point clouds sampled from m-dimensional manifolds embedded in the d-dimensional space. The proposed algorithm is easy to implement and the graph representation yields to an effective abstraction of the data. Finally, we present experimental results on point-sampled surfaces and volumetric data that show the robustness of the Point Cloud Graph to non-uniform point distributions and its usefulness for shape comparison.

In this paper we prove that for a simple graph G without isolated vertices 0 < λ2(G) < 1/3 if and only if G ≅ Kn-3 V (K1 ∪ K2), the graph obtained by joining each vertex of Kn-3 to each vertex of K1 ∪ K2). © 1993 John Wiley & Sons, Inc.

International audience; We prove that every planar graph is an intersection graph of strings in the plane such that any two strings intersect at most once.

Sequence assembly from short reads is an important problem in biology. It is known that solving the sequence assembly problem exactly on a bi-directed de Bruijn graph or a string graph is intractable. However, finding a shortest double stranded DNA string (SDDNA) containing all the k-long words in the reads seems to be a good heuristic to get close to the original genome. This problem is equivalent to finding a cyclic Chinese Postman (CP) walk on the underlying unweighted bi-directed de Bruijn graph built from the reads. The Chinese Postman walk Problem (CPP) is solved by reducing it to a general bi-directed flow on this graph which runs in O(|E|2 log 2(|V|)) time. In this paper we show that the cyclic CPP on bi-directed graphs can be solved without reducing it to bi-directed flow. We present a Θ(p(|V| + |E|) log (|V|) + (d max p)3) time algorithm to solve the cyclic CPP on a weighted bi-directed de Bruijn graph, where p = max {|{v|d in (v) - d out (v) > 0}|, |{v|d in (v) - d out (v) < 0}|} and d max = max {|d in (v) - d out (v)}. Our algorithm performs asymptotically better than the bi-directed flow algorithm when the number of imbalanced nodes p is much less than the nodes in the bi-directed graph. From our experimental results on various datasets, we have noticed that the value of p/|V| lies between 0.08% and 0.13% with 95% probability. Many practical bi-directed de Bruijn graphs do not have cyclic CP walks. In such cases it is not clear how the bi-directed flow can be useful in identifying contigs. Our algorithm can handle such situations and identify maximal bi-directed sub-graphs that have CP walks. A Θ(p(|V| + |E|)) time heuristic algorithm based on these ideas has been implemented for the SDDNA problem. This algorithm was tested on short reads from a plant genome and achieves an approximation ratio of at most 1.0134. We also present a Θ((|V| + |E|) log (V)) time algorithm for the single source shortest path problem on bi-directed de Bruijn graphs, which may be of independent interest.

The de Bruijn graph assembly approach breaks reads into k-mers before assembling them into contigs The string graph approach forms contigs by connecting two reads with k or more overlapping nucleotides Both approaches must deal with the following problems: false-positive vertices, due to erroneous reads; gap problem, due to non-uniform coverage; branching problem, due to erroneous reads and repeat regions A proper choice of k is crucial but for single k there is always a trade-off: a small k favors the situation of erroneous reads and non-uniform coverage, and a large k favors short repeat regions. We propose an iterative de Bruijn graph approach iterating from small to large k exploring the advantages of the in between values Our IDBA outperforms the existing algorithms by constructing longer contigs with similar accuracy and using less memory, both with real and simulated data The running time of the algorithm is comparable to existing algorithms. Availability: IDBA is available at http://www.cs.hku.hk/~alse/idba/

We study strategies that minimize the instability of a fault-tolerant consensus system. More precisely, we find the strategy than minimizes the number of output changes over a random walk sequence of input vectors (where each component of the vector corresponds to a particular sensor reading). We analyze the case where each sensor can read three possible inputs. The proof of this result appears to be much more complex than the proof of the binary case (previous work). In the binary case the problem can be reduced to a minimal cut in a graph. We succeed in three dimensions by using the fact that an auxiliary graph (projected graph) is planar. For four and higher dimensions this auxiliary graph is not planar anymore and the problem remains open.

In a variety of emerging applications one needs to decide whether a graph G matches another G p , i.e. , whether G has a topological structure similar to that of G p . The traditional notions of graph homomorphism and isomorphism often fall short of capturing the structural similarity in these applications. This paper studies revisions of these notions, providing a full treatment from complexity to algorithms. (1) We propose p-homomorphism (p -hom) and 1-1 p -hom, which extend graph homomorphism and subgraph isomorphism, respectively, by mapping edges from one graph to paths in another, and by measuring the similarity of nodes . (2) We introduce metrics to measure graph similarity, and several optimization problems for p -hom and 1-1 p -hom. (3) We show that the decision problems for p -hom and 1-1 p -hom are NP-complete even for DAGs, and that the optimization problems are approximation-hard. (4) Nevertheless, we provide approximation algorithms with provable guarantees on match quality. We experimentally verify the effectiveness of the revised notions and the efficiency of our algorithms in Web site matching, using real-life and synthetic data.

The advent of high-throughput short read technology is revolutionizing life sciences by providing an inexpensive way to sequence genomes at high coverage. Exploiting this technology requires the development of a de novo short read assembler, which is an important open problem that is garnering significant research effort. Current methods are largely limited to microbial organisms, whose genomes are two to three orders of magnitude smaller than complex mammalian and plant genomes. In this paper, we present the design and development of a parallel de novo short read assembler that can scale to large genomes with high coverage. Our approach is based on the string graph formulation. Input reads are mapped to short paths, and the genome is reconstructed as a superpath anchored by distance constraints inferred from read pairs. Our method can handle a mixture of multiple read sizes and multiple paired read distances. We present parallel algorithms for string graph construction, string graph compaction, graph based error detection and removal, and computing aggregate summarization of paired read links across graph edges. Using this, we navigate the final graph structure to reproduce large contiguous sequences from the underlying genome. We present a validation of our framework on experimental and simulated data from multiple known genomes and present scaling results on IBM Blue Gene/L.

A graph G is called pancyclic if it contains a cycle of length I for each integer I from 3 to |V(G)| inclusive, where |V(G)| denotes the cardinality of the vertex set of graph G. It has been shown by Ma et al. (2007) that the augmented cube, proposed by Choudum and Sunitha (2002), is pancyclic. In this paper, we propose a more refined property, namely double-pancyclicity. Let G be a pancyclic graph with N vertices, and (u1, v1), (u2, v2) be any two vertex-disjoint edges in G. Moreover, let l1 and l2 be any two integers of {3, 4,. .., N - 3} such that l1 + l2  N. Then G is said to be double-pancyclic if it has two vertex-disjoint cycles, C1 and C2, such that |V(Ci)| = li and (ui, vi) ∈ E(Ci) for i = 1,2. Moreover, we show that the class of augmented cubes can be almost double-pancyclic.

String graphs are intersection graphs of continuous simple arcs (”strings”) in the plane. They may have a complicated structure, they have no good characterization, the recognition of string graphs is an NP-complete problem. Yet these graphs show remarkably beautiful properties from the point of view of extremal graph theory. What is the explanation for this phenomenon? We do not really know, so we offer three answers. (1) Being a string graph is a hereditary property. (2) String graphs are nicely separable into smaller pieces. (3) As in any geometric picture, one can discover several natural partial orders on a collection of strings.

Given a collection C of curves in the plane, its string graph is defined as the graph with vertex set C, in which two curves in C are adjacent if and only if they intersect. Given a partially ordered set (P,0 there exists δ>0 with the property that if C is a collection of curves whose string graph has at least ε|C|[superscript 2] edges, then one can select a subcurve γ′ of each γ∈C such that the string graph of the collection {γ′:γ∈C} has at least δ|C|[superscript 2] edges and is an incomparability graph. We also discuss applications of this result to extremal problems for string graphs and edge intersection patterns in topological graphs., National Science Foundation (U.S.). Graduate Research Fellowship, Princeton University (Centennial Fellowship), Simons Foundation, National Science Foundation (U.S.) (Grant DMS-1069197)

International audience; Given a set S of segments in the plane, the intersection graph of S is the graph with vertex set S in which two vertices are adjacent if and only if the corresponding two segments intersect. We prove a conjecture of Scheinerman (PhD Thesis, Princeton\nUniversity, 1984) that every planar graph is the intersection graph of some segments in the plane.

We show that every graph can be subdivided in a way that the resulting graph can be colored without repetitions on paths using only 3 colors. This extends the result of Thue asserting the existence of arbitrarily long nonrepetitive strings over a 3-letter alphabet.

International audience; The medial axis being an homotopic transformation, the skeleton of a 2D shape corresponds to a planar graph having one face for each hole of the shape and o ne node for each junction or extremity of the branches. This graph is non simple since it can be composed of loops and multiple-edges. Within the shape comparison framework, s uch a graph is usually transformed into a simpler structure such as a tree or a simp le graph hereby loosing major information about the shape. In this paper, we propose a graph kernel combining a kernel between bags of trails and a kernel between faces. T he trails are defined within the original complex graph and the kernel between trails is enforced by an edition process. The kernel between bags of faces allows to put an empha sis on the holes of the shapes and hence on their genre. The resulting graph kernel is po sitive semi-definite on the graph domain.

This paper presents a Web graph representation based on a compact tree structure that takes advantage of large empty areas of the adjacency matrix of the graph. Our results show that our method is competitive with the best alternatives in the literature, offering a very good compression ratio (3.3---5.3 bits per link) while permitting fast navigation on the graph to obtain direct as well as reverse neighbors (2---15 microseconds per neighbor delivered). Moreover, it allows for extended functionality not usually considered in compressed graph representations.

The problems that are related to string inclusion and non-inclusion have been vigorously studied in such diverse fields as data compression, molecular biology, and computer security. Given a finite set of negative strings ? and a finite set of positive strings ?, a string ? is a consistent superstring if every positive string is a substring of ? and no negative string is a substring of ?. The shortest (resp. longest) consistent superstring problem is finding a string ? that is the shortest (resp. longest) among all the consistent superstrings for the given sets of strings. In this paper, we first propose a new graph model based on the Aho-Corasick algorithm to represent the consistent superstrings for the given sets. Then, we propose improved algorithms for the problems of the shortest consistent superstring and the longest consistent superstring using the graph model.

We are interested in the problem of discovering the set of object classes present in a database of images using a weakly supervised graph-based framework. Rather than making use of the "Bag-of-Features (BoF)" approach widely used in current work on object recognition, we represent each image by a graph using a group of selected local invariant features. Using local feature matching and iterative Procrustes alignment, we perform graph matching and compute a similarity measure. Borrowing the idea of query expansion , we develop a similarity propagation based graph clustering (SPGC) method. Using this method class specific clusters of the graphs can be obtained. Such a cluster can be generally represented by using a higher level graph model whose vertices are the clustered graphs, and the edge weights are determined by the pairwise similarity measure. Experiments are performed on a dataset, in which the number of images increases from 1 to 50K and the number of objects increases from 1 to over 500. Some objects have been discovered with total recall and a precision 1 in a single cluster.

The interval graph for a set of intervals on a line consists of one vertex for each interval, and an edge for each intersecting pair of intervals. A probe interval graph is a variant that is motivated by an application to genomics, where the intervals are partitioned into two sets: probes and non-probes. The graph has an edge between two vertices if they intersect and at least one of them is a probe. We give a linear-time algorithm for determining whether a given graph and partition of vertices into probes and non-probes is a probe interval graph. If it is, we give a layout of intervals that proves that it is. In contrast to previous algorithms for the problem, our algorithm can determine whether the layout is uniquely constrained. As part of the algorithm we solve the consecutive-ones probe matrix problem.

The de novo assembly of genomes from high-throughput short reads is an active area of research. Several promising methods have been recently developed, with applicability largely restricted to the smaller and less complex bacterial genomes. In this paper, we present a method for assembling large genomes from high-coverage paired short reads. Our method exploits large distributed memory and parallelism available on multiprocessor systems to handle memory-intensive phases of the algorithm, effectively allowing scaling to large genomes. We present parallel algorithms to construct a bidirected string graph that is several orders of magnitude smaller than the raw sequence data and to extract features from paired reads. We also present a heuristic method that uses these features to guide the extension of partial graph traversals corresponding to large genomic contigs. In addition, we propose a simple model for error correction and derive a lower bound on the coverage needed for its use. We present a validation of our framework with short reads from D. melanogaster and S. cervisiae synthetically generated at 300-fold coverage. Assembly of the D. melanogaster genome resulted in large contigs (50% of the genome covered by contigs larger than 102Kb), accurate to 99.9% of the bases, in under 4 hours of wall clock time on a 512-node Blue Gene/L.

The Reeb graph represents the topological skeleton of a 3-D object and shows between which contours the surface patches should be generated. To construct the graph automatically, a weight function is defined for a pair of contours with each contour lying on the adjacent cross sections. First, the algorithm automatically generates the major parts of the edges of the Reeb graph where the number of contours does not change. Then the rest of the graph is determined by using the weight function and prior knowledge of the number of holes the object has. Specifically, the graph is completed by adding edges that do not contradict the known number of holes in descending order of the weight. >

We provide a construction of a graph on O ( n ) vertices which can be represented as the intersection graph of a system of curves in the plane, but every such representation contains at least 2 n intersecting points of the curves.

An axis-parallel box in b-dimensional space is a Cartesian product R1×R2×...×Rb where Ri (for 1⩽i⩽b) is a closed interval of the form [ai, bi] on the real line. For a graph G, its boxicity is the minimum dimension b, such that G is representable as the intersection graph of (axis-parallel) boxes in b-dimensional space. The concept of boxicity finds application in various areas of research like ecology, operation research etc. Chandran, Francis and Sivadasan gave an O(Δn2ln2n) randomized algorithm to construct a box representation for any graph G on n vertices in [(Δ+2)lnn] dimensions, where ? is the maximum degree of the graph. They also came up with a deterministic algorithm that runs in O(n4Δ) time. Here, we present an O(n2Δ2lnn) deterministic algorithm that constructs the box representation for any graph in [(Δ+2)lnn] dimensions.

A finite automaton, simply referred to as a robot , has to explore a graph, that is, visit all the nodes of the graph. The robot has no a priori knowledge of the topology of the graph, nor of its size. It is known that for any k -state robot, there exists a graph of maximum degree 3 that the robot cannot explore. This article considers the effects of allowing the system designer to add short labels to the graph nodes in a preprocessing stage, for helping the exploration by the robot. We describe an exploration algorithm that, given appropriate 2-bit labels (in fact, only 3-valued labels), allows a robot to explore all graphs. Furthermore, we describe a suitable labeling algorithm for generating the required labels in linear time. We also show how to modify our labeling scheme so that a robot can explore all graphs of bounded degree, given appropriate 1-bit labels. In other words, although there is no robot able to explore all graphs of maximum degree 3, there is a robot R, and a way to color in black or white the nodes of any bounded-degree graph G , so that R can explore the colored graph G . Finally, we give impossibility results regarding graph exploration by a robot with no internal memory (i.e., a single-state automaton).

We propose a highly compact two-part representation of a given graph G consisting of a graph summary and a set of corrections. The graph summary is an aggregate graph in which each node corresponds to a set of nodes in G, and each edge represents the edges between all pair of nodes in the two sets. On the other hand, the corrections portion specifies the list of edge-corrections that should be applied to the summary to recreate G. Our representations allow for both lossless and lossy graph compression with bounds on the introduced error. Further, in combination with the MDL principle, they yield highly intuitive coarse-level summaries of the input graph G. We develop algorithms to construct highly compressed graph representations with small sizes and guaranteed accuracy, and validate our approach through an extensive set of experiments with multiple real-life graph data sets.To the best of our knowledge, this is the first work to compute graph summaries using the MDL principle, and use the summaries (along with corrections) to compress graphs with bounded error.

Methods employed for extracting parallel grains from a given sparse graph are varied and heuristic in nature, since it is NP-Hard to find the maximally balanced connected partition for a general graph [1]. In many cases, e.g. the GR -"Greedy Algorithm" [2], PI - "Principal Inertia" algorithms [3], RGB - "Recursive Graph Bisection" [4], 1DTF - The "ID Topology Frontal"; algorithm [5] and RSB - "Recursive Spectral Bisection" [6,7], systems are decomposed based upon the number of available processors without regard to the graph topology, which leads to inefficient data structuring (i.e. redundant storage, high communication costs and indiscriminate load balancing). An efficient methodology for regrouping and mapping a given decomposition is developed in this work. It is based on the "elimination-tree," or e-tree, data structure of [8]. The e-tree is a spanning tree for the given graph, and is utilized as a data structure to guide parallel processing. The mapping function assigns a "label," gamma, to each vertex: V rarr {1,2,...,n}. "Label classes" are defined as an ordered set, or list, of labels and contain vertices which can be processed in parallel after the vertices of all previously defined classes have been processed. A symbolic factorization technique is used to create these label classes, or sub-graphs, from G(A).

International audience; Motivated by the fact that neighbors are generally known in practical routing algorithms, we introduce the notion of remote-spanner. Given an unweighted graph $G$, a sub-graph $H$ with vertex set $V(H)=V(G)$ is an \emph{$(\a,\b)$-remote-spanner} if for each pair of points $u$ and $v$ the distance between $u$ and $v$ in $H_u$, the graph $H$ augmented by all the edges between $u$ and its neighbors in $G$, is at most $\a$ times the distance between $u$ and $v$ in $G$ plus $\b$. We extend this definition to $k$-connected graphs by considering minimum length sum over $k$ disjoint paths as distance. We then say that an $(\a,\b)$-remote-spanner is \emph{$k$-connecting }. In this paper, we give distributed algorithms for computing $(1+\eps,1-2\eps)$-remote-spanners for any $\eps>0$, $k$-connecting $(1,0)$-remote-spanners for any $k\ge 1$ (yielding $(1,0)$-remote-spanners for $k=1$) and $2$-connecting $(2,-1)$-remote-spanners. All these algorithms run in constant time for any unweighted input graph. The number of edges obtained for $k$-connecting $(1,0)$-remote-spanner is within a logarithmic factor from optimal (compared to the best $k$-connecting $(1,0)$-remote-spanner of the input graph). Interestingly, sparse $(1,0)$-remote-spanners (i.e. preserving exact distances) with $O(n^4/3)$ edges exist in random unit disk graphs. The number of edges obtained for $(1+\eps,1-2\eps)$-remote-spanners and $2$-connecting $(2,-1)$-remote-spanners is linear if the input graph is the unit ball graph of a doubling metric (distances between nodes are unknown). Our methodology consists in characterizing remote-spanners as sub-graphs containing the union of small depth tree sub-graphs dominating nearby nodes. This leads to simple local distributed algorithms.

This article is part of a project consisting in expressing, whenever possible, graph properties and graph transformations in monadic second-order logic or in its extensions using modulo p cardinality set predicates or auxiliary linear orders. A circle graph is the intersection graph of a set of chords of a circle. Such a set is called a chord diagram. It can also be described by a word with two occurrences of each letter, called a double occurrence word. If a circle graph is prime for the split (or join) decomposition defined by Cunnigham, it has a unique representation by a chord diagram, and this diagram can be defined by monadic second-order formulas with the even cardinality set predicate. By using the (canonical) split decomposition of a circle graph, we define in monadic second-order logic with auxiliary linear orders all its chord diagrams. This construction uses the fact that the canonical split decomposition of a graph can be constructed in monadic second-order logic with help of an arbitrary linear order. We prove that the order of first occurrences of the letters in a double occurrence word w that represents a connected circle graph determines this word in a unique way. The word w can be defined by a monadic second-order formula from the word of first occurrences of letters. We also prove that a set of circle graphs has bounded clique-width if and only if all the associated chord diagrams have bounded tree-width.

In this paper we propose a spectral-graph-partitioning-based algorithm to decompose an object-oriented system into components. We begin with a weighted class dependence graph, in which vertexes stand for the classes and edges stand for the weight of the relationship between classes. We employ a technology from algebraic graph theory known as Laplace spectral graph partitioning to divide the class graph into components. The decomposition algorithm can be performed automatically and achieve a good performance.

Let F = {I1, I2,…,In} be a finite family of closed intervals on the real line. Two intervals Ij and Ik in F are said to overlap each other if they intersect but neither one of them contains the other. A graph G = (V, E) is called an overlap graph for F if there is a one-to-one correspondence between V and F such that two vertices in V are adjacent to each other if and only if the corresponding intervals in F overlap each other. In this paper, we present two efficient algorithms for finding maximum cliques of an overlap graph when it is given in the form of a family of n intervals. The first algorithm finds a maximum clique in O (n. log n + Min {m, n- ω}) time, where m is the number of edges and ω is the size of a maximum clique, respectively, of the graph. The second algorithm generates all maximum cliques in O (n - log n + m + γ) time, where γ is the total sum of their sizes.

Given an n-node plane graph G, the visibility representation of G is concerned with drawing each node of G using a horizontal line segment such that the line segments associated with any two adjacent nodes of G are vertically visible to each other. Finding most compact visibility representations of plane graphs is not only of theoretical importance but also of practical interest, and has received much attention in the community of algorithmic graph theory. In this paper, we give a linear-time algorithm to find a visibility representation of G no wider than ⌊4n/3⌋ - 2. Our result improves upon the previously known upper bound 4n/3 + 2⌈ √n⌉, providing a positive answer to a conjecture suggested in the literature about whether an upper bound 4n/3 + O(1) on the required width can be achieved for an arbitrary plane graph. In fact, our visibility representation achieves optimality in the upper bound of width because the bound differs from the previously known lower bound ⌊4n/3⌋ - 3 only by one unit.

We focus on large graphs where nodes have attributes, such as a social network where the nodes are labelled with each person's job title. In such a setting, we want to find subgraphs that match a user query pattern. For example, a "star" query would be, "find a CEO who has strong interactions with a Manager, a Lawyer,and an Accountant, or another structure as close to that as possible". Similarly, a "loop" query could help spot a money laundering ring.Traditional SQL-based methods, as well as more recent graph indexing methods, will return no answer when an exact match does not exist. This is the first main feature of our method. It can find exact-, as well as near-matches, and it will present them to the user in our proposed "goodness" order. For example, our method tolerates indirect paths between, say, the "CEO" and the "Accountant" of the above sample query, when direct paths don't exist. Its second feature is scalability. In general, if the query has nq nodes and the data graph has n nodes, the problem needs polynomial time complexity O(nnq), which is prohibitive. Our G-Ray ("Graph X-Ray") method finds high-quality subgraphs in time linear on the size of the data graph.Experimental results on the DLBP author-publication graph (with 356K nodes and 1.9M edges) illustrate both the effectiveness and scalability of our approach. The results agree with our intuition, and the speed is excellent. It takes 4 seconds on average fora 4-node query on the DBLP graph.