Extending a multi-set relational algebra to a parallel environment

Parallel database systems will very probably be the future for high-performance data-intensive applications. In the past decade, many parallel database systems have been developed, together with many languages and approaches to specify operations in these systems. A common background is still missing, however. This paper proposes an extended relational algebra for this purpose, based on the well-known standard relational algebra. The extended algebra provides both complete database manipulation language features, and data distribution and process allocation primitives to describe parallelism. It is defined in terms of multi-sets of tuples to allow handling of duplicates and to obtain a close connection to the world of high-performance data processing. Due to its algebraic nature, the language is well suited for optimization and parallelization through expression rewriting. The proposed language can be used as a database manipulation language on its own, as has been done in the PRISMA parallel database project, or as a formal basis for other languages, like SQL

Automated verification of termination certificates

In order to increase user confidence, many automated theorem provers provide certificates that can be independently verified. In this paper, we report on our progress in developing a standalone tool for checking the correctness of certificates for the termination of term rewrite systems, and formally proving its correctness in the proof assistant Coq. To this end, we use the extraction mechanism of Coq and the library on rewriting theory and termination called CoLoR

Using Resources as Synchronizers to Manage Mobile Process Adaptation

Process management in Mobile Ad-hoc NETworks (MANETs) has to deal with different types of tasks and resources. Teams can be formed with specific goals, such as recognition of a damaged area for disaster assessment, where each member of a team is assigned some task to be performed according to some policy. However, in real situations, it is possible that task assignments and policies have to be revised due to different causes. In addition to typical causes for dynamic changes in adaptive workflows, mobility introduces some specific problems, e.g. the need for new connectivity-maintaining tasks, or reassignment of tasks originally for members who have become unreachable, or who have no sufficient resources to complete the original plan. As these modifications occur dynamically, it is difficult to manage them through hard-coded programs. Rather, we propose the use of a rule-based formalism, expressed in terms of multi-set rewriting. This supports a resource-centered view, in which both data-dependencies between tasks and plan-dependent ordering of tasks are expressed as production and consumption of resources of different types. In turn, rules are themselves seen as resources, so that they are prone to the same rewriting process, in order to redefine process schemas. The paper illustrates these notions and formalisms, and shows some cases of their application

Inheritance hierarchies: Semantics and unification

Inheritance hierarchies are introduced as a means of representing taxonomicallyorganized data. The hierarchies are built up from so-called feature types that are ordered by subtyping and whose elements are records. Every feature type comes with a set of features prescribing fields of its record elements. So-called feature terms are available to denote subsets of feature types. Feature unification is introduced as an operation that decides whether two feature terms have a nonempty intersection and computes a feature term denoting the intersection.We model our inheritance hierarchies as algebraic specifications in ordersortedequational logic using initial algebra semantics. Our framework integrates feature types whose elements are obtained as records with constructor types whose elements are obtained by constructor application. Unification in these hierarchies combines record unification with order-sorted term unification and is presented as constraint solving. We specify a unitary unification algorithm by a set of simplification rules and prove its soundness and completeness with respect to the model-theoretic semantics