The notion of a recognizable set of words, trees or graphs is relative to an algebraic structure on the set of words, trees or graphs respectively. We establish that several algebraic structures yield the same notion of a recognizable set of graphs. This notion is equivalent to that of a fully cutset-regular set of graphs introduced by Fellows and Abrahamson. We also establish that the class of recognizable sets of graphs is closed under the operations considered in these various equivalent definitions. This fact is not a standard consequence of the definition of recognizability.

In this paper we provide a categorical interpretation of the first-order Hoare logic of a small programming language by giving a weakest precondition semantics for the language. To this end, we extend the well-known notion of a (first-order) hyperdoctrine to include partial maps. The most important new aspect of the resulting partial (first-order) hyperdoctrine is a different notion of morphism between the fibres. We also use this partial hyperdoctrine to give a model for Beeson's Partial Function Logic such that (a version of) his axiomatization is complete with respect to this model. This shows the usefulness of the notion, independent of its intended use as a model for Hoare logic.

Having started life as a way of reconstructing a topological space from a pair of complementary subspaces, the glueing construction has found employment in a wide range of different roles, from the construction of free distributive lattices to a supporting part in the 2-categorical analysis of types theories. In this latter role the construction appears to be a fundamental factor in the behaviour of higher order proof theory. What is going on here? Before that can be answered we need at least a less ad hoc description of the construction. In this paper I set down what is, I believe, the beginnings of a coherent account of the algebraic version of glueing. As well as the abstract theory, I give a good selection of different examples to illustrate the diverse nature of the uses of the construction.

In this article, we indicate how the category theoretical approach to tree automata, due to Betti and Kasangian, can be fruitfully combined with Walters’ categorical approach to context-free grammars to provide a simple way of establishing the well-known correspondence between context-free languages and the behaviors of non-deterministic tree automata. The connecting link between the two notions is provided by the theory of relational presheaves.

We propose a formalization of standard database management systems using topos theory. In this treatment, all constructions take place within an ambient topos, which thereby serves as the ‘universe of discourse’. A database schema is defined using objects and morphisms in the ambient topos. A database state for a given schema involves not only the ambient topos but also an internal category within the topos. This approach neatly separates the schema from the state data by placing them in distinct category structures. It is shown that database states can either be regarded syntactically as objects in an external topos or semantically as morphisms in an internal slice category. A number of operations are introduced that correspond to operations used in standard database systems. Extraction selects some of the tables, attributes and domains of a database state. The squeeze operation performs an ‘elimination of duplicates’, which can be combined with extraction to obtain an operation called ‘projection’ in standard relational database systems. A join operation is defined, which generalizes the relational join operation and can be used for the cartesian product and selection operations. Finally, ‘boolean’ operations of intersection, union and difference are introduced and related to the other operations.

The notion of a dynamic labeled 2-structure(dℓ2s) is introduced and investigated. It generalizes the notion of a labeled 2-structure (ℓ2s) (Ehrenfeucht and Rozenberg 1990), by making it possible to change the (label) relationships between the nodes. This is achieved by storing in the nodes of a ℓ2s output and input functions that can change the outgoing and incoming labels, respectively. The notion of a clan, which is central in the theory of ℓ2s's is transferred to the framework of dℓ2s's, and the basic properties of clans of dℓ2s's are investigated.

Within a categorical framework for primitive recursion, equality between p.r. maps is shown to be definable by suitable p.r. equality predicates. Equivalence is shown between a direct categorical formalization of classical p.r. functions and p.r. maps in the sense of Lawvere and Freyd. An extension of the theory is shown to admit a ‘universal set’ containing all objects of the extended theory of subobjects.

Dynamic programming is a strategy for solving optimisation problems. In this paper, we show how many problems that may be solved by dynamic programming are instances of the same abstract specification. This specification is phrased using the calculus of relations offered by topos theory. The main theorem underlying dynamic programming can then be proved by straightforward equational reasoning.

The generic specification of dynamic programming makes use of higher-order operators on relations, akin to the fold operators found in functional programming languages. In the present context, a data type is modelled as an initial F-algebra, where F is an endofunctor on the topos under consideration. The mediating arrows from this initial F-algebra to other F-algebras are instances of fold – but only for total functions. For a regular category ε, it is possible to construct a category of relations Rel(ε). When a functor between regular categories is a so-called relator, it can be extended (in some canonical way) to a functor between the corresponding categories of relations. Applied to an endofunctor on a topos, this process of extending functors preserves initial algebras, and hence fold can be generalised from functions to relations.

It is well-known that the use of dynamic programming is governed by the principle of optimality. Roughly, the principle of optimality says that an optimal solution is composed of optimal solutions to subproblems. In a first attempt, we formalise the principle of optimality as a distributivity condition. This distributivity condition is elegant, but difficult to check in practice. The difficulty arises because we consider minimum elements with respect to a preorder, and therefore minimum elements are not unique. Assuming that we are working in a Boolean topos, it can be proved that monotonicity implies distributivity, and this monotonicity condition is easy to verify in practice.

The categorical data types in models of second order lambda calculus are studied. We prove that Reynolds parametricity is a sufficient and necessary condition for the categorical data types to fulfill the universal properties.

We add extensional equalities for the functional and product types to the typed λ-calculus with, in addition to products and terminal object, sums and bounded recursion (a version of recursion that does not allow recursive calls of infinite length). We provide a confluent and strongly normalizing (thus decidable) rewriting system for the calculus that stays confluent when allowing unbounded recursion. To do this, we turn the extensional equalities into expansion rules, and not into contractions as is done traditionally. We first prove the calculus to be weakly confluent, which is a more complex and interesting task than for the usual λ-calculus. Then we provide an effective mechanism to simulate expansions without expansion rules, so that the strong normalization of the calculus can be derived from that of the underlying, traditional, non-extensional system. These results give us the confluence of the full calculus, but we also show how to deduce confluence directly form our simulation technique without using the weak confluence property.

We define a categorical framework, based on the notion of sketch, for specification and evaluation in the senses of algebraic specifications and algebraic programming. This framework goes far beyond our initial motivation, which was to specify computation with algebraic numbers. We begin by redefining sketches in order to deal explicitly with programs. Expressions and terms are carefully defined and studied, then quasi-projective sketches are introduced. We describe static evaluation in these sketches: we propose a rigorous basis for evalution in the corresponding structures. These structures admit an initial model, but are not necessarily equational. In Part II (Duval and Reynaud 1994), we study a more general process, called dynamic evaluation, for structures that may have no initial model.

We introduce a new class of higher order rewriting systems, called Interaction Systems (IS's). IS's are derived from Lafont's (Intuitionistic) Interaction Nets (Lafont 1990) by dropping the linearity constraint. In particular, we borrow from Interaction Nets the syntactical bipartitions of operators into constructors and destructors and the principle of binary interaction. As a consequence, IS's are a subclass of Klop's Combinatory Reduction Systems (Klop 1980), where the Curry-Howard analogy still ‘makes sense’. Destructors and constructors, respectively, correspond to left and right logical introduction rules: interaction is cut and reduction is cut-elimination.

Interaction Systems have been primarily motivated by the necessity of extending the practice of optimal evaluators for λ-calculus (Lamping 1990; Gonthier et al. 1992a) to other computational constructs such as conditionals and recursion. In this paper we focus on the theoretical aspects of optimal reductions. In particular, we generalize the family relation in Lévy (1978; 1980), thus defining the amount of sharing an optimal evaluator is required to perform. We reinforce our notion of family by approaching it in two different ways (generalizing labelling and extraction in Levy (1980)) and proving their coincidence. The reader is referred to Asperti and Laneve (1993c) for the paradigmatic description of optimal evaluators of IS's.

In the first part of this paper (Duval and Reynaud 1994), we defined a categorical framework, based on the notion of sketch, for specification and evaluation in the senses of algebraic specifications and algebraic programming. Static evaluation in quasi-projective sketches was defined in Part I; in this paper, dynamic evaluation is introduced. It deals with more general structures, which may have no initial model. Until now, this process has not been used in algebraic specification systems, but computer algebra systems are beginning to use it as a basic tool. Finally, we give some applications of dynamic evaluation to computation in field extensions.

The shuffle product of two words u and v, denoted u‖v, is the set of all words of the form x1y1x2y2…xnyn for some n and for some (possible empty) words x1, …xn, y1, …yn, such that u = x1x2…xn, and v = y1y2…yn. In other words, u‖v is the set of all possible words that can be obtained by merging u and v so that the letters of u and v separately maintain their original orders but are allowed to alternate arbitrarily. The shuffle product of languages L and M, denoted L‖M, is the union of all u‖v for u ∈ L and v ∈ M.

In a PCF-like call-by-name typed λ-calculus with a minimal fixpoint operator, ‘parallelor’, Plotkin's ‘continuous existential quantifier’ ∃ and recursive types together with constructors and destructors, all computable objects can be denoted by terms of the programming language. According to A. Meyer's terminology (cf. Meyer (1988)), such a programming language is called universal in the sense that any extension of it must be conservative, as all computable objects can already be expressed by program terms.

As a byproduct, we get that, in principle, recursive types could be totally avoided, as they appear as syntactically expressible retracts of the non-recursive type → , where and are the flat domains of natural numbers and boolean values, respectively.

This paper surveys several different variants of order sorted algebra (abbreviated OSA), comparing some of the main approaches (overloaded OSA, universe OSA, unified algebra, term declaration algebra, etc.), emphasising motivation and intuitions, and pointing out features that distinguish the original ‘overloaded’ OSA approach from some later developments. These features include sort constraints and retracts; the latter is particularly useful for handling multiple data representations (including automatic coercions among them). Many examples are given, for most of which, runs are shown on the OBJ3 system.

This paper also significantly generalises overloaded OSA by dropping the regularity and monotonicity assumptions, and by adding signatures of non-monotonicities, which support simple semantics for some aspects of object oriented programming. A number of new results for this generalisation are proved, including initiality, variety, and quasi-variety theorems. Axiomatisability results à la Birkhoff are also proved for unified algebras.

We have found both a proofnet criterion and a sequent calculus for the multiplicative fragment with units ( ⊗1,℘,0, atoms), but without the ┴-boxes of Girard (1987), which differentiate between 1 and ┴. We have also proved that for any of our proofnets there is a corresponding sequential proof.