In our development up to this point, we have treated feature structures logically as models of descriptions expressed in a simple attribute-value language. In the last chapter, we extended the notion of description to include variables; in this chapter, we generalize the notion of model to partial algebraic structures. An algebraic model consists of an arbitrary collection of domain objects and associates each feature with a unary partial function over this domain. In the research of Smolka (1988, 1989) and Johnson (1986, 1987, 1990), more general algebraic models of attribute-value descriptions are the focus of attention. We pull the rabbit out of the hat when we show that our old notion of satisfaction as a relation between feature structures and descriptions is really just a special case of a more general algebraic definition of satisfaction. The feature structures constitute an algebraic model in which the domain of the model is the collection of feature structures, and the features pick out their natural (partial) value mappings. What makes the feature structure model so appealing from a logical perspective is that it is canonical in the sense that descriptions are logically equivalent if and only if they are logically equivalent for the feature structure model. In this respect, the feature structure model plays the same logical role as term models play in universal algebra. This connection is strengthened in light of the most general satisfier and description theorems, which allow us to go back and forth between feature structures and their normal form descriptions.

Introduction

In recent joint work with A. Edalat[ES91] we developed a general approach to the solution of domain equations, based on information system ideas. The basis of the work was an axiomatization of the notion of a category of information systems, yielding what we may call an “information category”, or I-category for short. We begin this paper with an exposition of the I-category work. In the remainder of the paper we consider duality in I-categories, as the setting for studying initial algebra/final algebra coincidence. We then look at induction and coinduction principles in the light of these ideas.

To amplify the preceding a little, we note that the existing treatments of information systems, following [Sco82] and [LW84], make use of a global ordering of the objects of the category (the information systems) in order to “solve” domain equations by the ordinary cpo fixed point theorem. In the I-category approach, an initial algebra characterization of the solutions is obtained, by making use of a global ordering ⊆ of morphisms in addition to the ordering ⊴ of objects. (In the usual cases, where morphisms are “approximable relations” between tokens, the global ordering is essentially set inclusion; more precisely, we have that (f : A → B) ⊆ (f′ : A′ → B′) if A ⊴ A′, B ⊴ B′ and f ⊆ f′.) Moreover the axiomatic formulation enables us to handle many examples besides the usual categories of domains, in a unified manner: for example, “domain equations” over Stone spaces, via Boolean algebras as information systems. In the present exposition, we attempt to clarify the relation between the I-category approach and an established method of domain equation solution, namely the O-category method,usingthe Basic Lemma of [SP82] as a key.

In Algebraically Complete Categories (in the proceedings of the Category theory conference in Como '90) an ALGEBRAICALLY COMPLETE CATEGORY was defined as one for which every covariant endofunctor has an initial algebra. This should be understood to be in a 2-category setting, that is, in a setting in which the phrase “every covariant endofunctor” refers to an understood class of endofunctors.

Given an endofunctor T the category of T- INVARIANT objects is best defined as the category whose objects are triples <A,f, g> where f:TA →A, g:A→TA and fg and gf are both identity maps. T-Inv appears as a full subcategory of both T-Alg and T-Coalg, in each case via a forgetful functor. The Lambek lemma and its dual say that the initial object in T-Alg and the final object in T-Coalg may be viewed as objects in T-Inv wherein they easily remain initial and final. Of course there is a canonical map from the initial to the final. I will say that T is ALGEBRAICALLY BOUNDED if this canonical map is an isomorphism, equivalently if T-Inv is a punctuated category, that is one with a biterminator, an object that is both initial and final.

An algebraically bicomplete category is ALGEBRAICALLY COMPACT if each endofunctor is algebraically bounded. (As with algebraic completeness this should be understood to be in a 2-category setting.) In this context I will use the term FREE T-ALGEBRA rather than either initial algebra or final coalgebra.

With our definition of inheritance, we have a notion of consistency and unification for our smallest conceptual unit, the type. We now turn to the task of developing structured representations that can be built out of the basic concepts, which we call feature structures. The reason for the qualifier is that even though feature structures are defined using our type symbols, they are not typed, in the sense that there is no restriction on the co-occurrence of features or restrictions on their values. We introduce methods for specifying appropriateness conditions on features and a notion of well-typing only after studying the ordered notion of feature structures. We also hold off on introducing inequations and extensionality conditions. Before introducing these other topics, we concentrate on fully developing the notion of untyped feature structure and the logical notions we employ. Most of the results that hold for feature structures can be immediately generalized to well-typed feature structures by application of the type inference mechanism.

Our feature structures are structurally similar to the more traditional form of feature structures such as those used in the patr-ii system and those defined by Rounds and Kasper. The next major development after these initial systems was introduced by Moshier (1988). The innovation of Moshier's system was to allow atomic symbols to label arbitrary nodes in a feature structure. He also treated the identity conditions for these atoms fully intensionally. Both patr-ii and the Rounds and Kasper systems treated feature structures intensionally, but enforced extensional identity conditions on atoms.

In this chapter, we consider a phrase structure grammar formalism, or more precisely, a parameterized family of such formalisms, in which non-terminal (category) symbols are replaced by feature structures in both rewriting rules and lexical entries. Consequently, the application of a rewriting rule must be mediated by unification rather than by simple symbol matching. This explains why grammar formalisms such as the one we present here have come to be known as unification-based. Although our presentation of unification-based phrase structure grammars is self contained, for those unfamiliar with unification-based grammars and their applications, we recommend reading Shieber's excellent introduction (Shieber 1986). Shieber lays out the fundamental principles of unification-based phrase structure formalisms along with some of their more familar incarnations, as well as providing a wide variety of linguistic examples and motivations. Another good introductory source is the text by Gazdar and Mellish (1989).

The early development of unification-based grammars was intimately connected with the development of logic programming itself, the most obvious link stemming from Colmerauer's research into Q-systems (1970) and Metamorphosis Grammars (1978). In fact, Colmerauer's development of Prolog was motivated by the desire to provide a powerful yet efficient implementation environment for natural language grammars. The subsequent popularity of Prolog led to the development of a number of so-called logic grammar systems. These grammar formalisms are typically variations of first-order term unification phrase structure grammars such as the Definite Clause Grammars (DCGS) of Pereira and Warren (1980), the Extraposition Grammars of Pereira (1981), the Slot Grammars of McCord (1981) and also the Gapping Grammars of Dahl and Abramson (1984, Popowich 1985).

Introduction

In these circumstances it seems appropriate to set down those old ideas after all, and to complete them in various ways, in particular as regards enriched monads.

In this chapter we introduce the logical attribute-value language that we employ to describe feature structures. Our description language is the same (in the sense of containing exactly the same descriptions) as that of Rounds and Kasper (1986), but following Pollard (in press) our interpretations are based on our feature structures rather than the ones provided by Rounds and Kasper. One way to look at the language of descriptions is as providing a way to talk about feature structures; the language can be displayed linearly one symbol after another and can thus be easily used in implementations. Other researchers, namely Johnson (1987, 1988), Smolka (1988) and King (1989), use similar, but much more powerful, logical description languages and take a totally different view of the nature of interpretations or models for these languages. The main difference in their descriptions is the presence of general description negation, implication, and variables. The interpretations they use are based on a domain of objects with features interpreted as unary partial functions on this domain. In the system we describe here, we view feature structures themselves as partial objects; descriptions are just a particularly neat and tidy notation for picking them out. Our view thus corresponds to Aït-Kaci's treatment of his ψ-terms, which were also taken to be partial descriptions of empirical objects. Johnson (1988:72), on the other hand, is at pains to point out that he does not view feature structures as partial models or descriptions of total linguistic objects, but rather as total objects themselves.

In this chapter we generalize our notion of feature structure to allow for the possibility of having countably infinite collections of nodes. When we considered algebraic models in the last chapter, we implicitly allowed models with objects from which infinitely many distinct objects were accessible by iteratively applying feature value functions. In the case of feature structures as we have previously taken them, the set of substructures of a feature structure was always in one-to-one correspondence with the nodes of the feature structure and hence finite. In the case of finite feature structures, we were guaranteed joins or unifications for consistent finite sets of (finite) feature structures. We also saw examples of infinite sets of consistent finite feature structures which did not have a finite least upper bound. When we allow for the possibility of countably infinite feature structures, we have least upper bounds for arbitrary (possibly infinite) consistent sets of (possibly infinite) feature structures. In fact, the collection of feature structures with countable node sets turn out to form a predomain in the sense that when we factor out alphabetic variance, we are left with an algebraic countably based BCPO. Luckily, in the feature structure domain, the compact domain elements are just the finite feature structures, thus giving us a way to characterize arbitrary infinite feature structures as simple joins of finite feature structures. One benefit of such a move is that infinite or limit elements in our domains provide models for non-terminating inference procedures such as total type inference over an appropriateness specification with loops or extensionalization when non-maximal types are allowed to be extensional.

In this chapter we consider acyclic feature structures and their axiomatization. In standard first-order logic resolution theorem provers (see Wos et al. 1984 for an overview), it is necessary to make sure that when a variable X is unified with a term t, there is no occurrence of X in t. This is the so-called occurs check and dates back to Robinson's (1965) original algorithm for unification. Without the occurs check, resolution produces unsound inferences. The problem with the occurs check is that it is often expensive to compute in practical unification algorithms. Unification algorithms have been developed with built in occurs checks that are linear (Paterson and Wegman 1978) and quasi-linear (Martelli and Montanari 1982), but the data structures employed for computing the occurs check incur a heavy constant overhead (Jaffar 1984). Rather than carry out the occurs check, implementations of logic programming languages like Prolog simply omit it, leading to interpreters and compilers which are not sound with respect to the semantics of first-order logic and may furthermore cause the interpreters to hang during the processing of cyclic structures which are accidentally created. Rather than change the interpreters, the move made in Prolog II (Colmerauer 1984, 1987) was to change the semantics to allow for infinite rational trees, which correspond to the infinite unfoldings of the terms that result from unifications of a variable with a term that contains it. Considering the pointer-based implementation of unification (Jaffar 1984, Moshier 1988), infinite trees are more naturally construed as finite graphs containing cycles.

Abstract

Introduction

One of the cornerstones of programming language semantics is the correspondence between simply-typed λ-calculi and cartesian closed categories established by Lambek and Scott [LS86]. It provides a clean algebraic semantics for λ-terms, which helps us to reason effectively about the values of programs. Of equal interest to the implementer, however, is the reduction process which computes these values, i.e. the operational semantics. One of the most satisfying approaches to date is Plotkin's structural operational semantics [Plo75, Plo81] which uses a sequent calculus to describe the reduction process and provide a rigorous specification for computation.

In spite of their separate virtues, it is difficult to relate the logic (of operational semantics) to the categorical algebra (of denotational semantics); the usual approach, using computational adequacy, is rather unwieldy.

Introduction

In his seminal paper [Plo77], Plotkin introduced the functional language PCF (‘programming language for computable functions’) together with the standard denotational model of cpo's and continuous functions. He proved that this model is computationally adequate for PCF, but not fully abstract.

In order to obtain full abstraction he extended PCF by a parallel conditional operator. The problem with this operator is, that it changes the nature of the language. All computations in the original language PCF can be executed sequentially, but the new operator requires expressions to be evaluated in parallel.

Here we address the problem of full abstraction for the original sequential language PCF, i. e. instead of extending the language we try to improve the model. Our approach is to cut down the standard model with the aid of certain logical relations, which we call sequentiality relations. We give a semantic characterization of these relations and illustrate how they can be used to reason about sequential (i. e. PCF-definable) functions. Finally we prove that this style of reasoning is ‘complete’ for proving observational congruences between closed PCF-expressions of order ≤ 3. Technically, this completeness can be expressed as a full abstraction result for the sublanguage which consists of these expressions.

Sequential PCF

In [Plo77], PCF is defined as a simply typed λ-calculus over the ground types ι (of integers) and o (of Booleans).

Abstract

Fibrations have been widely used to model polymorphic λ-calculi. In this paper we describe the additional structure on a fibration that suffices to make it a model of a polymorphic λ-calculus with subtypes and bounded quantification; the basic idea is to single out a class of maps, the inclusions, in each fibre. Bounded quantification is made possible by a imposing condition that resembles local smallness. Since the notion of inclusion is not stable under isomorphism, some care must be taken to make everything strict.

We then show that PER models for λ-calculi with subtypes fit into this framework. In fact, not only PERs, but also any full reflective sub category of the category of modest sets (‘PERs’ in a realizability topos), provide a model; hence all the small complete categories of ‘synthetic domains’ found in various realizability toposes can be used to model subtypes.

Introduction

What this paper is about

At the core of object-oriented programming, and related approaches to programming, are the notions of subtyping and inheritance. These have proved to be very powerful tools for structuring programs, and they appear—in one form or another—in a wide variety of modern programming languages.

One way of studying these notions formally is to use the framework of typed λ-calculus. That is, we start with a formal system (say, a version of the polymorphic λ-calculus) and extend it by adding a notion of type inclusion, together with suitable rules; we obtain a larger system. We can then use the methods of mathematical logic to study the properties of the system.

Abstract

We explore some foundational issues in the development of a theory of intensional semantics, in which program denotations may convey information about computation strategy in addition to the usual extensional information. Beginning with an “extensional” category C, whose morphisms we can think of as functions of some kind, we model a notion of computation using a comonad with certain extra structure and we regard the Kleisli category of the comonad as an intensional category. An intensional morphism, or algorithm, can be thought of as a function from computations to values, or as a function from values to values equipped with a computation strategy. Under certain rather general assumptions the underlying category C can be recovered from the Kleisli category by taking a quotient, derived from a congruence relation that we call extensional equivalence. We then focus on the case where the underlying category is cartesian closed. Under further assumptions the Kleisli category satisfies a weak form of cartesian closure: application morphisms exist, currying and uncurrying of morphisms make sense, and the diagram for exponentiation commutes up to extensional equivalence. When the underlying category is an ordered category we identify conditions under which the exponentiation diagram commutes up to an inequality. We illustrate these ideas and results by introducing some notions of computation on domains and by discussing the properties of the corresponding categories of algorithms on domains.

Introduction

Most existing denotational semantic treatments of programming languages are extensional, in that they abstract away from computational details and ascribe essentially extensional meanings to programs.

Introduction

There has been considerable recent interest in the use of algebraic methodologies to define and elucidate constructions in fixed point semantics [B], [FMRS], [Mu2]. In this paper we present recent results utilizing categorical methods, particularly strong monads, algebras and dinatural transformations to build general fixed point operators. The approach throughout is to evolve from the specific to the general case by eventually discarding the particulars of domains and continuous functions so often used in this setting. Instead we rely upon the structure of strong monads and algebras to provide a general algebraic framework for this discussion. This framework should provide a springboard for further investigations into other issues in semantics.

By way of background, the issues raised in this paper find their origins in several different sources. In [Mu2] the formal role of iteration in a cartesian closed category (ccc) with fixed points was investigated. This was motivated by the observation in [H-P] that the presence of a natural number object (nno) was inconsistent with ccc's and fixed points. This author introduced the notion of onno (ordered nno) which in semantic categories played a role as iterator and was precisely the initial T-algebra for T the strong lift monad. Using the onno a factorization of fix was produced and further it was shown fix was in fact a dinatural transformation. This was accomplished by avoiding the traditional projection/embedding approach to semantics. Similar results were extended to order-enriched and effective settings as well.

Turning to monads, their role in computation is not new. In particular, it was emphasized early in the development of topos theory that the partial map classifier was a strong monad.

Abstract

Domain theoretic understanding of databases as elements of powerdomains is modified to allow multisets of records instead of sets. This is related to geometric theories and classifying toposes, and it is shown that algebraic base domains lead to algebraic categories of models in two cases analogous to the lower (Hoare) powerdomain and Gunter's mixed powerdomain.

Terminology

Throughout this paper, “domain” means algebraic poset – not necessarily with bottom, nor second countable. The information system theoretic account of algebraic posets fits very neatly with powerdomain constructions. Following Vickers [90], it may be that essentially the same methods work for continuous posets; but we defer treating those until we have a better understanding of the necessary generalizations to topos theory.

More concretely, a domain is a preorder (information system) (D, ⊆) of tokens, and associated with it are an algebraic poset pt D of points (ideals of D; one would normally think of pt D as the domain), and a frame ΩD of opens (upper closed subsets of D; ΩD is isomorphic to the Scott topology on pt D).

“Topos” always means “Grothendieck topos”, and not “elementary topos” morphisms between toposes are understood to be geometric morphisms.

S, italicized, denotes the category of sets.

We shall follow, usually without comment, the notation of Vickers [89], which can be taken as our standard reference for the topological and localic notions used here.

Abstract

Introduction

The straightforward way to describe the simply typed λ-calculus (denoted here by λ1) categorically is in terms of cartesian closed categories (CCC's), see [10]. On the type theoretic side this caused some discomfort, because one commonly uses only exponent types without assuming cartesian product types — let alone unit (i.e. terminal) types. The typical reply from category theory is that one needs cartesian products in order to define exponents. Below we give a categorical description of exponent types without assuming cartesian product types. We do use cartesian products of contexts; these always exist by concatenation. Thus both sides can be satisfied by carefully distinguishing between cartesian products of types and cartesian products of contexts. We introduce an appropriate categorical structure for doing so.

In [6] one can find a general method to describe typed λ-calculi categorically. One of the main organizing principles used there is formulated below. It deserves the status of a slogan.

Abstract

Introduction

There are many situations in logic, theoretical computer science, and category theory where two binary operations, “tensor products” (though one may be a “sum”), play a key role. The multiplicative fragment of linear logic is a particularly interesting example as it is a Gentzen style sequent calculus in which the structural rules of contraction, thinning, and (sometimes) exchange are dropped. The fact that these rules are omitted considerably simplifies the derivation of the cut elimination theorem. Furthermore, the proof theory of this fragment is interesting and known [Se89] to correspond to *-autonomous categories as introduced by Ban in [Ba79].

In the study of categories with two tensor products one usually assumes a distributivity condition, particularly in the case when one of these is either the product or sum.