A programming metalogic is a formal system into which programming languages can be translated and given meaning. The translation should both reflect the structure of the language and make it easy to prove properties of programs. This thesis develops certain metalogics using techniques of category theory and treats recursion in a new way. The notion of a category with fixpoint object is defined. Corresponding to this categorical structure there are type theoretic equational rules which will be present in all of the metalogics considered. These rules define the fixpoint type which will allow the interpretation of recursive declarations. With these core notions FIX categories are defined. These are the categorical equivalent of an equational logic which can be viewed as a very basic programming metalogic. Recursion is treated both syntactically and categorically. The expressive power of the equational logic is increased by embedding it in an intuitionistic predicate calculus, giving rise to the FIX logic. This contains propositions about the evaluation of computations to values and an induction principle which is derived from the definition of a fixpoint object as an initial algebra. The categorical structure which accompanies the FIX logic is defined, called a FIX hyperdoctrine, and certain existence and disjunction properties of FIX are stated. A particular FIX hyperdoctrine is constructed and used in the proof of the same properties. PCF-style languages are translated into the FIX logic and computational adequacy reaulta are proved. Two languages are studied: Both are similar to PCF except one has call by value recursive function declararations and the other higher order conditionals. ...

... theory T with axioms for identity types admits a non-trivial weak factorisation system. After characterising this weak factorisation system explicitly, we relate it to the homotopy theory of groupoids.

We describe a non-extensional variant of Martin-Löf type theory which we call two-dimensional type theory, and equip it with a sound and complete semantics valued in 2-categories.

The lL-calculus is a dependent type theory with both linear and intuitionistic dependent function spaces. It can be seen to arise in two ways. Firstly, in logical frameworks, where it is the language of the RLF logical framework and can uniformly represent linear and other relevant logics. Secondly, it is a presentation of the proof-objects of BI, the logic of bunched implications. BI is a logic which directly combines linear and intuitionistic implication and, in its predicate version, has both linear and intuitionistic quantifiers. The lL-calculus is the dependent type theory which generalizes both implications and quantifiers. In this paper, we describe the categorical semantics of the lL-calculus. This is given by Kripke resource models, which are monoid-indexed sets of functorial Kripke models, the monoid giving an account of resource consumption. We describe a class of concrete, set-theoretic models. The models are given by the category of families of sets, parametrized over a small monoidal category, in which the intuitionistic dependent function space is described in the established way, but the linear dependent function space is described using Day's tensor product.

A lambda-free logical framework takes parameterisation and definitions as the basic notions to provide schematic mechanisms for specification of type theories and their use in practice. The framework presented here, PAL + , is a logical framework for specification and implementation of type theories, such as Martin-Lof's type theory or UTT. As in Martin-Lof's logical framework [NPS90], computational rules can be introduced and are used to give meanings to the declared constants. However, PAL + only allows one to talk about the concepts that are intuitively in the object type theories: types and their objects, and families of types and families of objects of types. In particular, in PAL + , one cannot directly represent families of families of entities, which could be done in other logical frameworks by means of lambda abstraction. PAL + is in the spirit of de Bruijn's PAL for Automath [dB80]. Compared with PAL, PAL + allows one to represent parametric concepts such as famil...

The work reported in this thesis arises from the old idea, going back to the origins of constructive logic, that a proof is fundamentally a kind of program. If proofs can be

Abstract not found

Peter Aczel [1] and Gerard Huet [8] have implemented the category of sets in LEGO and Coq respectively. Here we show an implementation of the category of sets in ALF [2], a proof assistant based on Martin-Löf's logical framework (or theory of logical types) [10]. We used WINDOW ALF. This system allows one to manipulate the proof term in order to refine it until it is complete. Some facilities are provided which show the term in a readable way (special symbols for constants, infix use of symbols, hiding of arguments, etc). What is presented below is, unfortunately, not what is shown on the screen, but the source code for the type checker and the window interface. Thus, for instance, no arguments are hidden and lambda is used instead of . We refer to the introduction to the ALF chapter of the library for further information. We have essentially followed Peter Aczel's development. But we ha

This note is about work in progress on the topic of “internal type theory ” where we investigate the internal formalization of the categorical metatheory of constructive type theory in (an extension of) itself. The basic notion is that of a category with families, a categorical notion of model of dependent type theory. We discuss how to formalize the notion of category with families inside type theory and how to build initial categories with families. Initial categories with families will be term models which play the role of canonical syntax for dependent type theory. We also discuss the formalization of the result that categories with finite limits give rise to categories with families. This yields a type-theoretic perspective on Curien’s work on “substitution up to isomorphism”. Our formalization is being carried out in the proof assistant Agda 2 developed at Chalmers. 1

In type theory a proposition is represented by a type, the type of its proofs. As a consequence the equality relation on a certain type is represented by a binary family of types. Equality on a type may be conventional or inductive. Conventional equality means that one particular equivalence relation is singled out as the equality, while inductive equality, which we also call identity, is inductively defined as the "smallest reflexive relation". It is sometimes convenient to know that the type representing a proposition is collapsed in the sense that all its inhabitants are identical. Although uniqueness of identity proofs for an arbitrary type is not derivable inside type theory, there is a large class of types for which it may be proved. Our main result is a proof that any type with decidable identity has unique identity proofs. This result is convenient for proving that the class of types with decidable identities is closed under indexed sum. Our proof of the main result...