Jan Maluszynski

Relating logic programs and attribute grammars

Abstract This paper shows that logic programs and attribute grammars are closely related. Constructions are fiven which transform logic programs into semantically equivalent attribute grammars, and vice versa. This opens for application in logic programming of some methods developed for attribute grammars. These results are used to find a sufficient condition under which no infinite term can be created during a computation of a logic program, and to define a nontrivial class of logic programs which can be run without employing unification in its general form.

Inductive assertion method for logic programs

Certain properties of logic programs are inexpressible in terms of their declarative semantics. On example of such properties would be the actual form of procedure calls and successes which occur during computations of a program. They are often used by programmers in their informal reasoning. In this paper, the inductive assertion method for proving partial correctness of logic programs is introduced and proved sound. The method makes it possible to formulate and prove properties which are inexpressible in terms of the declarative semantics. An execution mechanism using the Prolog computation rule and arbitrary search strategy (eg. OR-parallelism or Prolog backtracking) is assumed. The method may be also used to specify the semantics of some extra-logical built-in procedures for which the declarative semantics is not applicable.

Hybrid reasoning with rules and ontologies

The purpose of this chapter is to report on work that has been done in the REWERSE project concerning hybrid reasoning with rules and ontologies. Two major streams of work have been pursued within REWERSE. They start from the predominant semantics of nonmonotonic rules in logic programming. The one stream was an extension of non-monotonic logic programs under answer set semantics, with query interfaces to external knowledge sources. The other stream, in the spirit of the AL-log approach of enhanced deductive databases, was an extension of Datalog (with the well-founded semantics, which is predominant in the database area). The former stream led to so-called nonmonotonic dl-programs and HEX-programs, and the latter stream to hybrid wellfounded semantics. Further variants and derivations of the formalisms (like a well-founded semantics for dl-programs, respecting probabilistic knowledge, priorities, etc.) have been conceived.

Well-founded semantics for hybrid rules

The problem of integration of rules and ontologies is addressed in a general framework based on the well-founded semantics of normal logic programs and inspired by the ideas of Constraint Logic Programming (CLP). Hybrid rules are defined as normal clauses extended with constraints in the bodies. The constraints are formulae in a language of a first order theory defined by a set T of axioms. Instances of the framework are obtained by specifying a language of constraints and providing T. A hybrid program is a pair (P, T) where P is a finite set of hybrid rules. Thus integration of (non-disjunctive) Datalog with ontologies formalized in a Description Logic is covered as a special case. The paper defines a declarative semantics of hybrid programs and a formal operational semantics. The latter can be seen as an extension of SLS-resolution and provides a basis for hybrid implementations combining Prolog with constraint solvers. In the restricted case of positive rules, hybrid programs are formulae of FOL. In that case the declarative semantics reduces to the standard notion of logical consequence. The operational semantics is sound and it is complete for a restricted class of hybrid programs.

Towards a Clean Amalgamation of Logic Programs with External Procedures

The paper presents a clean approach to the amalgamation of logic programming with external functional procedures. Both the logical semantics and the operational semantics of the amalgamated language are outlined. The operational semantics is based on an incomplete ɛ-unification algorithm which we call S-unification. It is suggested to use abstract interpretation techniques in order to identify classes of goals for which the approach is complete. For this purpose a domain of abstract substitutions is defined, and an abstract unification algorithm used for a compile-time check is developed.

Semantic techniques for the web: the REWERSE perspective

Hybrid Reasoning with Rules and Ontologies.- Four Lessons in Versatility or How Query Languages Adapt to the Web.- Evolution and Reactivity in the Semantic Web.- Rule-Based Policy Representations and Reasoning.- Component Models for Semantic Web Languages.- Controlled English for Reasoning on the Semantic Web.- Semantic Search with GoPubMed.- Information Integration in Bioinformatics with Ontologies and Standards.

Modeling and Reasoning with Paraconsistent Rough Sets

We present a language for defining paraconsistent rough sets and reasoning about them. Our framework relates and brings together two major fields: rough sets [23] and paraconsistent logic programming [9]. To model inconsistent and incomplete information we use a four-valued logic. The language discussed in this paper is based on ideas of our previous work [21,32,22] developing a four-valued framework for rough sets. In this approach membership function, set containment and set operations are four-valued, where logical values are t (true), f (false), i (inconsistent) and u (unknown). We investigate properties of paraconsistent rough sets as well as develop a paraconsistent rule language, providing basic computational machinery for our approach.

Directional types and the annotation method

Abstract A directonal type for a Prolog program expresses certain properties of the operational semantics of the program. This paper shows that the annotation proof method, proposed by Deransart for proving declarative properties of logic programs, is also applicable for proving correctness of directional types. In particular, the sufficient correctness criterion of well-typedness by Bronsard et al., turns out to be a specialization of the annotation method. The comparison shows a general mechanism for construction of similar specializations, which is applied to derive yet another concept of well-typedness. The usefulness of the new correctness criterion is shown on examples of Prolog programs, where the traditional notion of well-typedness is not applicable. We further show that the new well-typing condition can be applied to different execution models. This is illustrated by an example of an execution model where unification is controlled by directional types, and where our new well-typing condition is applied to show the absence of deadlock.

Static and Dynamic Slicing of Constraint Logic Programs

Slicing is a program analysis technique originally developed for imperative languages. It facilitates understanding of data flow and debugging. This paper discusses slicing of Constraint Logic Programs. Constraint Logic Programming (CLP) is an emerging software technology with a growing number of applications. Data flow in constraint programs is not explicit, and for this reason the concepts of slice and the slicing techniques of imperative languages are not directly applicable. This paper formulates declarative notions of slice suitable for CLP. They provide a basis for defining slicing techniques (both dynamic and static) based on variable sharing. The techniques are further extended by using groundness information. A prototype dynamic slicer of CLP programs implementing the presented ideas is briefly described together with the results of some slicing experiments.

On Subtyping of Tree-Structured Data: A Polynomial Approach

This paper discusses subtyping of tree-structured data encountered on the Web, e.g. XML and HTML data. Our long range objective is to define a type system for Web and/or Semantic Web query languages amenable to static type checking. We propose a type formalism motivated by XML Schema and accommodating two concepts of subtyping: inclusion subtyping (corresponding to XML Schema notion of type restriction) and extension subtyping (motivated by XML Schema’s type extension). We present algorithms for checking both kinds of subtyping. The algorithms are polynomial if certain conditions are imposed on the type definitions; the conditions seem natural and not too restrictive.