Efficient Retrieval and Ranking of Undesired Package Cycles in Large Software Systems

International audienceMany design guidelines state that a software system architecture should avoid cycles between its packages. Yet such cycles appear again and again in many programs. We believe that the existing approaches for cycle detection are too coarse to assist the developers to remove cycles from their programs. In this paper, we describe an efficient algorithm that performs a fine-grained analysis of the cycles among the packages of an application. In addition, we define a metric to rank cycles by their level of undesirability, prioritizing the cycles that seems the more undesired by the developers. Our approach is validated on two large and mature software systems in Java and Smalltalk

Cache-Oblivious Persistence

Partial persistence is a general transformation that takes a data structure and allows queries to be executed on any past state of the structure. The cache-oblivious model is the leading model of a modern multi-level memory hierarchy.We present the first general transformation for making cache-oblivious model data structures partially persistent

Amortised resource analysis with separation logic

Type-based amortised resource analysis following Hofmann and Jost—where resources are associated with individual elements of data structures and doled out to the programmer under a linear typing discipline—have been successful in providing concrete resource bounds for functional programs, with good support for inference. In this work we translate the idea of amortised resource analysis to imperative languages by embedding a logic of resources, based on Bunched Implications, within Separation Logic. The Separation Logic component allows us to assert the presence and shape of mutable data structures on the heap, while the resource component allows us to state the resources associated with each member of the structure. We present the logic on a small imperative language with procedures and mutable heap, based on Java bytecode. We have formalised the logic within the Coq proof assistant and extracted a certified verification condition generator. We demonstrate the logic on some examples, including proving termination of in-place list reversal on lists with cyclic tails

Fast modularisation and aomic decomposition of ontologies using axiom dependency hypergraphs

In this paper we define the notion of an axiom dependency hypergraph, which explicitly represents how axioms are included into a module by the algorithm for computing locality-based modules. A locality-based module of an ontology corresponds to a set of connected nodes in the hypergraph, and atoms of an ontology to strongly connected components. Collapsing the strongly connected components into single nodes yields a condensed hypergraph that comprises a representation of the atomic decomposition of the ontology. To speed up the condensation of the hypergraph, we first reduce its size by collapsing the strongly connected components of its graph fragment employing a linear time graph algorithm. This approach helps to significantly reduce the time needed for computing the atomic decomposition of an ontology. We provide an experimental evaluation for computing the atomic decomposition of large biomedical ontologies. We also demonstrate a significant improvement in the time needed to extract locality-based modules from an axiom dependency hypergraph and its condensed version

Complexity of Coloring Graphs without Paths and Cycles

Let $P_t$ and $C_\ell$ denote a path on $t$ vertices and a cycle on $\ell$ vertices, respectively. In this paper we study the $k$-coloring problem for $(P_t,C_\ell)$-free graphs. Maffray and Morel, and Bruce, Hoang and Sawada, have proved that 3-colorability of $P_5$-free graphs has a finite forbidden induced subgraphs characterization, while Hoang, Moore, Recoskie, Sawada, and Vatshelle have shown that $k$-colorability of $P_5$-free graphs for $k \geq 4$ does not. These authors have also shown, aided by a computer search, that 4-colorability of $(P_5,C_5)$-free graphs does have a finite forbidden induced subgraph characterization. We prove that for any $k$, the $k$-colorability of $(P_6,C_4)$-free graphs has a finite forbidden induced subgraph characterization. We provide the full lists of forbidden induced subgraphs for $k=3$ and $k=4$. As an application, we obtain certifying polynomial time algorithms for 3-coloring and 4-coloring $(P_6,C_4)$-free graphs. (Polynomial time algorithms have been previously obtained by Golovach, Paulusma, and Song, but those algorithms are not certifying); To complement these results we show that in most other cases the $k$-coloring problem for $(P_t,C_\ell)$-free graphs is NP-complete. Specifically, for $\ell=5$ we show that $k$-coloring is NP-complete for $(P_t,C_5)$-free graphs when $k \ge 4$ and $t \ge 7$; for $\ell \ge 6$ we show that $k$-coloring is NP-complete for $(P_t,C_\ell)$-free graphs when $k \ge 5$, $t \ge 6$; and additionally, for $\ell=7$, we show that $k$-coloring is also NP-complete for $(P_t,C_7)$-free graphs if $k = 4$ and $t\ge 9$. This is the first systematic study of the complexity of the $k$-coloring problem for $(P_t,C_\ell)$-free graphs. We almost completely classify the complexity for the cases when $k \geq 4, \ell \geq 4$, and identify the last three open cases

Width and size of regular resolution proofs

This paper discusses the topic of the minimum width of a regular resolution refutation of a set of clauses. The main result shows that there are examples having small regular resolution refutations, for which any regular refutation must contain a large clause. This forms a contrast with corresponding results for general resolution refutations.Comment: The article was reformatted using the style file for Logical Methods in Computer Scienc

A quasi-linear algorithm to compute the tree of shapes of n-D images

International audienceTo compute the morphological self-dual representation of images, namely the tree of shapes, the state-of-the-art algorithms do not have a satisfactory time complexity. Furthermore the proposed algorithms are only effective for 2D images and they are far from being simple to implement. That is really penalizing since a self-dual representation of images is a structure that gives rise to many powerful operators and applications, and that could be very useful for 3D images. In this paper we propose a simple-to-write algorithm to compute the tree of shapes; it works for \nD images and has a quasi-linear complexity when data quantization is low, typically 12~bits or less. To get that result, this paper introduces a novel representation of images that has some amazing properties of continuity, while remaining discrete

Bounded Search Tree Algorithms for Parameterized Cograph Deletion: Efficient Branching Rules by Exploiting Structures of Special Graph Classes

Many fixed-parameter tractable algorithms using a bounded search tree have been repeatedly improved, often by describing a larger number of branching rules involving an increasingly complex case analysis. We introduce a novel and general search strategy that branches on the forbidden subgraphs of a graph class relaxation. By using the class of $P_4$-sparse graphs as the relaxed graph class, we obtain efficient bounded search tree algorithms for several parameterized deletion problems. We give the first non-trivial bounded search tree algorithms for the cograph edge-deletion problem and the trivially perfect edge-deletion problems. For the cograph vertex deletion problem, a refined analysis of the runtime of our simple bounded search algorithm gives a faster exponential factor than those algorithms designed with the help of complicated case distinctions and non-trivial running time analysis [21] and computer-aided branching rules [11].Comment: 23 pages. Accepted in Discrete Mathematics, Algorithms and Applications (DMAA

Inference of Well-Typings for Logic Programs with Application to Termination Analysis

This paper develops a method to infer a polymorphic well-typing for a logic program. One of the main motivations is to contribute to a better automation of termination analysis in logic programs, by deriving types from which norms can automatically be constructed. Previous work on type-based termination analysis used either types declared by the user, or automatically generated monomorphic types describing the success set of predicates. Declared types are typically more precise and result in stronger termination conditions than those obtained with inferred types. Our type inference procedure involves solving set constraints generated from the program and derives a well-typing in contrast to a success-set approximation. Experiments show that our automatically inferred well-typings are close to the declared types and thus result in termination conditions that are as good as those obtained with declared types for all our experiments to date. We describe the method, its implementation and experiments with termination analysis based on the inferred types