122 research outputs found
Decision Procedures for Loop Detection
The dependency pair technique is a powerful modular method for automated termination proofs of term rewrite systems. We first show that dependency pairs are also suitable for disproving termination: loops can be detected more easily.
In a second step we analyze how to disprove innermost termination. Here, we present a novel procedure to decide whether a given loop is an innermost loop.
All results have been implemented in the termination prover AProVE
Group Communication Patterns for High Performance Computing in Scala
We developed a Functional object-oriented Parallel framework (FooPar) for
high-level high-performance computing in Scala. Central to this framework are
Distributed Memory Parallel Data structures (DPDs), i.e., collections of data
distributed in a shared nothing system together with parallel operations on
these data. In this paper, we first present FooPar's architecture and the idea
of DPDs and group communications. Then, we show how DPDs can be implemented
elegantly and efficiently in Scala based on the Traversable/Builder pattern,
unifying Functional and Object-Oriented Programming. We prove the correctness
and safety of one communication algorithm and show how specification testing
(via ScalaCheck) can be used to bridge the gap between proof and
implementation. Furthermore, we show that the group communication operations of
FooPar outperform those of the MPJ Express open source MPI-bindings for Java,
both asymptotically and empirically. FooPar has already been shown to be
capable of achieving close-to-optimal performance for dense matrix-matrix
multiplication via JNI. In this article, we present results on a parallel
implementation of the Floyd-Warshall algorithm in FooPar, achieving more than
94 % efficiency compared to the serial version on a cluster using 100 cores for
matrices of dimension 38000 x 38000
The Quest for Optimal Sorting Networks: Efficient Generation of Two-Layer Prefixes
Previous work identifying depth-optimal -channel sorting networks for
is based on exploiting symmetries of the first two layers.
However, the naive generate-and-test approach typically applied does not scale.
This paper revisits the problem of generating two-layer prefixes modulo
symmetries. An improved notion of symmetry is provided and a novel technique
based on regular languages and graph isomorphism is shown to generate the set
of non-symmetric representations. An empirical evaluation demonstrates that the
new method outperforms the generate-and-test approach by orders of magnitude
and easily scales until
Sorting Networks: the End Game
This paper studies properties of the back end of a sorting network and
illustrates the utility of these in the search for networks of optimal size or
depth. All previous works focus on properties of the front end of networks and
on how to apply these to break symmetries in the search. The new properties
help shed understanding on how sorting networks sort and speed-up solvers for
both optimal size and depth by an order of magnitude
Twenty-Five Comparators is Optimal when Sorting Nine Inputs (and Twenty-Nine for Ten)
This paper describes a computer-assisted non-existence proof of nine-input
sorting networks consisting of 24 comparators, hence showing that the
25-comparator sorting network found by Floyd in 1964 is optimal. As a
corollary, we obtain that the 29-comparator network found by Waksman in 1969 is
optimal when sorting ten inputs.
This closes the two smallest open instances of the optimal size sorting
network problem, which have been open since the results of Floyd and Knuth from
1966 proving optimality for sorting networks of up to eight inputs.
The proof involves a combination of two methodologies: one based on
exploiting the abundance of symmetries in sorting networks, and the other,
based on an encoding of the problem to that of satisfiability of propositional
logic. We illustrate that, while each of these can single handed solve smaller
instances of the problem, it is their combination which leads to an efficient
solution for nine inputs.Comment: 18 page
Automated Termination Analysis for Logic Programs with Cut
Termination is an important and well-studied property for logic programs.
However, almost all approaches for automated termination analysis focus on
definite logic programs, whereas real-world Prolog programs typically use the
cut operator. We introduce a novel pre-processing method which automatically
transforms Prolog programs into logic programs without cuts, where termination
of the cut-free program implies termination of the original program. Hence
after this pre-processing, any technique for proving termination of definite
logic programs can be applied. We implemented this pre-processing in our
termination prover AProVE and evaluated it successfully with extensive
experiments
SAT Solving for Argument Filterings
This paper introduces a propositional encoding for lexicographic path orders
in connection with dependency pairs. This facilitates the application of SAT
solvers for termination analysis of term rewrite systems based on the
dependency pair method. We address two main inter-related issues and encode
them as satisfiability problems of propositional formulas that can be
efficiently handled by SAT solving: (1) the combined search for a lexicographic
path order together with an \emph{argument filtering} to orient a set of
inequalities; and (2) how the choice of the argument filtering influences the
set of inequalities that have to be oriented. We have implemented our
contributions in the termination prover AProVE. Extensive experiments show that
by our encoding and the application of SAT solvers one obtains speedups in
orders of magnitude as well as increased termination proving power
- …