37,651 research outputs found
Guided Unfoldings for Finding Loops in Standard Term Rewriting
In this paper, we reconsider the unfolding-based technique that we have
introduced previously for detecting loops in standard term rewriting. We
improve it by guiding the unfolding process, using distinguished positions in
the rewrite rules. This results in a depth-first computation of the unfoldings,
whereas the original technique was breadth-first. We have implemented this new
approach in our tool NTI and compared it to the previous one on a bunch of
rewrite systems. The results we get are promising (better times, more
successful proofs).Comment: Pre-proceedings paper presented at the 28th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2018), Frankfurt
am Main, Germany, 4-6 September 2018 (arXiv:1808.03326
Probabilistic Analysis of Edge Elimination for Euclidean TSP
One way to speed up the calculation of optimal TSP tours in practice is
eliminating edges that are certainly not in the optimal tour as a preprocessing
step. In order to do so several edge elimination approaches have been proposed
in the past. In this work we investigate two of them in the scenario where the
input consists of independently distributed random points in the
2-dimensional unit square with bounded density function from above and below by
arbitrary positive constants. We show that after the edge elimination procedure
of Hougardy and Schroeder the expected number of remaining edges is
, while after that the the non-recursive part of Jonker and
Volgenant the expected number of remaining edges is
Optimizing compilation with preservation of structural code coverage metrics to support software testing
Code-coverage-based testing is a widely-used testing strategy with the aim of providing a meaningful decision criterion for the adequacy of a test suite. Code-coverage-based testing is also mandated for the development of safety-critical applications; for example, the DO178b document requires the application of the modified condition/decision coverage. One critical issue of code-coverage testing is that structural code coverage criteria are typically applied to source code whereas the generated machine code may result in a different code structure because of code optimizations performed by a compiler. In this work, we present the automatic calculation of coverage profiles describing which structural code-coverage criteria are preserved by which code optimization, independently of the concrete test suite. These coverage profiles allow to easily extend compilers with the feature of preserving any given code-coverage criteria by enabling only those code optimizations that preserve it. Furthermore, we describe the integration of these coverage profile into the compiler GCC. With these coverage profiles, we answer the question of how much code optimization is possible without compromising the error-detection likelihood of a given test suite. Experimental results conclude that the performance cost to achieve preservation of structural code coverage in GCC is rather low.Peer reviewedSubmitted Versio
Transformation Rules for Locally Stratified Constraint Logic Programs
We propose a set of transformation rules for constraint logic programs with
negation. We assume that every program is locally stratified and, thus, it has
a unique perfect model. We give sufficient conditions which ensure that the
proposed set of transformation rules preserves the perfect model of the
programs. Our rules extend in some respects the rules for logic programs and
constraint logic programs already considered in the literature and, in
particular, they include a rule for unfolding a clause with respect to a
negative literal.Comment: To appear in: M. Bruynooghe, K.-K. Lau (Eds.) Program Development in
Computational Logic, Lecture Notes in Computer Science, Springe
Proving theorems by program transformation
In this paper we present an overview of the unfold/fold proof method, a method for proving theorems about programs, based on program transformation. As a metalanguage for specifying programs and program properties we adopt constraint logic programming (CLP), and we present a set of transformation rules (including the familiar unfolding and folding rules) which preserve the semantics of CLP programs. Then, we show how program transformation strategies can be used, similarly to theorem proving tactics, for guiding the application of the transformation rules and inferring the properties to be proved. We work out three examples: (i) the proof of predicate equivalences, applied to the verification of equality between CCS processes, (ii) the proof of first order formulas via an extension of the quantifier elimination method, and (iii) the proof of temporal properties of infinite state concurrent systems, by using a transformation strategy that performs program specialization
Improving DISPGB Algorithm Using the Discriminant Ideal
In 1992, V. Weispfenning proved the existence of Comprehensive Groebner Bases
(CGB) and gave an algorithm to compute one. That algorithm was not very
efficient and not canonical. Using his suggestions, A. Montes obtained in 2002
a more efficient algorithm (DISPGB) for Discussing Parametric Groebner Bases.
Inspired in its philosophy, V. Weispfenning defined, in 2002, how to obtain a
Canonical Comprehensive Groebner Basis (CCGB) for parametric polynomial ideals,
and provided a constructive method.
In this paper we use Weispfenning's CCGB ideas to make substantial
improvements on Montes DISPGB algorithm. It now includes rewriting of the
discussion tree using the Discriminant Ideal and provides a compact and
effective discussion. We also describe the new algorithms in the DPGB library
containing the improved DISPGB as well as new routines to check whether a given
basis is a CGB or not, and to obtain a CGB. Examples and tests are also
provided.Comment: 21 pages, see also http://www-ma2.upc.edu/~montes
Generic Encodings of Constructor Rewriting Systems
Rewriting is a formalism widely used in computer science and mathematical
logic. The classical formalism has been extended, in the context of functional
languages, with an order over the rules and, in the context of rewrite based
languages, with the negation over patterns. We propose in this paper a concise
and clear algorithm computing the difference over patterns which can be used to
define generic encodings of constructor term rewriting systems with negation
and order into classical term rewriting systems. As a direct consequence,
established methods used for term rewriting systems can be applied to analyze
properties of the extended systems. The approach can also be seen as a generic
compiler which targets any language providing basic pattern matching
primitives. The formalism provides also a new method for deciding if a set of
patterns subsumes a given pattern and thus, for checking the presence of
useless patterns or the completeness of a set of patterns.Comment: Added appendix with proofs and extended example
- …