Formalizing Categorical Models of Type Theory in Type Theory - Master 2 Internship
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Master 2 Internship
ENS Cachan
Master Parisien
de Recherche en Informatique
Formalizing Categorical
Models of Type Theory
in Type Theory
Alexandre Buisse
Under the direction of Peter Dybjer
Chalmers Tekniska Högskola
Göteborg, Sverige
March - August 2007Contents
Contents 2
1 Fiche de synthèse 4
1.1 Le contexte général . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Le problème étudié . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 La contribution proposée . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Les arguments en faveur de sa validité . . . . . . . . . . . . . . . 5
1.5 Le bilan et les perspectives . . . . . . . . . . . . . . . . . . . . . 5
2 Version française 6
2.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.1 Catégories avec famille . . . . . . . . . . . . . . . . . . . . 6
2.1.2 Agda 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Formalisation des CwF . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1 Catégories . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.2 Setoı̈des . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.3 CwF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Des limites finies aux Familles . . . . . . . . . . . . . . . . . . . . 10
2.3.1 Idée de la transformation . . . . . . . . . . . . . . . . . . 10
2.3.2 Substitutions à isomorphisme près . . . . . . . . . . . . . 11
2.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3 Introduction 12
4 Prerequisites 14
4.1 Type Theory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.1.1 Simply Typed λ-calculus . . . . . . . . . . . . . . . . . . . 14
4.1.2 Martin-Löf’s Type Theory . . . . . . . . . . . . . . . . . . 15
4.2 The proof assistant Agda 2 . . . . . . . . . . . . . . . . . . . . . 15
4.3 Category Theory . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3.1 Main notions . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3.2 Cartesian Closed Categories vs simply typed λ-calculus . 20
5 Modeling CwF 21
5.1 CwF presentation . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2 Formalizing Fam . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.2.1 Formalizing a category . . . . . . . . . . . . . . . . . . . . 25
5.2.2 Setoids . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.3 The rest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.3.1 From Fam to CwF . . . . . . . . . . . . . . . . . . . . . . 27
5.3.2 Flat vs packed . . . . . . . . . . . . . . . . . . . . . . . . 28
26 From CwFL to CwF 30
6.1 The transformation . . . . . . . . . . . . . . . . . . . . . . . . . . 30
6.1.1 Finite limits in type theory . . . . . . . . . . . . . . . . . 30
6.1.2 Intuitions . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
6.1.3 The transformation . . . . . . . . . . . . . . . . . . . . . . 31
6.2 “Substitution up to isomorphism” . . . . . . . . . . . . . . . . . 33
7 Conclusion 34
References 35
Abstract
We investigate the possible formalization of categorical metatheory of con-
structive type theory in (an extension of) itself, using the notion of “in-
ternal type theory”. The model chosen is categories with families, which
model the most basic part of dependent type theory. We will discuss how
to formalize them inside type theory, and also how to formalize the proof
that categories with finite limits, another model of type theory, can be
seen as categories with families. Our formalization is carried out in the
proof assistant Agda 2, developed at Chalmers.
31. Fiche de synthèse
1.1 Le contexte général
Les mathématiques sont souvent utilisées comme un ensemble de méthodes per-
mettant l’étude de problèmes donnés, mais on peut également décider d’étudier
les mathématiques elles-mêmes comme objet de première classe. Pour ce faire,
il est nécessaire d’utiliser un langage, mathématique lui aussi, qui permet de
décrire les propriétés des objets étudiés. On parlera alors de métalangage.
Historiquement, le métalangage le plus utilisé est la théorie des ensembles,
notamment dans sa version dite de Zermelo-Fraenkel avec l’axiome du choix
(ZFC) et correspond aux mathématiques classiques. Mais des alternatives exis-
tent, notamment la théorie des types de Martin-Löf, métalangage constructif, et
suffisamment complet pour décrire d’importantes portions des mathématiques,
en utilisant au besoin des extensions.
Puisque cette théorie des types est elle aussi un objet mathématique rigou-
reusement défini, on peut l’étudier également. Se pose alors la question du
métalangage à utiliser pour ce faire. Et de manière surprenante, alors même que
toutes les méthodes utilisées apparaissent constructives, la théorie des ensembles
classique est presque toujours utilisée !
Nous allons ici nous attacher à montrer qu’on peut parler de théorie des types
dans un langage lui-même intrinsèquement constructif. Ce n’est pas une idée
nouvelle, puisque la première tentative remonte à Martin-Löf lui-même [ML75],
bien qu’il n’ait pas utilisé un métalangage formel.
1.2 Le problème étudié
A la différence de la plupart des tentatives précédentes de formalisation de la
théorie des types à l’intérieur de la théorie des types, nous n’avons pas utilisé
des modèles basés sur le λ-calcul mais sur la théorie des catégories. Notamment
les catégories avec familles (cwf), variation des catégories avec attributs de
Cartmell [Car86], mais aussi les catégories localement cartésiennes closes, dont
Seely a “prouvé”1 qu’elles étaient également des modèles de la théorie des types
dépendants [See84].
Nous avons donc dans un premier temps cherché à formaliser de manière con-
structive la notion de catégories avec familles, puis à montrer que les catégories
avec limites finies pouvaient être interprétées comme des catégories avec familles.
Puisque les catégories localement cartésiennes closes sont un cas particulier des
catégories avec limites finies, cette preuve est un premier pas vers une for-
malisation constructive de la preuve de Seely et de la solution apportée par
Curien [Cur93] au problème dit de “substitution à isomorphisme près”.
1 La preuve de Seely comportait une subtile erreur qui a été corrigée indépendamment par
Curien et Hofmann et dont l’étude constitue une importante partie du présent travail.
41.3 La contribution proposée
Le travail présenté ici est une extension de celui de Peter Dybjer dans son article
“Internal Type Theory” [Dyb96]. Nous avons utilisé l’assistant de preuve Agda
2, actuellement en développement à Chalmers [Nor07] pour les formalisations.
Bien qu’encore incomplètes, les principales difficultés ont été résolues. Afin
de formaliser les catégories avec familles, nous avons du passer par la catégorie
Fam dont la version constructive est basée sur des setoı̈des et non des ensembles.
Le résultat final est un type de données CwF.
De même, la preuve formelle que les catégories avec limites finies sont aussi
des catégories avec familles ne comporte pas, faute de temps, les parties liées à
l’extension de contexte, bien que la méthode à utiliser soit connue. Néanmoins,
les parties les plus intéressantes dans la perspective d’une modélisation de la
théorie des types ont été effectuées, et un éclairage nouveau a été apporté au
fameux problème de la substitution à isomorphisme près, auquel une solution
proche de celle de Pierre-Louis Curien [Cur93] a été apportée. Le résultat final
de la formalisation est un “compilateur” qui prend en entrée un objet de type
Catégorie à limites finies et en renvoit un de type CwF.
1.4 Les arguments en faveur de sa validité
Puisque tout a été formalisé à l’intérieur d’un assistant de preuves, nous avons
fait d’une pierre deux coup : d’une part, Agda 2 a servi de métalangage con-
structif, pouvant être considéré comme un langage de programmation fonction-
nel avec des types dépendants, et d’autre part, les preuves utilisées dans la
formalisation, et en particulier celles liées à la définition de la substitution dans
les types, ont été vérifiées par machine.
1.5 Le bilan et les perspectives
Bien que de manière encore incomplète, nous avons réussi à montrer qu’il était
tout à fait faisable d’interpréter la théorie des types à l’intérieur d’une extension
d’elle-même, et qu’il n’était pas nécessaire de recourir à des outils de logique
classique pour la définir. Plusieurs possibilités d’extension de ces résultats exis-
tent alors, notamment le rajout de structures supplémentaires à nos modèles afin
de les rendre plus puissants ou la (re)démonstration de résultats plus complexes
sur la théorie des types.
Notre travail a également permis de maturer un outil encore en développe-
ment, Agda 2, de résoudre quelques bugs et de confirmer qu’il ne s’agissait pas
d’un jouet mais bien d’un logiciel puissant et complet.
52. Version française
Ce rapport est écrit en anglais et non en français pour deux raisons :
d’une part, le stage a été effectué à l’étranger, en Suède, et mon
maı̂tre de stage, Peter Dybjer, n’est pas francophone. D’autre part,
ce rapport est en grande partie basé sur l’article que nous avons écrit,
en anglais, au cours du stage et qui a été accepté dans le workshop
LFMTP’07 [BD07] et sera publié dans ENTCS.
2.1 Définitions
2.1.1 Catégories avec famille
Le modèle de la théorie des types dépendants que nous allons utiliser dans
tout ce travail est la structure de catégorie avec familles (“categories with fam-
ilies”, abrégé ci-après en CwF ). Il s’agit d’une variation des catégories avec
attributs de Cartmell [Car86], mais où certaines notions, comme les termes ou
les substitutions, sont présentes de manière native et non définies a posteriori.
Les catégories avec familles sont également un modèle de la théorie des types
plus proches de la syntaxe, pouvant être définies comme une théorie algébrique
généralisée (GAT). Nous ne présenterons ici que la définition “catégorique”,
pour la version complète de la définition en tant que GAT, se reporter à la
section 5.1.
Définition 2.1.1 (Fam). Fam est la catégorie des familles d’ensembles in-
dexées par des ensembles, dont les objets sont des paires B = (B 0 , B 1 ) où B 0
est un ensemble et B 1 = Bb1 b∈B 0 une famille d’ensembles indexés par B 0 .
Un morphisme
entre B et C est une paire f = (f 0 , f 1 ) où f 0 : B 0 → C 0 et
f = fb b∈B 0 est une famille de morphismes fb1 : Bb1 → Cf10 (b) .
1 1
Définition 2.1.2 (Catégorie avec famille). Une catégorie avec famille est un
quadruplet:
• Une catégorie de base C. Ses objets sont appelés contextes et ses mor-
phismes substitutions.
• Un objet terminal < > de C, appelé le contexte vide.
• Un foncteur T : C op → Fam. Si Γ est un objet de C, on écrira
T (Γ) = T ype(Γ), T erm(Γ, A)A∈Type(Γ)
Si γ : Γ → ∆ est une substitution, T (γ) interprètera les substitutions dans
les types et les termes, notées respectivement A[γ] et a[γ].
• Une opération d’ extension de contexte ; qui construit un contexte Γ; A
à partir d’un contexte Γ et d’un élément A de T ype(Γ). Il existe alors
deux projections pΓ;A , substitution de Γ; A → Γ et qΓ;A , terme de Γ; A `
6A[pΓ;A ] tels que pour tout contexte ∆, substitution γ : ∆ → Γ et terme
a : ∆ ` A[γ], il existe un unique morphisme hγ, ai : ∆ → Γ; A tel que
pΓ;A:A[pΓ;A ] ◦ hγ, ai = γ et qΓ;A [hγ, ai] = a.
2.1.2 Agda 2
Tous nos travaux de formalisation ont été effectués avec l’assistant de preuves
Agda 2, actuellement en développement à Chalmers [Nor07]. Il s’agit d’une
implémentation du “Logical Framework” de Martin-Löf permettant l’ajout de
familles définies inductivement et de fonctions définies récursivement via pattern
matching. On peut également voir Agda 2 comme un langage de programmation
fonctionnel avec types dépendants, à la syntaxe proche de Haskell.
Outre les types dépendants, une différence notable avec Haskell concerne le
polymorphisme, qu’Agda 2 ne possède pas. On utilisera à la place une quantifi-
cation explicite sur les types. Ainsi, l’identité écrite id :: a → a en Haskell
deviendra id : (A : Set) → A → A en Agda ((x : A) → B désigne le type d’une
fonction prenant en entrée un élément x de type A et renvoyant un élément de
type B), que l’on pourra ensuite instancier avec n’importe quel type A, donnant
par exemple id bool : bool → bool.
Afin de ne pas surcharger les notations, on pourra utiliser le système d’argu-
ment implicite d’Agda, en ne spécifiant pas certains arguments que le système
pourra inférer seul depuis le contexte. Ainsi, dans l’exemple précédent, il suf-
fit d’examiner le type du deuxième argument d’id pour déduire la valeur du
premier, qu’on pourra donc omettre. Syntaxiquement, il faudra utiliser des ac-
colades en lieu et place des parenthèses dans la déclaration de type pour spécifier
qu’un argument est implicite.
Une autre notion importante en Agda 2 est celle d’enregistrement (record ),
qui correspond à une structure de donnée contenant des champs, lesquels peu-
vent être accédés indépendamment. Un exemple d’enregistrement qui nous sera
utile par la suite est la notion de relation d’équivalence :
record Equivalence (A : Set) : Set1 where
== : A → A → Set
ref l : {x : A} → x == x
sym : {x y : A} → x == y → y == x
trans : {x y z : A} → x == y → y == z → x == z
72.2 Formalisation des CwF
La première partie de notre travail a donc consisté à formaliser la structure des
CwF.
2.2.1 Catégories
Avant de s’attaquer à une structure complexe comme celle de catégorie avec
famille, on commencera par formaliser les “briques élémentaires”, à commencer
par la notion de catégorie, évidemment centrale.
On formalisera une catégorie comme un enregistrement dont les champs
seront non seulement les éléments de la catégorie (objets, morphismes...) mais
aussi les preuves que la catégorie est bien formée (par exemple que la loi de
composition est associative). Il est également important de noter que nous
avons suivi la littérature sur le sujet [HS95] et formalisé les morphismes entre
deux objets non par un ensemble, mais par un setoı̈de, afin de disposer d’une
égalité sur les flèches. Nous n’aurons par contre pas besoin d’égalité sur les
objets. Le résultat final est :
record Cat : Set2 where
Obj : Set1
−→ : Obj → Obj → Setoid
id : {A : Obj} → car(A −→ A)
◦ : {A B C : Obj} → car(B −→ C) → car(A −→ B) →
car(A −→ C)
...
idL : {A B : Obj} {f : A −→ B} → == (rel(A −→ B))
(id ◦ f ) f
...
car et rel sont les deux projections permettant d’accéder respectivement à
l’ensemble et à la relation d’un setoı̈de. Déclarer un opérateur encadré par des
permet de l’utiliser ensuite de manière infixe.
2.2.2 Setoı̈des
La principale difficulté dans la formalisation des CwF vient de la catégorie Fam.
En effet, une conséquence de notre formalisation des catégories est que nous ne
manipulons plus des familles d’ensembles indexées par des ensembles, mais des
familles de setoı̈des indexées par des setoı̈des, ce qui a de lourdes conséquences
formelles, puisqu’il faut systématiquement s’assurer de la cohérence de nos struc-
tures avec les relations d’équivalences transportées dans les setoı̈des.
Il nous faut commencer par définir la notion de morphisme de setoı̈de :
8record ⇒ (S1 S2 : Setoid) : Set where
map : |S1 | → |S2 |
stab : {x y : |S1 |} → x == y → (map x) == (map y)
On voit ici que l’on doit rajouter un champ stab pour s’assurer de la cohé-
rence du morphisme. On retrouve la même idée pour les familles de setoı̈des
indexées par des setoı̈des :
record SetoidF am (S : Setoid) : Set1 where
f ibre : |S| → Setoid
ι : {x x0 : |S|} → x == x0 → (f ibre x0 ) ⇒ (f ibre x)
idcoh : {x : |S|} → ι (ref l (rel S) {x}) ==⇒ id {f ibre x}
symcohL : {x y : |S|} → (p : x == y) →
ι (sym (rel S) {x} {y} p) ◦ (ι p) ==⇒ id
symcohR : ...
transcoh : {x y z : |S|} → (p : x == y) → (p0 : x == z) →
ι (trans (rel S) {x} {y} {z} p p0 ) ==⇒ (ι p) ◦ (ι p0 )
On doit rajouter une fonction de réindexation ι pour garder la cohérence avec
la relation du setoı̈de index, ainsi que plusieurs preuves que cette réindexation
est elle-même cohérente avec le fait qu’il s’agit d’une équivalence.
La dernière étape consiste à définir la notion de morphisme de familles de
setoı̈des indexées par des setoı̈des, puis à prouver toutes les propriétés habituelles
d’une catégorie, et ne sera pas détaillée ici.
2.2.3 CwF
Le reste des structures nécessaires à la définition des CwF, comme celles de
foncteur ou d’objet terminal ne posent pas de problème particulier. On arrive
alors à une formalisation des trois premiers composants d’une catégorie avec
famille. L’extension de contexte étant moins intéressante pour modéliser la
théorie des types, nous l’avons temporairement laissée de côté.
On peut aussi remarquer qu’il est possible d’“aplatir” nos structures (de la
même manière qu’on peut transformer une liste de listes en liste de manière
simple dans les langages fonctionnels), ce qui, dans le cas des CwF, donne un
ensemble de règles très proche du langage qu’on cherche à modéliser. C’est en
ce sens qu’on dit que les catégories avec famille sont proches de la syntaxe. Pour
cette raison, nous avons écrit deux versions du code : une “structurée”, et une
“aplatie”.
92.3 Des limites finies aux Familles
2.3.1 Idée de la transformation
Les catégories avec limites finies peuvent être définies comme ayant un objet
terminal et tous les pullbacks. Les catégories localement cartésiennes closes,
étudiées entre autres par Seely [See84], sont donc des cas particuliers de caté-
gories à limites finies, ce qui justifie notre étude.
L’idée de la transformation d’une catégorie à limite finie en CwF consiste à
considérer un contexte comme une chaı̂ne finie de morphismes, terminée par un
morphisme dont le codomaine est l’objet terminal. Un type est alors modélisé
par le premier morphisme de la chaı̂ne, et le contexte dans lequel il est bien défini
par le reste. Les termes, de manière usuelle, seront les sections des types (i.e.
les morphismes qui neutralisent le morphisme modélisant le type). Il devient
alors naturel de modéliser la substitution dans les types par un pullback, cette
opération revenant à faire une “translation” d’un morphisme.
Plus précisément :
• La catégorie de base reste la même, C
• T ype(Γ) est l’ensemble des objets de la catégorie-tranche C/Γ (i.e. l’en-
semble des morphismes de C à codomaine Γ)
• T erm(Γ, A) est l’ensemble des sections de A
• A[γ] est défini par le diagramme 1
• a[γ] est défini par un autre pullback non exposé ici
• Γ; A est le domaine du morphisme modélisant A
• Etc. . .
∆; σ[γ] / Γ; σ
σ[γ] σ
∆ /Γ
γ
Figure 1: Substitution dans les types
102.3.2 Substitutions à isomorphisme près
Dans l’article originel de Seely [See84], une subtile erreur était dissimulée dans
une transformation très similaire à celle que nous avons présentée. En effet, dans
la substitution dans les types, le choix de A[γ] est déjà fixé par la syntaxe, et rien
ne permet a priori de choisir le même pullback. Des solutions indépendantes
au problème, dit de “substitution à isomorphisme près”, ont été apportées par
Curien [Cur93] et Hofmann [Hof94], et notre solution est très proche de celle de
Curien : l’égalité des types est modélisée par l’isomorphisme entre deux objets,
et les CwF jouent le rôle de “langage interne”, suffisamment explicite pour éviter
les incohérences entre syntaxe et sémantique.
2.4 Conclusion
Il est important de noter que même si nous pensons en avoir résolu les principales
difficultés, aucune des deux formalisations n’est encore complète2 . Les compléter
est bien évidemment la première tâche à accomplir. D’autres voies de recherche
consistent à chercher à étendre ces modèles, notamment en rajoutant Π et Σ
types aux CwF. Enfin, on pourra s’intéresser à l’élément initial dans la catégorie
des CwF (à commencer par prouver qu’il existe) qui devrait consister en une
version inductive de toutes nos structures et paraı̂t particulièrement intéressant
dans le cadre de la modélisation de la théorie des types.
2 On pourra consulter la version actuelle du code dans le repository darcs suivant :
http://www.cs.chalmers.se/∼buisse/lfmtp07/
113. Introduction
Mathematics, while often used to reason about “external” objects, can also
be studied as a mathematical object itself, thus giving rise to “metamathe-
matics”. But in order to be able to talk about something and describe its
properties, we need a language. When it is used to discuss another language,
here the mathematics, we call it a metalanguage.
Most of the time, mathematics is studied informally, without specifying
explicitly which metalanguage is used. When the need to do so arises, however,
the most common choice is, by far, classical set theory, in its Zermelo-Fraenkel
with axiom of choice (ZFC) version. However, alternatives have been proposed
based on constructivism and intuitionist logic, and one of the most complete
is Martin-Löf’s Type Theory [NPS90], which plays the same role of a general
framework for constructive mathematics as ZFC does for classical mathematics.
But of course, type theory is also a well defined mathematical object, and as
such, can be studied. In fact, theoretical investigations of type theory are much
anterior to its use as a metalanguage,
It then would seem logical to use the type theoretic metalanguage to de-
scribe properties of type theory itself, if only to be certain to be constructive.
However, surprisingly enough, with a few exceptions, it is not yet the case, and
most metatheoretical investigations of type theory use classical set theory and
“features” like partial functions which do not exist in type theory. While most
of the time, those proofs are constructively valid, this is not ensured by the met-
alanguage, and can often lead to increased complexity when trying to formalize
them.
In this work, we are interested in using type theory as a metalanguage for
type theory itself, but it should be noted that this isn’t the first attempt.
Martin-Löf himself tried to build a constructive model of his theory [ML75],
though he wasn’t working with a formal metalanguage, unlike Pollack’s “Lego
in Lego” [Pol94] and Barras’ “Coq in Coq” [Bar99]. However, the main dif-
ference with our work is that we are not manipulating the “usual” λ-calculus
based model, but a categorical one.
Categories are algebraic structures with some properties that make them
good candidates for modeling computer science notions. For instance, cartesian
closed categories have long been known to be models of simply typed λ-calculus.
Choosing categories allows us to get a more abstract model, and thus a more
canonical formalization, which will depend less on arbitrary choices such as how
to encode variables or whether to make substitution explicit. For dependent
type theory, which forms the basis of Martin-Löf’s type theory, the model which
interests us, and which has historically been the first one to be presented, is
Cartmell’s categories with attributes [Car86], which is modified in categories
with families (cwf) [Dyb96] in order to provide something closer to syntax and
definable equationally, as a “generalized algebraic theory”, i.e. a many-sorted
algebraic theory with dependent types.
Here again, none of those ideas are new. Constructive formalizations of cat-
egories is a well-known subject, studied for instance by Huet and Saı̈bi [HS95].
12Likewise, categorical models of dependent type theory have been known for
decades [See84] [Hof96]. However, putting all those elements together and
making constructive formalizations, machine checked, of categorical models of
dependent type theory is something quite new: the only previous work that
has been made in this direction is Peter Dybjer’s paper “Internal Type The-
ory” [Dyb96] where a preliminary investigation and an attempt at formalization
of such categorical models had been made. We will here continue and extend
this work. Similar ideas are currently being worked on by Nils-Anders Daniels-
son [Dan07], who is also formalizing type theory in type theory, but doesn’t use
categorical models.
Finally, this work is also a test for the new proof assistant Agda 2, currently
developed by Ulf Norell at Chalmers [Nor07], which we used as the actual im-
plementation of Martin-Löf’s type theory: using type theory as a metalanguage
effectively became metaprogramming.
The first part of this work consists in formalizing the cwf model of dependent
type theory in Agda 2. The second part deals with categories with finite limits,
a simplified version of locally cartesian closed categories which have tight links
to semantics of dependent type theory, and we formally show that they can be
interpreted as cwfs. This is a constructive version of a proof first carried by Seely
[See84] and then corrected by Curien [Cur93] and Hofmann [Hof94]. We will
investigate the so-called “substitution up to isomorphism” problem, resulting
from a mismatch between syntax and semantics, and compare our solution with
the ones of Curien and Hofmann.
In section 4, we’ll quickly introduce some useful prerequisites and present some
notions of (dependent) type theory, category theory and the Agda 2 syntax.
In section 5, we will present the formalization of our model of type theory,
categories with families. Finally, in section 6, we’ll sketch the formalization of
the proof that categories with finite limits can be interpreted as categories with
families and discuss related issues.
134. Prerequisites
4.1 Type Theory
The central object of this work is type theory, and specifically its dependent
version as formulated by Martin-Löf. However, we will first present simply
typed λ-calculus, a more basic type system, which, though it hasn’t any direct
usefulness in the rest of the work, can be considered as a good introduction to
Martin-Löf’s type theory and also helps to understand how categorical struc-
tures (here “cartesian closed categories”, see subsection 4.3) can model type
systems.
4.1.1 Simply Typed λ-calculus
In simply typed λ-calculus, there are three kinds of objects: terms, types and
contexts. They are formed following the grammar:
M ::= x | λx.M | M N | (M, N ) | π1 (M ) | π2 (M )
σ ::= α | σ → τ | σ × τ
Γ ::= [ ] | x : σ, Γ
The usual syntactic conventions of λ-calculus (e.g. for grouping arrows or
applications) apply.
Once we have well-formed objects, we will want to make judgements of
the form “In the context Γ, the term M has type σ”, which is abbreviated in
Γ ` M : σ.
The typing rules for making those judgements are:
Γ, x : σ ` x : σ
Γ, x : σ ` M : τ
Γ ` λx.M : σ → τ
Γ ` M :σ → τ Γ ` N :σ
Γ ` MN :τ
Γ ` M :σ Γ ` N :τ
Γ ` (M, N ) : σ × τ
Γ ` M :σ × τ
Γ ` π1 (M ) : σ
Γ ` M :σ × τ
Γ ` π2 (M ) : τ
An important property of this system is that if Γ ` M : σ and M can be
β-reduced to M 0 , then Γ ` M 0 : σ.
144.1.2 Martin-Löf ’s Type Theory
The main difference between Martin-Löf’s type theory and simply-typed λ-
calculus that we just presented is that the former has dependent types, meaning
that when typing λx.M , the type of M can depend on x itself.
A basic example of a dependant type is Πn : N.V ecσ (x), the type of vectors
of elements of type σ and of fixed size n. Its two constructors are nil : V ecσ (0)
and cons : Πn : N . σ → V ecσ (n) → V ecσ (succ(n)). We can then define a head
function whose type ensures that it will never raise an exception: hd : Πn :
N . V ecσ (succ(n)) → σ.
We will present a λ-calculus with dependent types, which is the core of Martin-
Löf’s type theory but is already complex enough for our study.
The grammar is now:
M ::= x | λx.M | M N | (M, N ) | π1 (M ) | π2 (M )
σ ::= α | Πx : σ.τ | Σx : σ.τ
Γ ::= [ ] | x : σ, Γ
Πx : σ.τ corresponds to a dependent version of σ → τ , but where τ can also
depend on x. Likewise, Σ types are a dependent version of product types.
The typing rules now become:
Γ, x : σ ` x : σ
Γ, x : σ ` M : τ
Γ ` λx.M : Πx : σ.τ
Γ ` M : Πx : σ.τ Γ ` N :σ
Γ ` M N : τ [N/x]
Γ`M :σ Γ ` N : τ [M/x]
Γ ` (M, N ) : Σx : σ.τ
Γ ` M : Σx : σ.τ
Γ ` π1 (M ) : σ
Γ ` M : Σx : σ.τ
Γ ` π2 (M ) : τ [π1 (M )/x]
4.2 The proof assistant Agda 2
We will use the proof assistant Agda 2 for formalizing our developments. Agda 2
is an implementation of Martin-Löf’s logical framework with support for adding
new inductively defined sets and recursively defined functions using pattern
matching. It is thus suitable for implementing various fragments of Martin-Löf
15type theory. It can also be viewed as a dependently typed programming lan-
guage. Its syntax is quite close to Haskell. The main difference to Haskell (and
other standard functional languages such as OCAML) is that it has dependent
types. It is important to point out that Agda does not itself force the user
to define only well-founded data types and terminating functions, although at
a later stage such termination and well-foundedness checkers will be available.
Currently it is up to the user to make sure that a specific logical discipline is
followed and to explain and justify this discipline.
If we remove Agda’s dependent types, we get a language rather close to
Haskell. However, Agda doesn’t have the implicit Hindley-Milner polymorphism
of Haskell. In Haskell we have for example the polymorphic identity function
id :: a -> a
stating that for any type a we have an identity funciton on it. In Agda we have
to explicitly quantify over the type Set of small types. We write
id : (A : Set) → A → A
which means that for any small type A we have an identity function id A : A →
A. (In general Agda uses the notation (x : α) → β for the type of functions
which map an object x of type α into a result in β, where the result type β
may depend on x. This is equivalent to the Πx : α.β notation of the previous
section). This is why one says that Agda is an implementation of Martin-Löf’s
monomorphic type theory: id has a unique type.
However, working directly in monomorphic type theory is cumbersome since
one has to manipulate large expressions. Therefore Agda make it possible to
suppress certain arguments when they can be inferred from the context. We call
such arguments implicit. For example, whenever the function id gets a second
argument a, Agda tries to infer the first argument A, which is the type of a. The
user can inform Agda that the first argument of id is such an implicit argument
by enclosing it in braces:
id : {A : Set} → A → A
Thus, during type-checking of an expression id a the system will know that a is
the second argument and try to infer the first argument.
Sometimes a user may want to give an implicit argument explicitly, for ex-
ample, in situations where the system cannot infer it. Such explicit implicit
arguments are enclosed in braces. For example, in
id {Bool} : Bool → Bool
the user has made the first argument Bool explicit.
A fairly new construction in Agda 2 is the notion of record, which is a data
structure containing some fields. To instantiate it, one needs to instantiate all
the fields. The way to access the fields of a record is not completely intuitive,
because a record really is a module, and thus the field x of a record r of type
16R should be accessed with the syntax R.A x: declaring the record type R
automatically creates a module with the same name and one projection function
for each field, which take as their first argument a structure of type R.
An example of record is the notion of equivalence relation, which spells out
that it is a quadruple parametered by a set A consisting of a binary relation on
A and proofs that this relation is reflexive, symmetric and transitive:
record Equivalence (A : Set) : Set1 where
== : A → A → Set
ref l : {x : A} → x == x
sym : {x y : A} → x == y → y == x
trans : {x y z : A} → x == y → y == z → x == z
And it is now easy to define what a setoid is:
record Setoid : Set1 where
car : Set
rel : Equivalence car
4.3 Category Theory
4.3.1 Main notions
A category can be seen as a way to abstract mathematical structures which pro-
vides some sort of general framework for abstract mathematical constructions.
Definition 4.3.1 (Category). A category C consists of:
• A collection |C| of objects.
• For all elements A, B of |C|, a collection Hom(A, B) of arrows, or mor-
phisms from A to B. If f ∈ Hom(A, B), we usually note f : A → B or
f
A → B. A is called domain and B codomain of f .
• For all objects A, there is an identity arrow idA : A → A.
• For all objects A, B, C, for all arrows f : A → B, g : B → C, there is a
composite arrow g ◦ f : A → C.
We also require the following two conditions to hold:
• Neutrality: For all objects A, B, for all arrows f : A → B, f ◦ idA = f =
idB ◦ f .
17f g h
• Associativity: For all A → B → C → D, h ◦ (g ◦ h) = (h ◦ g) ◦ f .
An elementary and intuitive example of category is Set, the category where
objects are sets and arrows are total functions between those sets. Identity and
composition have their usual meaning.
Another important notion is the one of functor, which is a mapping between
two categories that preserves their structure:
Definition 4.3.2 (Functor). If A and B are two categories, a functor F from
A to B consists of two elements:
• For all X ∈ |A|, there is an object F (X) of |B|.
• For all g : X → Y in A, there is an arrow F (g) : F (X) → F (Y ) in B.
For F to be well defined, we also require that:
• F (idA ) = idF (A)
• F (g ◦ h) = F (g) ◦ F (h).
Definition 4.3.3 (Terminal object). A category C is said to have a terminal
object iff there is an object 1 such that for all object A of C, there is a unique
arrow from A to 1.
Definition 4.3.4 (Product). We say that a category has all products if for any
two objects A and B, there is an object A × B and two arrows π1 : A × B → A
and π2 : A × B → B. Moreover, whenever there is an object C and arrows
f : C → A and g : C → B, we can find a unique arrow h : C → A × B such
that the following diagram commutes:
AO gOOO
OOO
OOO
OOO
OOO f
OOO
π1
OOO
OOO
OOO
OOO
O
A×B _
o _ _ _ _ _ h_ _ _ _ _ _ _
oo C
ooooo
oo
ooooo
ooo
ooo g
π2
o o
oo
ooo
woooo
B
18Category theory has many so-called universal constructions. One which will
be particularly important to us is that of pullback :
Definition 4.3.5 (Pullback). In the following diagram,
A0/ @TTTT
// @ TTTTT
// @ TTTT
TTTT
// @ h TTTTh2
// @ TTTT
// @ TTTT
@ TTTT
// @ TTTT
// @ TTTT
f TT*
// A /B
h1 /
//
//
//
// g g0
//
//
f0
C /D
the inner square is said to be a pullback if it commutes and for any object
A0 and arrows h1 : A0 → C, h2 : A0 → B such that g 0 ◦ h2 = f 0 ◦ h1 , there is
a unique arrow h : A0 → A such that the two upper triangles commute (that is
h1 = g ◦ h and h2 = f ◦ h).
In other words, A is unique up to isomorphism.
Definition 4.3.6 (Category with pullbacks). We say that a category has all
pullbacks if for all diagrams
B
C /D
There is an object A and two arrows A → B and A → C such that the square
created with those four objects is a pullback.
Definition 4.3.7 (Finite Limits). A category C is said to have finite limits if:
• C has a terminal object.
• C has all pullbacks.
Another categorical structure of importance to us is that of slice category,
which builds a new category from just an object:
19Definition 4.3.8 (Slice Category). Let C be a category and A ∈ |C|. The slice
category C/A is defined by:
• Its objects are morphisms f : B → A where B is an object of C.
• Its arrows from f : B → A to f 0 : B 0 → A are C-arrows h : B → B 0 such
that f 0 ◦ h = f .
• Composition of h : f → f 0 and h0 : f 0 → f 00 is usual C-composition, h0 ◦ h.
• Likewise, identity arrow of f : B → A is idB : B → B.
4.3.2 Cartesian Closed Categories vs simply typed λ-calculus
While Cartesian Closed Categories are not the main subject here and won’t
be used directly anywhere, presenting them and explaining quickly their link
to simply typed λ-calculus is useful to get intuitions about how categorical
structures can model type theories.
Definition 4.3.9 (Cartesian Closed Category). We say that a category C is
cartesian closed iff:
• It has a terminal object 1.
• It has all products
• It has exponential objects ( i.e. for all objects A and B, there is an object
B A and an arrow eval : B A ×A → B such that for every arrow f : C×A →
B, there is a unique arrow λf : C → B A such that eval ◦ (λf × A) = f .
For a more complete definition, please refer to Barr and Wells [BW95]).
Given a simply-typed λ-calculus L, we can then define a model category
C(L) by the following transformation:
• The objects of C(L) are the types of L.
• An arrow from A to B is the equivalence class of terms of type B with
one free variable of type A.
• σ × τ will be modeled by the product of the interpretation of σ and of τ .
• σ → τ will be modeled by the exponential object of the interpretations of
σ and τ .
• etc. . .
A complete proof that C(L) is indeed cartesian closed can be found in Lam-
bek and Scott’s book [LS86]. Interestingly, the reverse result also holds: a carte-
sian closed category possesses an internal language which is a typed λ-calculus,
and the internal language of C(L) is categorically equivalent to L.
205. Modeling CwF
5.1 CwF presentation
Categories with Families (hereafter shortened to cwf) are a categorical model
of dependent type theory closely related to Cartmell’s categories with attributes
but closer to the syntax.
Definition 5.1.1 (Fam). Fam is the category of families, which has as objects
pairs B = (B 0 , B 1 ) where B 0 is a set and (Bb1 )b∈B 0 is a family of sets indexed
over B 0 . A morphism from B to C = (C 0 , C 1 ) is a pair (f 0 , f 1 ) where f 0 :
B 0 → C 0 and f 1 = (fb1 )b∈B 0 is a family of functions fb1 : Bb1 → Cf10 (b) .
We can now define CwF themselves:
Definition 5.1.2 (Category with Families). A Category with Families is a
quadruple:
• A base category C. Its objects are called contexts and its morphisms sub-
stitutions.
• A terminal object of C, called the empty context.
• A functor T : C op → Fam. If Γ is an object of C, we write
T (Γ) = T ype(Γ), T erms(Γ, A)A∈T ype(Γ)
If γ : Γ → ∆ is a substitution in C, T (γ) will interpret substitution in
types and terms. We will note the application of its first component to a
type A as A[γ] and the application of its second component to a term a as
a[γ].
• A context comprehension operation, which to a context Γ of C and a type
A of T ype(Γ) associates a context Γ; A of C together with a substitution
p Γ,A : Γ; A → Γ, called the first projection or sometimes display maps
and a term q Γ,A of T erms(Γ; A, A [p Γ,A ]) such that for every context ∆,
substitution γ : ∆ → Γ and term a : ∆ ` A[γ], there is a unique morphism
hγ, ai : ∆ → Γ; A with the property that p Γ;A,A[p Γ,A ] ◦ hγ, ai = γ and
q Γ,A [hγ, ai] = a.
N.B. 1. It can seem puzzling at first that T is from C op (the dual of C, i.e. C
with all arrows reversed) rather than directly from C.
This can be explained by looking at the “real” context substitutions in type
theory, which we want to model here: let’s consider a context as a sequence
21x1 : A1 , . . . , xn : An where the xi are variables and the Ai types. A term in this
context is a term with its free variables amongst x1 , . . . xn . A substitution γ :
Γ → ∆ is then a tuple of terms (M1 , . . . , Mn ) such that the following properties
hold:
Γ ` M 1 : A1
Γ ` M2 : A2 [M1 /x1 ]
...
Γ ` Mn : An [M1 /x1 ][M2 /x2 ] . . . [Mn−1 /xn−1 ]
Then, if a : ∆ ` A, a[γ] will be a where every occurence of xi is replaced by Mi ,
thus a[γ] : Γ ` A[γ], which explains why T (γ) is best interpreted by a morphism
from T (∆) to T (Γ).
Categories with Families are very close to Cartmell’s categories with at-
tributes. The main difference comes from the fact that many notions such as
terms or substitutions are not natively present in categories with attributes but
rather defined afterwards and shown equivalent to some constructions.
A basic example of a cwf is obtained by letting C = Set, the category of
small sets, T ype(Γ) be the set of Γ-indexed small sets, and
Y
Γ`A = A(x)
x∈Γ
A[δ](x) = A(δ(x))
a[δ](x) = a(δ(x))
[] = 1
X
Γ; A = A(x)
x∈Γ
Definition 5.1.3. Let (C, T ) denote a cwf with base category C and functor
T . A morphism of cwfs with source (C, T ) and target (C 0 , T 0 ) is a pair (F, σ),
where F : C → C 0 is a functor and σ : T → T 0 F is a natural transformation,
such that terminal object and context comprehension are preserved on the nose.
Small cwfs and morphisms of cwfs form a category Cwf .
As already mentioned the notion of a category with families can be formal-
ized as a generalized algebraic theory in the sense of Cartmell [Car86].
Generalized algebraic theories generalize many-sorted algebraic theories and
are based on a framework of dependent types.
They have four parts:
• A list of sort symbols with dependent typings.
• A list of operator symbols with dependent typings.
• A list of equations between well-formed sort expressions (not needed here).
22• A list of equations between well-formed terms.
We present sort and operator symbols by their typing rules. As before, we
use polymorphic notation and write δ ◦ γ instead of the proper δ ◦Θ,∆,Γ γ, etc.
(Also write equations without types, although in the official syntax there should
be types.) Sort symbols:
Ctxt sort
∆, Γ : Ctxt
∆ → Γ sort
Operator symbols:
Θ, ∆, Γ : Ctxt γ:∆→Γ δ:Θ→∆
γ◦δ :Θ→Γ
Γ : Ctxt
idΓ : Γ → Γ
Equations:
(γ ◦ δ) ◦ θ = γ ◦ (δ ◦ θ)
idΓ ◦ γ = γ
γ ◦ idΓ = γ
Rules for the functor T
Sort symbols:
Γ : Ctxt
Ty(Γ) sort
Γ : Ctxt A : Ty(Γ)
Γ ` A sort
Operator symbols:
∆, Γ : Ctxt A : Ty(Γ) γ:∆→Γ
A[γ] : Ty(∆)
∆, Γ : Ctxt A : Ty(Γ) a : Γ ` A γ:∆→Γ
a[γ] : ∆ ` A[γ]
Equations:
A[γ ◦ δ] = A[γ][δ]
A[idΓ ] = A
a[γ ◦ δ] = a[γ][δ]
a[idΓ ] = a
23Rules for the terminal object
Operator symbols:
[ ] : Ctxt
Γ : Ctxt
hiΓ : Γ → [ ]
Equations
hiΓ ◦ γ = hiΓ
id[ ] = hi[ ]
Rules for context comprehension
Operator symbols:
Γ : Ctxt A : Ty(Γ)
Γ; A : Ctxt
∆, Γ : Ctxt A : Ty(Γ) γ : ∆ → Γ a : ∆ ` A[γ]
hγ, ai : ∆ → Γ; A
Γ : Ctxt A : Ty(Γ)
pΓ,A : Γ; A → Γ
Γ : Ctxt A : Ty(Γ)
qΓ,A : Γ; A ` A[pΓ,A ]
Equations:
pΓ,A ◦ hγ, ai = γ
qΓ,A [hγ, ai] = a
hδ, ai ◦ γ = hδ ◦ γ, a[γ]i
idΓ;A = hpΓ,A , qΓ,A i
This completes the description of the generalized algebraic theory of cwfs.
Note the correspondence between sort symbols and judgement forms and be-
tween operator symbols and inference rules of a substitution calculus for de-
pendent types. But note also that there are no sort symbols which correspond
to equality judgements and no operator symbols which correspond to general
equality rules. Instead general equality reasoning is inherited from the meta-
language.
245.2 Formalizing Fam
We will follow the recipe for formalizing categories with families in type theory
(internal cwfs) described in Dybjer [Dyb96]. It is well-known how to formalize
basic categorical notions such as category, functor, natural transformation, etc
[HS95] in type theory. It is also well-known how to formalize the type-theoretic
analogue of the category of sets in type theory. The objects of this category
are setoids (or E-sets) that is sets with equivalence relations. The arrows are
functions respecting equivalence relations.
The crucial issue for the formalization of cwfs is the formalization of the
category Fam, and we follow the approach in the paper Internal Type The-
ory [Dyb96].
Once we have defined the category Fam it is straightforward to formalize
the rest of the cwf-structure in type theory. Note that if a cwf is formally
represented as a quadruple consisting of the base category, the family valued
functor, the terminal object, and context comprehension, where each of these
components itself is a tuple, we can “flatten” this structure into a tuple where
each component corresponds to a rule in a substitution calculus for type theory.
This calculus is closely related to the calculus of explicit substitutions used by
Curien [Cur93]. Like this calculus there is an explicit construction for the type
conversion rule [Dyb96]. We can thus see how the type-theoretic perspective
gives a rational reconstruction of Curien’s calculus.
5.2.1 Formalizing a category
A category in type theory consists of a set of objects, hom-setoids for each pair
of objects, an identity arrow for each object, composition respecting equivalence
of the arrows in the hom-setoids, and proofs of the identity and associativity
laws. (Note that we have explicit proof objects for each law.)
open Setoid
record Cat : Set2 where
Obj : Set1
−→ : Obj → Obj → Setoid
id : {A : Obj} → car(A −→ A)
◦ : {A B C : Obj} → car(B −→ C) → car(A −→ B) →
car(A −→ C)
...
idL : {A B : Obj} {f : A −→ B} → == (rel(A −→ B))
(id ◦ f ) f
...
25We have chosen to formalize a notion of locally small category where hom-setoids
must be “small” (the carrier is a set), but an object can be “large” (a member
of the universe Set1 of large sets). Examples of such locally small categories is
the category Set of setoids and the category Fam of setoid-indexed families of
setoids. Note also the type of locally small categories is “very large” (a member
of a second universe Set2 of very large sets).
5.2.2 Setoids
To define the Fam category, we will need the notion of setoid-indexed family
of setoids, and of morphism between those (resp. objects and arrows of Fam).
We have seen in section 4.2 how to define a setoid as a record. The next step is
to define what a setoid morphism is:
record ⇒ (S1 S2 : Setoid) : Set where
map : |S1 | → |S2 |
stab : {x y : |S1 |} → x == 3 y → (map x) == (map y)
Identity and composition of setoid morphisms are easy to add. For instance,
id : {S : Setoid} → S ⇒ S
id = record {map = \x → x ; stab = \p → p}
We also add an extensional equality ==⇒ :
==⇒ : {S1 S2 : Setoid} → S1 ⇒ S2 → S1 ⇒ S2 → Set
F1 ==⇒ F2 = (forall x → (map F1 x) ==⇒ (map F2 x)) → T rue
We are now ready to define what a setoid indexed family of setoids is: a
fibre map that indexes setoids by elements of the carrier of the indexing setoid,
a reindexing function ι that maps the equivalence relation of the indexing setoid
into the indexed setoids and proofs that this reindexing function is coherent with
the fact that the relation is an equivalence.
3 Here we redefined == with the type {S : Setoid} → Equivalence. == (rel S)
26record SetoidF am (S : Setoid) : Set1 where
f ibre : |S| → Setoid
ι : {x x0 : |S|} → x == x0 → (f ibre x0 ) ⇒ (f ibre x)
idcoh : {x : |S|} → ι (ref l (rel S) {x}) ==⇒ id {f ibre x}
symcohL : {x y : |S|} → (p : x == y) →
ι (sym (rel S) {x} {y} p) ◦ (ι p) ==⇒ id
symcohR : ...
transcoh : {x y z : |S|} → (p : x == y) → (p0 : x == z) →
ι (trans (rel S) {x} {y} {z} p p0 ) ==⇒ (ι p) ◦ (ι p0 )
The last important step is to define what a morphism between objects of
type SetoidF am is. There will be one map for each component: the indexing
setoid, the fibre map and the reindexing function:
record =⇒ {S1 S2 : Setoid} (F1 : SetoidF am S1 )
(F2 : SetoidF am S2 ) : Set1 where
indexmap : S1 ⇒ S2
f ibremap : (x : |S1 |) →
(f ibre F1 x) ⇒ (f ibre F2 ((map indexmap x))
ιmap : {x x0 : |S1 |} → (p : x == x0 ) →
((f ibremap x) ◦ (ι F1 p)) ==⇒
(ι F2 (stab indexmap p)) ◦ (f ibremap x0 )
This can be represented as in the figure 2, with the ιmap part being a proof
that the upper part forms a commutative diagram.
The rest of the properties needed for Fam to be a category are then straight-
forward, though particularily tedious.
5.3 The rest
5.3.1 From Fam to CwF
As in the classical definition a cwf inside type theory is a quadruple consisting
of a base category C, a functor T : C op → Fam, a terminal object of C, and
a context comprehension. Above we have outlined the type theoretic definition
of a category and of the category Fam. The type-theoretic understanding of
the notion of a functor is well-known. Furthermore, it is clear what a terminal
object is type-theoretically, and there is no difficulty in expressing the structure
27f ibremap(f ibre x)
f ibremap(f ibre x0 )
ιp
f ibre x f ibre x0
p indexmap
x x0
Figure 2: Representation of F1 =⇒ F2
of context comprehension type-theoretically. All this leads to the definition of
cwf inside type theory (i.e. the notion of internal cwf), although we do not have
room to display the details.
The notion of internal cwf can be formalized as a record (iterated Σ-type)
assuming only the axioms of a version of Martin-Löf’s logical framework with
Σ-types. (This is modelled categorically by cwfs with a universe, Π-types, and
Σ-types). (If we want to express the type of locally small categories (and locally
small cwf) internally we also need a second universe Set2 . For the purpose of
formalizing the notion of small category (and cwf) one universe suffices.)
The notion of cwf just models the most basic structure of dependent types:
context and variable formation, substitution in types and terms. Therefore we
usually want to work with cwfs with extra structure corresponding to adding
type formers (Π, Σ, universes, natural numbers, etc) to dependent type theory.
This does not give rise to any further formalization problems. See the Internal
Type Theory paper [Dyb96] for further explanation.
5.3.2 Flat vs packed
So far, we have defined the CwF as a record, where each component itself is a
record, whose elements are possibly new records, and so on. For example, the
28first component of a CwF is a category, of which one component (Hom) is a
setoid, itself a record.
An interesting transformation is to “flatten” all those nested structures into
a single record, in the same way that we can flatten a list of lists of lists into a
list by a standard function in functional programming.
While packed versions are easier to work with, being of “higher level”, cwfs,
if flattened, look exactly like inference rules to the dependent type theory that
they model.
For this reason, we have chosen to develop both versions in parallel, writing
the proofs first for the packed version and then backporting them to the flat
one.
296. From CwFL to CwF
6.1 The transformation
Locally cartesian closed categories (LCCC) have been “proven” by Seely [See84]
to be models of dependent type theory. Curien [Cur93] and Hofmann [Hof94]
have later proposed solutions to a subtle flaw in Seely’s solution, the so-called
“substitution up to isomorphism” problem, which arises from a mismatch be-
tween syntax and semantics in the interpretation.
We will here outline the proof inside type theory that categories with finite
limits, a structure closely related to LCCC, are cwfs. This proof will help us
understand how cwfs relate to standard ideas in categorical type theory: why
types can be modelled as projection arrows, why terms can be modelled as sec-
tions of these projections, and why substitution in types can be modelled by
pullbacks. We will then discuss the type-theoretic perspective on the problem
of “substitution up to isomorphism” and show the similarity with Curien’s ap-
proach. We will also contrast it to Hofmann’s, who used standard categorical
notions assuming set-theoretic metalanguage.
6.1.1 Finite limits in type theory
Categories with finite limits can be formalized as categories with terminal ob-
jects and pullback (officially, this relies on the fact that a category with terminal
objects and pullbacks has all finite limits). As a type-theoretic structure a pull-
back is a function that given three objects and two arrows constructs an object,
two arrows, proofs of commutativity of the square, and a proof of the universal
property. Here is the formalization in Agda:
record IsP ull {A B C D : Obj}(f : A −→ B)(g : A −→ C)
(f 0 : C −→ D)(g 0 : B −→ D)
(square : g 0 ◦ f == f 0 ◦ g) : Set1 where
h : (A0 : Obj)(h1 : A0 −→ C)(h2 : A0 −→ B)
(triangle : f 0 ◦ h1 == g 0 ◦ h2 ) → ∃ ! \(h : A0 −→ A)
→ (g ◦ h == h1 ) ∧ (f ◦ h == h2 )
record P ullback {B C D : Obj}
(g 0 : B −→ D)(f 0 : C −→ D) : Set1 where
A : Obj
f : A −→ B
g : A −→ C
square : g 0 ◦ f == f 0 ◦ g
pull : isP ull f g f 0 g 0 square
30record P ullCat : Set2 where
pullprop : {B C D : Obj}(g 0 : B −→ D)(f 0 : C −→ D)
→ pullback g 0 f 0
Likewise, terminal objects will be formalized by an object T and a function
which, given an object A, will return an arrow A → T and a proof that this
arrow is unique.
6.1.2 Intuitions
The idea of interpreting dependent type theory in categories with finite limits
(and a fortiori in LCCC) is to model contexts as a sequence of composable
arrows which ends in the terminal object. Such sequences will then be decom-
posed in their first arrow modeling some type σ and the rest of the sequence
modeling the context Γ under which σ is well-defined as a type. Extending
this construction, we get that if a context Γ is modeled by an object A, then
T ype(Γ) is modeled by the collection of arrows with codomain A, and if σ is such
a type, then the domain of the arrow modeling it corresponds to the context
comprehension A; σ.
For modeling the effect of a substitution γ : ∆ → Γ on a type σ in Γ, we
will want to “translate” the arrow Γ; σ → Γ along γ, and this is exactly what
pullbacks do. The idea of Seely’s transformation is to say that σ[γ] is the left
arrow of the pullback of σ along γ:
∆; σ[γ] / Γ; σ
σ[γ] σ
∆ /Γ
γ
Figure 3: Type substitution
However, this does not really work, since the interpretation of σ[γ] is already
fixed by the syntax, and nothing allows us to prove that it is the chosen pullback
arrow. Since pullbacks are only defined up to isomorphism, the best solution we
can come up with is that there is an isomorphism between the syntactic (direct)
and semantic (through the pullback construction) versions of σ[γ], which is not
enough. This is the problem to which Curien [Cur93] and Hofmann [Hof94]
have proposed solutions, which we will detail and contrast to our in section 6.2.
6.1.3 The transformation
We get the cwf structure from a category with finite limits following the intu-
itions of the previous section:
31Vous pouvez aussi lire
