Intuitionistic and linear logics can be used to specify the operational semantics of transition systems in various ways. We consider here two encodings: one uses linear logic and maps states of the transition system into formulas, and the other uses intuitionistic logic and maps states into terms. In both cases, it is possible to relate transition paths to proofs in sequent calculus. In neither encoding, however, does it seem possible to capture properties, such as simulation and bisimulation, that need to consider all possible transitions or all possible computation paths. We consider augmenting both intuitionistic and linear logics with a proof theoretical treatment of definitions. In both cases, this addition allows proving various judgments concerning simulation and bisimulation (especially for noetherian transition systems). We also explore the use of infinite proofs to reason about infinite sequences of transitions. Finally, combining definitions and induction into sequent calculus proofs makes it possible to reason more richly about properties of transition systems completely within the formal setting of sequent calculus.

The theory of partial inductive definitions is a mathematical formalism which has proved to be useful in a number of different applications. The fundamentals of the theory is shortly described. Partial inductive definitions and their associated calculi are essentially infinitary. To implement them on a computer, they must be given a formal finitary representation. We present such a finitary representation, and prove its soundness. The finitary representation is given in a form with and without variables. Without variables, derivations are unchanging entities. With variables, derivations can contain logical variables that can become bound by a binding environment that is extended as the derivation is constructed. The variant with variables is essentially a generalization of the pure GCLA programming language.

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...

Logical frameworks with a logic programming interpretation such as hereditary Harrop formulae (HHF) [15] cannot express directly negative information, although negation is a useful specification tool. Since negation-as-failure does not fit well in a logical framework, especially one endowed with hypothetical and parametric judgements, we adapt the idea of elimination of negation introduced in [21] for Horn logic to a fragment of higher-order HHF. This entails finding a middle ground between the Closed World Assumption usually associated with negation and the Open World Assumption typical of logical frameworks; the main technical idea is to isolate a set of programs where static and dynamic clauses do not overlap.

Introduction During the past ten years, integration of functional and logic programming languages has attracted much research. An extensive survey and classification of their results can be found in [GLDD90]. Traditionally this integration is performed by attempting to integrate the respective semantic logics of functional and logic languages in some way, resulting in a "super logic language". As we presented in Chapter ??, the conventional understanding of logic programming is that a logic program defines a logical theory and computation is attempting to prove that a query is a logical consequence of this theory. Taking this view, integration is regarded as enhancing the original logic underlying a logic programming system to cope with functional programming features and results in a new logic programming system. Most approaches take first-order equational logic as the semantic logic of functional languages and combine it with Horn clause logic. The following

This paper describes the logical and philosophical background of an extension of logic programming which uses a general schema for introducing assumptions and thus presents a new view of hypothetical reasoning. The detailed proof theory of this system is given in [7], matters of implementation and control of the corresponding programming language GCLA with detailed examples can be found in [1, 2]. In Section 1 we consider the local rule-based approach to a notion of atomic consequence as opposed to the global logical approach. Section 2 describes our system and characterises the inference schema of definitional reflection which is central for our approach. In Section 3 we motivate the computational interpretation of this system. Finally, Section 4 relates our approach to the idea of logical frameworks and the way elimination inferences for logical constants are treated therein, and thus to the notions of logic and structure. It shows that from a certain perspective, logical reasoning is nothing but a special case of reasoning in our system. 1 Local and global consequence

The paper describes a tool for generating plans for the construction of a building. The application is implemented in GCLA, together with a simple constraint solving system. The main idea is that experiences from other plans are stored in methods; which are a systematic way of grouping activities together as higher level activities that can solve more complex tasks. Activities are entities that perform some action on a model of the real world, called the global state. Activities have preconditions, i.e. starting conditions, some representation of time and resource consumption, and postconditions, i.e. how and what to change in the global state. Scheduling activities amounts to allocating resources and placing the activities in time. The goal of the planning process, i.e what we want the planning process to achieve, is represented by a geometric model of the changed global state, i.e. a design of the specified building that one wants to build. To create plans, the system is divided into...

A definitional approach to the construction of knowledge-based systems is presented. The notions of a knowledge base and the logical interface of a knowledge base are discussed. 1 Introduction This paper presents some preliminary results from a project in which we intend to study the problem of giving mathematically precise and implementation independent models of the notion of a knowledge base. These models will then serve as a basis for computer aided development and testing of specialized knowledge-based systems (KBS). We will especially concentrate on trying to characterize the logical interface of a KB, i.e. a user's basic conceptual model of a given KB. This paper does not present any final results, but is merely a first attempt of putting some of the main ideas down on paper. The rest of this paper is organized as follows. In Sect. 2 we describe what we mean by a knowledge base and the notion of a logical interface of a knowledge base. We also provide a small example of a know...

We describe a definitional programming tool designed to be a successor to the GCLA and GCLAII systems. The tool is designed to provide for a cleaner definitional programming methodology. It is also intended for use as an embedded deductive database engine in objectoriented applications with GUI within the MedView project. The computational model and implementation are described, and a number of example programs given. 1 Introduction Declarative programming comes in many flavors. There are functional languages, lazy functional languages, logic languages, constraint logic languages, functional logic languages and so on. Common to most of these is the concept definition. Function definitions are given, predicates are defined etc. Yet another approach to declarative programming is what we call definitional programming. In a definitional program the definition is the basic notion not functions, predicates or constraints. Since conceptually both functions and predicates are given using...