Rewriting logic [72] is proposed as a logical framework in which other logics can be represented, and as a semantic framework for the specification of languages and systems. Using concepts from the theory of general logics [70], representations of an object logic L in a framework logic F are understood as mappings L ! F that translate one logic into the other in a conservative way. The ease with which such maps can be defined for a number of quite different logics of interest, including equational logic, Horn logic with equality, linear logic, logics with quantifiers, and any sequent calculus presentation of a logic for a very general notion of "sequent," is discussed in detail. Using the fact that rewriting logic is reflective, it is often possible to reify inside rewriting logic itself a representation map L ! RWLogic for the finitely presentable theories of L. Such a reification takes the form of a map between the abstract data types representing the finitary theories of...

We propose a refinement of the type theory underlying the LF logical framework by a form of subtypes and intersection types. This refinement preserves desirable features of LF, such as decidability of type-checking, and at the same time considerably simplifies the representations of many deductive systems. A subtheory can be applied directly to hereditary Harrop formulas which form the basis of Prolog and Isabelle. 1 Introduction Over the past two years we have carried out extensive experiments in the application of the LF Logical Framework [HHP93] to represent and implement deductive systems and their metatheory. Such systems arise naturally in the study of logic and the theory of programming languages. For example, we have formalized the operational semantics and type system of Mini-ML and implemented a proof of type preservation [MP91] and the correctness of a compiler to a variant of the Categorical Abstract Machine [HP92]. LF is based on a predicative type theory with dependent t...

ion An atomic constraint p ? (t 1 ; : : : ; t m ) is decomposed into a conjunction of pure atomic constraints by introducing new equations of the form (x = ? t), where t is an alien subterm in the constraint and x is a variable that does not appear in p ? (t 1 ; : : : ; t m ). This is formalized thanks to the notion of abstraction. Definition 4.2. Let T be a set of terms such that 8t 2 T ; 8u 2 X [ SC; t 6= E1[E2 u: A variable abstraction of the set of terms T is a surjective mapping \Pi from T to a set of variables included in X such that 8s; t 2 T ; \Pi(s) = \Pi(t) if and only if s =E1[E2 t: \Pi \Gamma1 denotes any substitution (with possibly infinite domain) such that \Pi(\Pi \Gamma1 (x)) = x for any variable x in the range of \Pi. It is important to note that building a variable abstraction relies on the decidability of E 1 [ E 2 -equality in order to abstract equal alien subterms by the same variable. Let T = fu #R j u 2 T (F [ X ) and u #R2 T (F [ X )n(X [ SC)g...

The purpose of this paper is to study the problem of complete type inferencing for polymorphic order-sorted logic programs. We show that previous approaches are incomplete even if one does not employ the full power of the used type systems. We present a complete type inferencing algorithm that covers the polymorphic order-sorted types in PROTOS-L, a logic programming language that allows for polymorphism as in ML and for hierarchically structured monomorphic types.

Traditionally the integration of functional and logic languages is performed by attempting to integrate their semantic logics in some way. Many languages have been developed by taking this approach, but none manages to exploit fully the programming features of both functional and logic languages and provide a smooth integration of the two paradigms. We propose that improved integrated systems can be constructed by taking a broader view of the underlying semantics of logic programming. A novel integrated language paradigm, Definitional Constraint Programming (DCP), is proposed. DCP generalises constraint logic programming by admitting user-defined functions via a purely functional subsystem and enhances it with the power to solve constraints over functional programs. This constraint approach to integration results in a homogeneous unified system in which functional and logic programming features are combined naturally. 1 Introduction During the past ten years the integration of funct...

Abstract. In the recent years rule-based programming in terms of declarative logic programming has formed the basis for many Artificial Intelligence (AI) applications and is well integrated in the mainstream information technology capturing higher-level decision logics. Typically, the standard rule systems and rule-based logic programming languages such as Prolog derivatives are based on the untyped theory of predicate calculus with untyped logical objects (untyped terms), i.e. the logical reasoning algorithms apply pure syntactical reasoning. From a rule engineering perspective this is a serious restriction which lacks major Software Engineering principles such as data abstraction or modularization, which become more and more important when rule applications grow larger and more complex. To support such principles in logic programming and capture the rule engineer’s intended meaning of a logic program, types and typed objects play an important role. Moreover, from a computational point of view, the use of types drastically reduces the search space, i.e. proofs can be kept at a more abstract level and it offers the option to restrict the application of rules and to

: We provide a mathematical specification of an extension of Warren's Abstract Machine for executing Prolog to type-constraint logic programming and prove its correctness. In this paper, we keep the notion of types and dynamic type constraints rather abstract to allow applications to different constraint formalisms like Prolog III or CLP(R). This generality permits us to introduce modular extensions of Borger's and Rosenzweig 's formal derivation of the WAM. Starting from type-constraint Prolog algebras that are derived from Borger's standard Prolog algebras, the specification of the typeconstraint WAM extension is given by a sequence of evolving algebras, each representing a refinement level. For each refinement step a correctness proof is given. Thus, we obtain the theorem that for every such abstract type-constraint logic programming system L and for every compiler satisfying the specified conditions, the WAM extension with an abstract notion of types is correct w.r.t. L. This is a ...

Although sorts and unary predicates are semantically identical in order-sorted logic, they are classified as different kinds of properties in formal ontology (e.g. sortal and non-sortal). This ontological analysis is an essential notion to deal with properties (or sorts) of objects in knowledge representation and reasoning. In this paper, we propose an extension of an order-sorted logic with the ontological property classification. This logic contains types (rigid sorts), non-rigid sorts and unary predicates to distinguishably express the properties: substantial sorts, non-substantial sorts and non-sortal properties. We define a sorted Horn-clause calculus for such property expressions in a knowledge base. Based on the calculus, we develop a reasoning algorithm for many separated knowledge bases where each knowledge base can extract rigid property information from other knowledge bases (called rigid property derivation).

Equational presentations with ordered sorts encompass partially defined functions and subtyping information in an algebraic framework. In this work we address the problem of computing in order-sorted algebras, with very few restrictions on the allowed presentations. We adopt an algebraic framework where equational, membership and existence formulas can be expressed. A complete deduction calculus is provided to incorporate the interaction between all these formulas. The notion of decorated terms is proposed to memorize local sort information, dynamically changed by a rewriting process. A completion procedure for equational presentations with ordered sorts computes a set of rewrite rules with which not only equational theorems of the form (t = t 0 ), but also typing theorems of the for...

. We provide a mathematical specification of an extension of Warren's Abstract Machine for executing Prolog to type-constraint logic programming and prove its correctness. Our aim is to provide a full specification and correctness proof of a concrete system, the PROTOS Abstract Machine (PAM), an extension of the WAM by polymorphic order-sorted unification as required by the logic programming language PROTOS-L. In this paper, while leaving the details of the PAM's type constraint representation and solving facilities to a sequel to this work, we keep the notion of types and dynamic type constraints abstract to allow applications to different constraint formalisms like Prolog III or CLP(R). This generality permits us to introduce modular extensions of Borger's and Rosenzweig's formal derivation of the WAM. Since the type constraint handling is orthogonal to the compilation of predicates and clauses, we start from type-constraint Prolog algebras with compiled AND/OR structure that are der...