Gert Smolka

Attributive concept descriptions with complements

Abstract We investigate the consequences of adding unions and complements to attributive concept descriptions employed in terminological knowledge representation languages. It is shown that deciding coherence and subsumption of such descriptions are PSPACE-complete problems that can be decided with linear space.

The Oz Programming model

The Oz Programming Model (OPM) is a concurrent programming model that subsumes functional and object-oriented programming as facets of a general model. This is particularly interesting for concurrent object-oriented programming, for which no comprehensive and formal model existed until now. There is a conservative extension of OPM providing the problem-solving capabilities of constraint logic programming. OPM has been developed together with a concomitant programming language Oz designed for applications that require complex symbolic representations, organization into multiple agents, and soft real-time control. An efficient, robust, and interactive implementation of Oz is freely available.

Order-Sorted Equational Computation

Publisher Summary This chapter discusses order-sorted equational computation. Many-sorted equational logic is the basis for algebraic specifications, rewriting techniques, unification theory, and equational programming. In the standard approach, sorts are unrelated and can be thought of as denoting disjoint sets. Order-sorted equational logic improves the expressivity of many-sorted equational logic by adding the notion of subsorts. The standard example of an abstract data type, stacks of natural numbers, is specified in order-sorted equational logic. It is known that defining a less or equal test for integers with unconditional equations not using subsorts is complicated; one has to introduce an auxiliary function and an auxiliary sort. These complications disappear if one uses conditional equations, but verification methods for the confluence of conditional rewriting systems are complicated and in most cases not practical. The chapter presents the verification methods for confluence extend to order-sorted unconditional rewriting systems.

Feature-constraint logics for unification grammars

Abstract This paper studies feature-description languages that have been developed for use in unification grammars, logic programming, and knowledge representation. The distinctive notational primitives of these languages are features that can be understood as unary partial functions on a domain of abstract objects. We show that feature-description languages can be captured naturally as sublanguages of first-order predicate logic with equality and show the equivalence of a loose Tarski semantics with a fixed feature-graph semantics for quantifier-free constraints. For quantifier-free constraints we give a constraint solving method and show the NP-completeness of satisfiability checking. For general feature constraints with quantifiers satisfiability is shown to be undecidable. Moreover, we investigate an extension of the logic with sort predicates and set-denoting expressions called feature terms.

Records for logic programming

Abstract CFT is a new constraint system providing records as logical data structure for constraint (logic) programming. It can be seen as a generalization of the rational tree system employed in Prolog II, where finer-grained constraints are used and where subtrees are identified by keywords rather than by position. CFT is defined by a first-order structure consisting of so-called feature trees. Feature trees generalize the ordinary trees corresponding to first-order terms by having their edges labeled with field names called features. The mathematical semantics given by the feature tree structure is complemented with a logical semantics given by five axiom schemes, which we conjecture to comprise a complete axiomatization of the feature tree structure. We present a decision method for CFT, which decides entailment and disentailment between possibly existentially quantified constraints. Since CFT satisfies the independence property, our decision method can also be employed for checking the satisfiability of conjunctions of positive and negative constraints. This includes quantified negative constraints such as ∀ y ∀ z(x≠f(y,z)) . The paper also presents an idealized abstract machine processing negative and positive constraints incrementally. We argue that an optimized version of the machine can decide satisfiability and entailment in quasilinear time.

Mobile objects in distributed Oz

Some of the most difficult questions to answer when designing a distributed application are related to mobility: what information to transfer between sites and when and how to transfer it. Network-transparent distribution, the property that a programs behavior is independent of how it is partitioned among sites, does not directly address these questions. Therefore we propose to extend all language entities with a network behavior that enables efficient distributed programming by giving the programmer a simple and predictable control over network communication patterns. In particular, we show how to give objects an arbitrary mobility behavior that is independent of the objects definition. In this way, the syntax and semantics of objects are the same regardless of whether they are used as stationary servers, mobile agents, or simply as caches. These ideas have been implemented in Distributed Oz, a concurrent object-oriented language that is state aware and has dataflow synchronization. We prove that the implementation of objects in Distributed Oz is network transparent. To satisfy the predictability condition, the implementation avoids forwarding chains through intermediate sites. The implementation is an extension to the publicly available DFKI Oz 2.0 system.

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.

Representation and reasoning with attributive descriptions

This paper surveys terminological representation languages and feature-based unification grammars pointing out the similarities and differences between these two families of attributive description formalisms. Emphasis is given to the logical foundations of these formalisms.

Order-sorted unification

This paper studies unification for order-sorted equational logic. This logic generalizes unsorted equational logic by allowing a partially ordered set of sorts, with the ordering interpreted as set-theoretic containment in the models; it also allows overloading of function symbols, such as + for integer and rational number addition, with the overloaded functions of greater rank interpreted in the models as extensions of those of smaller rank. Our presentation emphasizes semantic aspects, and gives a categorical treatment of unification that has substantial advantages in this context over the usual treatment of unifiers as endomorphisms of a single free algebra. Given system @C of equations and a set E of axioms that is sort-preserving and does not impose restrictions on the sorts of its variables, the main results characterize when an order-sorted signature has a minimal (or finite, or most general when @C is solvable) family of order-sorted E-unifiers for @C. In addition, for unitary signatures, where each solvable system of equations has a most general unifier, we give a quasi-linear algorithm for syntactic unification (i.e., for E= ) a la Martelli-Montanari, that is more efficient than the unsorted one for failures.

A Foundation for Higher-order Concurrent Constraint Programming

We present the γ-calculus, a computational calculus for higher-order concurrent programming. The calculus can elegantly express higher-order functions (both eager and lazy) and concurrent objects with encapsulated state and multiple inheritance. The primitives of the γ-calculus are logic variables, names, procedural abstraction, and cells. Cells provide a notion of state that is fully compatible with concurrency and constraints. Although it does not have a dedicated communication primitive, the γ-calculus can elegantly express one-to-many and many-to-one communication. There is an interesting relationship between the γ-calculus and the π-calculus: The γ-calculus is subsumed by a calculus obtained by extending the asynchronous and polyadic π-calculus with logic variables. The γ-calculus can be extended with primitives providing for constraint-based problem solving in the style of logic programming. A such extended γ-calculus has the remarkable property that it combines first-order constraints with higher-order programming.