Transitive Closure Computation Research Articles

A Note on the Fast Computation of Transitive Closure of Graphs and the Multiplication of Integer Matrices

Some algorithms for computing transitive closure of a graph and matrix multiplication in the Boolean semiring and in the rings of residues are compared. The bounds for the size and depth of the corresponding Boolean circuits are given.

High Performance Methods for Linked Open Data Connectivity Analytics

The main objective of Linked Data is linking and integration, and a major step for evaluating whether this target has been reached, is to find all the connections among the Linked Open Data (LOD) Cloud datasets. Connectivity among two or more datasets can be achieved through common Entities, Triples, Literals, and Schema Elements, while more connections can occur due to equivalence relationships between URIs, such as owl:sameAs, owl:equivalentProperty and owl:equivalentClass, since many publishers use such equivalence relationships, for declaring that their URIs are equivalent with URIs of other datasets. However, there are not available connectivity measurements (and indexes) involving more than two datasets, that cover the whole content (e.g., entities, schema, triples) or “slices” (e.g., triples for a specific entity) of datasets, although they can be of primary importance for several real world tasks, such as Information Enrichment, Dataset Discovery and others. Generally, it is not an easy task to find the connections among the datasets, since there exists a big number of LOD datasets and the transitive and symmetric closure of equivalence relationships should be computed for not missing connections. For this reason, we introduce scalable methods and algorithms, (a) for performing the computation of transitive and symmetric closure for equivalence relationships (since they can produce more connections between the datasets); (b) for constructing dedicated global semantics-aware indexes that cover the whole content of datasets; and (c) for measuring the connectivity among two or more datasets. Finally, we evaluate the speedup of the proposed approach, while we report comparative results for over two billion triples.

Code clone genealogy detection on e-health system using Hadoop

Code clone genealogy detection has been widely used in refactoring and maintenance of code in software systems. It identifies history of code clones in a source code repository. Existing code clone genealogy detection techniques are based on text similarity for extraction of different versions of program. However, existing proposals in literature for code clone genealogy detection fail to extract code clone genealogy on Git (a distributed version control system). To address this issue, we presented a new scheme, based on transitive closure computation that detects code clone genealogies in e-health system on Git. Our insight is to extract clone pairs from thousands of commits on a software system in Git by transitive closure computation. We implemented the proposed scheme using Hadoop and Neo4j on Open Medical Record System. The results prove efficacy of the proposed scheme using parameters such as transitive depth, ratio of similarity, and count of clones.

Directed hypergraphs: Introduction and fundamental algorithms—A survey

Just as ordinary hypergraphs are a generalization of graphs, directed hypergraphs (DH) are a natural generalization of digraphs. A DH consists of a set of vertices V and a set of hyperarcs H, where a hyperarc is a pair <S,v>, S non empty subset of V and v∈V. DHs have a variety of applications: they have been used to represent functional dependency in databases, Horn formulae in propositional logic, and–or graphs, context free grammars etc. In the paper, after providing a brief historical introduction on the notion of DH and some relevant applications, various problems regarding DHs are surveyed and analyzed. In particular we consider the complexity of the reachability problem (together with its application in the related satisfiability problem for Horn CNF formulae) and the computation of transitive closure and transitive reduction of directed hypergraphs (together with its application to the computation of minimum coverings for a set of functional dependencies). Finally a short introduction to the problem of computing shortest hyperpaths in directed hypergraphs is provided.

Automatic segmentation of color images with transitive closure

In this paper, a mask based automatic segmentation algorithm for color images which uses pixel similarity has been presented. Main concept of the algorithm relies on spatial mask for course segmentation and the Warshall's transitive closure (TC) computation algorithm for region merging. Although the proposed spatial mask approach reduces the computational burden required for segmentation or clustering techniques such as seeded region growing (SRG) or fuzzy c-means (FCM) in which user supplied parameters are essential, it has over segmentation drawback. Therefore, the transitive closure algorithm, which uses adjacency and similarity matrix associated to undirected graph of the over segmented image, has been employed to merge the regions. After comparing to existing methods, the obtained experimental results confirmed that the color images as well as gray level images could be segmented with considerable accuracy. Also computational complexity of image segmentation is significantly reduced. Furthermore, there is no need any user supplied parameter such as the number of clusters or seed points.

Embedded Transitive Closure Network for Runtime Deadlock Detection in Networks-on-Chip

Interconnection networks with adaptive routing are susceptible to deadlock, which could lead to performance degradation or system failure. Detecting deadlocks at runtime is challenging because of their highly distributed characteristics. In this paper, we present a deadlock detection method that utilizes runtime transitive closure (TC) computation to discover the existence of deadlock-equivalence sets, which imply loops of requests in networks-on-chip (NoCs). This detection scheme guarantees the discovery of all true deadlocks without false alarms in contrast with state-of-the-art approximation and heuristic approaches. A distributed TC-network architecture, which couples with the NoC infrastructure, is also presented to realize the detection mechanism efficiently. Detailed hardware realization architectures and schematics are also discussed. Our results based on a cycle-accurate simulator demonstrate the effectiveness of the proposed method. It drastically outperforms timing-based deadlock detection mechanisms by eliminating false detections and, thus, reducing energy wastage in retransmission for various traffic scenarios including real-world application. We found that timing-based methods may produce two orders of magnitude more deadlock alarms than the TC-network method. Moreover, the implementations presented in this paper demonstrate that the hardware overhead of TC-networks is insignificant.

Symbolic computation of strongly connected components and fair cycles using saturation

The computation of strongly connected components (SCCs) in discrete-state models is a critical step in formal verification of LTL and fair CTL properties, but the potentially huge number of reachable states and SCCs constitutes a formidable challenge. We consider the problem of computing the set of states in SCCs or terminal SCCs in an asynchronous system. We employ the idea of saturation, which has shown clear advantages in symbolic state-space exploration (Ciardo et al. in Softw Tools Technol Transf 8(1):4–25, 2006; Zhao and Ciardo in Proceedings of 7th international symposium on automated technology for verification and analysis, pp 368–381, 2009), to improve two previously proposed approaches. We use saturation to speed up state exploration when computing each SCC in the Xie-Beerel algorithm, and we compute the transitive closure of the transition relation using a novel algorithm based on saturation. Furthermore, we show that the techniques we developed are also applicable to the computation of fair cycles. Experimental results indicate that the improved algorithms using saturation achieve a substantial speedup over previous BFS algorithms. In particular, with the new transitive closure computation algorithm, up to 10150 SCCs can be explored within a few seconds.

A new realization of shared resource matrix transitive closure computation algorithm

A new realization of shared resource matrix transitive closure computation algorithm

Decomposition Optimization for Minimizing Label Overflow in Prime Number Graph Labeling

Recently, a graph labeling technique based on prime numbers has been suggested for reducing the costly transitive closure computations in RDF query languages. The suggested prime number graph labeling provides the benefit of fast query processing by a simple divisibility test of labels. However, it has an inherent problem that originates with the nature of prime numbers. Since each prime number must be used exclusively, labels can become significantly large. Therefore, in this paper, we introduce a novel optimization technique to effectively reduce the problem of label overflow. The suggested idea is based on graph decomposition. When label overflow occurs, the full graph is divided into several sub-graphs, and nodes in each sub-graph are separately labeled. Through experiments, we also analyze the effectiveness of the graph decomposition optimization, which is evaluated by the number of divisions.

System Π: A Native RDF Repository Based on the Hypergraph Representation for RDF Data Model

RDF is the data interchange layer for the Semantic Web. In order to manage the increasing amount of RDF data, an RDF repository should provide not only the necessary scalability and efficiency, but also sufficient inference capabilities. Though existing RDF repositories have made progress towards these goals, there is still ample space for improving the overall performance. In this paper, we propose a native RDF repository, System Π, to pursue a better tradeoff among system scalability, query efficiency, and inference capabilities. System Π takes a hypergraph representation for RDF as the data model for its persistent storage, which effectively avoids the costs of data model transformation when accessing RDF data. Based on this native storage scheme, a set of efficient semantic query processing techniques are designed. First, several indices are built to accelerate RDF data access including a value index, a labeling scheme for transitive closure computation, and three triple indices. Second, we propose a hybrid inference strategy under the pD * semantics to support inference for OWL-Lite with a relatively low computational complexity. Finally, we extend the SPARQL algebra to explicitly express inference semantics in logical query plan by defining some new algebra operators. In addition, MD5 hash value of URI and schema level cache are introduced as practical implementation techniques. The results of performance evaluation on the LUBM benchmark and a real data set show that System Π has a better combined metric value than other comparable systems.

Equivalence-Set Genes Partitioning Using an Evolutionary-DP Approach

Computation of transitive-closure equivalence sets has recently emerged as an important step for building static and dynamic models of gene network from DNA sequences. We present an evolutionary-DP approach in which dynamic programming (DP) is embedded into a genetic algorithm (GA) for fitness function evaluation of small equivalence sets (with m genes) within a large-scale genetic network of n genes, where n > m. This approach reduces a computation-intensive optimal problem of high dimension into a heuristic search problem on nCm candidates. The DP computation of transitive closure forms the basic fitness evaluation for selecting candidate chromosomes generated by GA operators. By introducing bounded mutation and conditioned crossover operators to constrain the feasible solution domain, small transitive-closure equivalence sets for large genetic networks can be found with much reduced computational effort. Empirical results have successfully demonstrated the feasibility of our GA-DP approach for offering highly efficient solutions to large scale equivalence gene-set partitioning problem. We also describe dedicated GA-DP hardware using field programmable gate arrays (FPGAs), in which significant speedup could be obtained over software implementation.

On the Recognition of Algorithm Templates

This paper deals with the problem of deciding whether a System of Affine Recurrent Equations (SARE) is an instantiation of a SARE template. A solution to this problem would be a step toward algorithm template recognition and open new perspectives in program analysis, optimization and parallelization. The problem is known to be undecidable and we show that there exists a semi-decision procedure, in which the key ingredient is the computation of transitive closures of affine relations. This is a non-effective process which has been extensively studied. We then describe the limitations of our algorithm and point to unsolved problems.

Optimizing taxonomic semantic web queries using labeling schemes

This paper focuses on the optimization of the navigation through voluminous subsumption hierarchies of topics employed by portal catalogs like Netscape Open Directory (ODP). We advocate for the use of labeling schemes for modeling these hierarchies in order to efficiently answer queries such as subsumption check, descendants, ancestors or nearest common ancestor, which usually require costly transitive closure computations. We first give a qualitative comparison of three main families of schemes, namely bit vector, prefix and interval based schemes. We then show that two labeling schemes are good candidates for an efficient implementation of label querying using standard relational DBMS, namely the Dewey prefix scheme and an interval scheme by Agrawal et al. We compare their storage and query evaluation performance for the 16 ODP hierarchies using the PostgreSQL engine.

Optimizing Taxonomic Semantic Web Queries Using Labeling Schemes

This paper focuses on the optimization of the navigation through voluminous subsumption hierarchies of topics employed by Portal Catalogs like Netscape Open Directory (ODP). We advocate for the use of labeling schemes for modeling these hierarchies in order to efficiently answer queries such as subsumption check, descendants ancestors or nearest common ancestor which usually require costly transitive closure computations. We give a qualitative comparison of three main families of schemes, namely bit vector prefix and interval based schemes We then show that two labeling schemes are good candidates for an efficient implementation of label querying using standard relational DBMS namely the Dewey Prefix scheme and an Interval scheme by Agrawal Borgida and Jagadish. We compare their storage and query evaluation performance for the ODP hierarchies using the PostgreSQL engine.

Techniques for Reducing the Number of Decisions and Backtracks in Combinational Test Generation

Combinational test pattern generation (TPG) is basically a search in a finite state space. In general, the search is performed in a branch-and-bound fashion. The branch-and-bound search builds a decision tree using two basic operations: decision making and backtracking. The size of the decision tree, and hence the efficiency of the branch-and-bound search, is directly dependent on the number of decisions made. This paper proposes a set of novel techniques for reducing the number of decisions and the size of the decision space. These techniques work directly on the maximum number of potential ways of justifying a given logical assignment. This maximum number is reduced by exploiting the properties of prime-and-irredundant covers. These same properties are also used to reduce the number of backtracks by implying a maximum number of necessary assignments. The reduction of the number of decisions and the identification of a maximum of necessary assignments make the proposed TPG method highly efficient as demonstrated by experimental results. This paper also proposes a novel combination of prime-and-irredundant cover extraction and transitive closure computation for a more efficient TPG process.

PERFORMANCE DEPENDENCY MODELING FOR ADA PROGRAMS BASED ON MODULE INVOCATION MECHANISMS

ABSTRACT Retaining a satisfactory performance for a program has been an important yet difficult task for software maintenance. This difficulty can largely be attributed to the performance ripple effect of software modifications which, in turn, is caused by the performance dependencies between program entities. Among various linguistic mechanisms contributing to the causes of performance dependencies, module invocation may be the one most commonly used. This mechanism, however, may appear in a variety of syntactic forms in a program, ranging from a simple form such as subprogram invocation to more complex forms such as task communication and data abstraction. This paper presents an approach to the modeling of module invocation based performance dependencies among program entities for Ada1 programs. This approach is based on an extended program invocation graph model. In this model, an Ada program is analyzed and partitioned into primitive program entities that will be mapped into vertices of this graph model. The edges between vertices are constructed in accordance with the invocation mechanisms linking the corresponding program entities. Since this graph model preserves the transitive property of performance dependency relations between program entities, the tracing of indirect performance dependencies can then be converted into a simple computation of transitive closure of this graph model. This technique forms partially the theoretical basis for the analysis of performance ripple effect as a consequence of program modifications. Although this approach was developed to analyze performance dependencies for Ada programs, the technique presented can be easily tailored to analyze programs written in other concurrent programming languages.

Parallel transitive closure computation in relational databases

The transitive closure operation is an important extension to relational algebra. Because of its high computation cost, it is of great interest to design efficient parallel algorithms for computing the transitive closure in relational database systems. In this paper, we present a new algorithm to compute transitive closures on SIMD meshes based on relational algebra operations. Double-hash distribution is used to avoid rehashing new tuples for the next join phase. There presently exists no extra step for the redistribution of these tuples. Possible redundant computation between different join phases has been prevented without using global operations. As only regular linear communication occurs on the mesh, and the workload is fully distributed, a speedup of O( n × n) has been achieved, where n × n is the size of mesh. Therefore, this algorithm is an optimal parallel version of the transitive closure algorithms based on relational algebra operations on SIMD meshes.

A new fragmentation scheme for recursive query processing

Data fragmentation is a well-known technique used in distributed database design to support efficient query processing. In deductive databases and knowledge bases, one distinct operation is the computation of transitive closures. In this paper, we employ a fragmentation approach to deductive databases. Fragmentation techniques are investigated in distributed database environments for parallel recursive query processing. Based on the novel fragmentation scheme, a new parallel transitive closure algorithm is proposed. Compared with previous algorithms, our algorithm can explore a much higher level of parallelism with very little communication overhead increase.

A transitive closure algorithm for test generation

A transitive-closure-based test generation algorithm is presented. A test is obtained by determining signal values that satisfy a Boolean equation derived from the neural network model of the circuit incorporating necessary conditions for fault activation and path sensitization. The algorithm is a sequence of two main steps that are repeatedly executed: transitive closure computation and decision-making. A key feature of the algorithm is that dependences derived from the transitive closure are used to reduce ternary relations to binary relations that in turn dynamically update the transitive closure. The signals are either determined from the transitive closure or are enumerated until the Boolean equation is satisfied. Experimental results on the ISCAS 1985 and the combinational parts of ISCAS 1989 benchmark circuits are presented to demonstrate efficient test generation and redundancy identification. Results on four state-of-the-art production VLSI circuits are also presented. >

Efficient computation of transitive closures

We describe an efficient, time-space balanced algorithm for computation of the transitive max-min closure of a proximity relation, i.e. of a fuzzy relation that is reflexive and symmetric. The algorithm creates a binary tree representation of the transitive closure in O( m log 2 m) time and O( m) space, where m is the number of edges in the proximity graph. A central idea in algorithm is to order the edges after decreasing strength and then to process them in that order. For any pair of vertices, their similarity, i.e. their membership value in the transitive closure, is looked up in the tree in O(log 2 n) time, where n is the number of vertices in the proximity graph. We compare the performance of the algorithm with the performances of two other presented algorithms that compute transitive closures of broader classes of fuzzy relations.