10.6092/issn.1972-5787/1695
This work is about formalizing  models of various type theories of the Calculus  of Constructions family.  Here we  focus on  set theoretical models. The long-term goal is  to build a formal set theoretical model of the Calculus of Inductive Constructions, so we can be sure that Coq is consistent with the language used by most mathematicians.

One  aspect of this  work is  to axiomatize  several set  theories: ZF possibly  with   inaccessible  cardinals,   and  HF,  the   theory  of hereditarily finite sets. On top  of these theories we have developped a  piece  of the  usual  set  theoretical  construction of  functions, ordinals and fixpoint  theory. We then proved sound  several models of the  Calculus  of  Constructions,   its  extension  with  an  infinite hierarchy of universes,  and its extension with the  inductive type of natural  numbers where  recursion follows  the  type-based termination approach.

The  other   aspect  is   to  try  and   discharge  (most   of)  these assumptions.  The  goal here  is  rather  to  compare the  theoretical strengths of  all these formalisms. As already noticed by  Werner, the replacement  axiom  of ZF  in  its general  form  seems  to require  a type-theoretical  axiom  of  choice   (TTAC).
application/pdf
1972-5787
1695
1
en
Bruno Barras
Journal of Formalized Reasoning
Sets in Coq, Coq in Sets
Text.Serial.Journal
https://jfr.unibo.it/
3
Articles
2010-10-06
2009-12-14
2010-04-14
2016-01-29
29-48
JFR
Bruno Barras
2010/10/06
10.6092/issn.1972-5787/1695
29
INRIA Saclay - France
1972-5787
1
en
48
Sets in Coq, Coq in Sets
https://jfr.unibo.it/article/download/1695/1316
3
Sets in Coq, Coq in Sets
Bruno Barras
bruno.barras@inria.fr
INRIA Saclay - Île de France
4, rue Jacques Monod
91893 ORSAY Cedex - France


This work is about formalizing models of various type theories of the Calculus of Constructions
family. Here we focus on set theoretical models. The long-term goal is to build a formal set
theoretical model of the Calculus of Inductive Constructions, so we can be sure that Coq is
consistent with the language used by most mathematicians.
   One aspect of this work is to axiomatize several set theories: ZF possibly with inaccessible car-
dinals, and HF, the theory of hereditarily finite sets. On top of these theories we have developed a
piece of the usual set theoretical construction of functions, ordinals and fixpoint theory. We then
proved sound several models of the Calculus of Constructions, its extension with an infinite hier-
archy of universes, and its extension with the inductive type of natural numbers where recursion
follows the type-based termination approach.
   The other aspect is to try and discharge (most of) these assumptions. The goal here is rather
to compare the theoretical strengths of all these formalisms. As already noticed by Werner, the
replacement axiom of ZF in its general form seems to require a type-theoretical axiom of choice.




   The title of this article refers to Werner’s “Set in Types, Types in Sets” [19]. Our
initial goal was to formally build a model of the Calculus of Inductive Constructions
(CIC), the formalism of Coq. In [6], we formalized the syntactic metatheory of CIC
and type-checking algorithms, under the assumption that our presentation enjoys
the strong normalization property, which is the non-elementary step in proving the
consistency of CIC.
   The present work can be viewed as a first step towards the formalization of the
semantics of CIC, concluding to strong normalization and consistency. Of course,
due to Gödel’s second incompleteness theorem, this can be fulfilled only under some
assumptions that strengthen Coq’s theory (unless the formalism is inconsistent).
This approach is similar to Harrison’s work about verifying HOL Light [13].
   It is well-known that the Calculus of Constructions (CC, [7]) admits a proof-
irrelevant and classical model where all types are finite. The only requirement on
such a model is to include booleans and to be closed by arrow type (non-dependent
product). No infinite set is involved so we should be able to build a model of CC
in the theory of hereditarily finite sets. However simple this description may seem,
actually building a model for the common presentation of CC reveals technical
traps as illustrated by Miquel and Werner in [16]. The focus will be on the product
fragment and on universes of CIC. A complete formalization of inductive types
requires a lot of work. However, to show that our model construction can cope
with inductive types, we have built a simple, yet recursive, inductive type: Peano’s
natural numbers. We have adopted a systematic approach and departed from the
usual representation of natural numbers (ordinal ω).

                                         Journal of Formalized Reasoning Vol. 3, No. 1, 2010 Pages 29–48.
30       ·     Bruno Barras

   The formal definitions of this article1 can be organized in three categories: (1)
developing a Coq library of common set theoretical notions and facts about pairs,
functions, ordinals, transfinite recursion, Grothendieck universes, etc. (the Sets in
Coq side), (2) building specific ingredients for models of typed λ-calculi, and (3)
building set theoretical models of those theories within Coq (both fall into the Coq
in Sets side).

1.      HEREDITARILY FINITE DECIDABLE SETS
This is the Vω set: the set obtained by applying ω times the powerset operation on
the empty set. All the basic operations are decidable, so there is no distinction be-
tween intuitionistic and classical variants. The type of hereditarily finite decidable
sets can be defined as the type of well-founded, finitely branching trees:
Inductive hf : Set := HF (elts : list hf).
   Of course, here we use lists for commodity, but order and repetition of elements
in the list is not relevant. We thus need to express the equality as a setoid, in order
to have rewriting reasoning on sets. We will use the let (xl) := x in ... idiom
(destructing let) to get the list of elements of x.
  Equality and membership. These two notions are mutually recursive: two set are
equal if they contain the same elements, and a set is a member of another set if
the latter contains an element that is equal to the former. This informal definition
cannot be used as-is in Coq because of the strict syntactic guard condition that
ensures that recursive definitions are well founded. One solution is to inline the
membership definition in the equality. We first define universal and existential
quantifiers on the members of a set. Note that they apply to predicate P only
sets that are structurally smaller than x. This justifies that the definition of eq_hf
below is accepted by Coq.
Definition forall_elt (P:hf->bool) x :=
  let (xl) := x in List.forallb P xl.
Definition exists_elt (P:hf->bool) x :=
  let (xl) := x in List.existsb P xl.
Fixpoint eq_hf x y {struct x} : bool :=
  forall_elt(fun x’ => exists_elt(fun y’ => eq_hf x’ y’) y) x &&
  forall_elt(fun y’ => exists_elt(fun x’ => eq_hf x’ y’) x) y.
Definition in_hf x y := exists_elt (fun y’ => eq_hf x y’) y.
  We then show the basic facts that eq_hf (noted ==) is an equivalence relation
and that membership (noted as usual ∈) is compatible w.r.t. equality:
                         x == x0 ∧ y == y 0 ∧ x ∈ y ⇒ x0 ∈ y 0 .
   Finite Zermelo-Fraenkel. The various operations of HF can be implemented eas-
ily:
Definition empty    := HF nil.
Definition pair x y := HF(x::y::nil).

1 See   http://www.lix.polytechnique.fr/Labo/Bruno.Barras/proofs/sets/.
Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                          Sets in Coq, Coq in Sets        ·     31


                     x ∈ empty    =⇒   ⊥
                   x ∈ pair a b   ⇐⇒   x == a ∨ x == b
                   x ∈ union a    ⇐⇒   ∃y ∈ a.x ∈ y
                   x ∈ power a    ⇐⇒   ∀y ∈ x.y ∈ a
                x ∈ subset a P    ⇐⇒   x ∈ a ∧ ∃x0 .x == x0 ∧ P (x0 )
                  y ∈ repl a F    ⇐⇒   ∃x ∈ a.y == F (x) (if F is a morphism)


                    Fig. 1.   Axioms of Hereditarily Finite Set Theory (HF)

Definition union x :=
 HF(fold_set(fun y l => let (yl):=y in yl++l) x nil).
Definition subset x (P:hf->bool) :=
 HF(fold_set(fun y l => if P y then y::l else l) x nil).
Definition power x :=
 HF(fold_set (fun y pow p => pow p ++ pow (y::p)) x
                 (fun p => HF (rev p) :: nil) nil).
Definition repl x (f:hf->hf) := let (xl) := x in HF(map f xl).
                   S
LetSus recall that x is the union of the all the elements of x, so a ∪ b is encoded
as {a; b}. subset a P denotes {x ∈ a | P (x)} where P is decidable (coded as
bool-valued function in Coq). The powerset Px (power x) is the set of all subsets
of x.2 The last operation is the replacement: repl a f stands for the informal
notation {f (x) | x ∈ a}, where f is a function of the meta-logic (Coq), so we can
actually compute with sets. Iterator fold_set has type ∀X, (hf → X → X) →
hf → X → X and is defined by fold_set f {x1 ; . . . ; xn } a = f x1 (. . . (f xn a) . . .)
taking care to cancel repetition of elements. This requirement will be used when
defining the dependent product of two sets. A slightly more readable notation for
fold_set f x a is foldy∈x (X 7→ f (y, X)) a.
  At this point we prove the basic properties of those constructions, see figure 1
for a precise statement. They can be seen as an axiomatic presentation of the HF
theory. This theory is similar to the Intuitionistic Zermelo-Fraenkel set theory, with
three main differences:
—obviously, there is no infinite set axiom,
—the schema of separation (subset) holds only for decidable predicates,
—and the replacement schema requires a function expressed in the meta-logic. In
 particular, it has to be computable.
From now on, we should not need to consider the actual representation of sets
anymore. However, for efficiency reasons, some definitions will be allowed to break
this set abstraction, mainly to avoid using of the powerset operator which is very
expensive.
   Ordered pairs and functions. We follow the common usage to encode the ordered
pair (couple a b) written (a, b) as {{a}; {a; b}}. A function f is coded as the set
of couples (x, f (x)) where x ranges a given domain set. Typing of functions lead

2 The rev is only for cosmetic reasons, so the elements of the subsets are displayed in the same
order as the original set.

                                               Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
32       ·    Bruno Barras

to introduce dep_func A B for B : hf → hf, the set of dependent functions from
(x ∈ A) to B(x), that is Πx∈A B(x). The formalization is quite standard, so we
simply list the definitions and main facts:
                          S       S
                fst p := S{x ∈ S p | {x} ∈ p}
                snd p := {y ∈ p | {fst p; y} ∈ p}
             lam a f := {(x,S  f (x)) | x ∈ a}
              app a b := snd {p ∈ a | fst p == b}
      dep_func A B := foldx∈A (X 7→ {{(x, y)} ∪ f | f ∈ X, y ∈ B(x)}) {∅}
                S
                    (a, b) == {a; b}   fst (a, b) == a  snd (a, b) == b
                                       x ∈ a ⇒ app (lam a f ) x == f (x)
                      (∀x ∈ a, f (x) ∈ B(x)) ⇒ lam A f ∈ dep_func A B
                f ∈ dep_func A B ∧ x ∈ A ⇒ app f x ∈ B(x)
                         f ∈ dep_func A B ⇒ f == lam A (λx. app f x)
The set of dependent functions is built efficiently: instead of generating all relations
and retain only functional ones, we incrementally build partial functions by iteration
on the domain set. The fact that fold_set f x a does not apply the same element
of x twice to f is crucial so that we actually build functional relations.

2.    INTUITIONISTIC ZERMELO-FRAENKEL
In this section, we will not proceed as for HF. Our primary goal is to use Coq as
a prover for IZF, rather than comparing the theoretical strengths of Coq and IZF.
This is why we will first proceed by defining a module interface that gathers the
basic operations and axioms of IZF, and build a library of set theoretical construc-
tions together with their properties. To make complex constructions easier, we have
chosen a Skolemized presentation. Then, we will try to instantiate the signature.
Such attempt to give a model of set theory within Coq has already been formalized
by Werner.3 Here, we recoded this work, and pushed further the study of universes.
2.1      IZF Axiomatization
We assume we have a type set:Type equipped with two relations == and ∈ such
that set equality is extensional and membership is a morphism:
      a == b ⇐⇒ ∀x. x ∈ a ⇐⇒ x ∈ b                     and      a == a0 ∧ a ∈ b =⇒ a0 ∈ b.
Next, sets can be constructed using the following constants: the empty and infinity
sets, a binary operation pair:set->set->set, two unary operators union and
power, and the replacement operator repl:set → (set → set → Prop) → set.
They should satisfy the so-called “axioms of ZF” listed in figure 2. Replacement
is obviously the one that calls the most for explanations. The introduction of a
variable y 0 equals to y is to deal with cases where R is not a morphism.4 The
side condition (R is functional) does not require R to be total (unlike in HF). So,

3 This   formalization is available as the Rocq/ZFC user contribution of Coq.
4 Assuming    we have two extensionally equal sets y and y 0 but intentionally distinct (y == y 0 ∧¬y =
y 0 ), then we could show that y belongs to repl {∅} (λ z. z = y), but y 0 would not, in contradiction
with the fact that ∈ is a morphism.

Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                              Sets in Coq, Coq in Sets       ·     33


                  x ∈ empty =⇒ ⊥
                x ∈ pair a b ⇐⇒ x == a ∨ x == b
                x ∈ union a ⇐⇒ ∃y ∈ a.x ∈ y
                x ∈ power a ⇐⇒ ∀y ∈ x.y ∈ a
               y ∈ repl a R ⇐⇒ ∃x ∈ a.∃y 0 .y == y 0 ∧ R(x, y 0 )
                   (if ∀x x0 y y 0 . x ∈ a ∧ R(x, y) ∧ R(x0 , y 0 ) ∧ x == x0 → y == y 0 )
              x ∈ infinite ⇐= x == empty ∨ ∃y ∈ infinite. x == y ∪ {y}


                              Fig. 2.   Axioms of Zermelo Fraenkel

repl a R is the image of a by R, discarding those that are not in the domain of R.
This allows to derive the comprehension scheme from replacement:
                     subset a P := repl a (λx y.x == y ∧ P (x))
   Another important remark about replacement is that the relation is a Prop-valued
relation, as opposed to a first-order formula. This might strengthen the theory, since
we can quantify over proper classes (classes are terms of type set→Prop), thanks
to the impredicativity of Prop.

2.2   A library of IZF constructions
We are now ready to formalize basic constructions such as pairs, relations and
functions mostly in the same way as in HF, so we will resume the formalization at
this point.
   Disjoint sums. The construction of a model for inductive types requires a notion
of disjoint sum, in order to ensure that constructors build distinct elements. The
definitions and expected properties about typing and elimination are the following:

                                              inl a == inl a0 ⇒ a == a0
                  inl a := (0,a)
                                              inr b == inr b0 ⇒ b == b0
                  inr b := (1,b)
                                              inl a == inr b0 ⇒ ⊥

                sum A B         :=   {(0, a) | a ∈ A} ∪ {(1, b) | b ∈ B}
                  a∈A           ⇒    inl a ∈ sum A B
                  b∈B           ⇒    inr b ∈ sum A B
            p ∈ sum A B         ⇒    (∃a ∈ A, p == inl a) ∨ (∃b ∈ B, p == inr b)
       A ⊆ A0 ∧ B ⊆ B 0         ⇒    sum A B ⊆ sum A0 B 0
   Ordinals and fixpoints. The classical definition of ordinals as hereditarily transi-
tive sets and the successor of x as x+ = x ∪ {x} raises problems in an intuitionistic
setting. As remarked by Grayson, y < x+ is equivalent to y = x ∨ y < x, but not to
y ⊆ x unless we are classical. Taylor [18] introduced the notion of plump ordinals,
which fixes that issue. Informally, a set x is a plump ordinal if (1) every element of
x is an ordinal, and (2) for all ordinals z such that z ⊆ y ∈ x for some y, then z ∈ x.
Since the term ordinal occurs negatively in condition (2), we define ordinals in two
steps. Firstly, plump u x stands for x is a plump ordinal included in a well-founded
set u; this is defined by well-founded induction on u. Secondly, we define the class


                                                  Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
34      ·    Bruno Barras

isOrd of well-founded sets that are plump ordinals bounded by themselves:
             plump u x := (∀y ∈ u, y ∈ x ⇒ plump y y) ∧
                               (∀z y. y ∈ u ∧ plump y z ∧ z ⊆ y ∈ x ⇒ z ∈ x)
                isOrd x := Acc (∈) x ∧ plump x x
The plump successor of x is then the set of plump ordinals included in x. So,
x+ = {y ∈ Px | isOrd y}. To illustrate the difference, let us consider the ordinal 2:
the classical successor of 1 is {∅; {∅}}, which is a boolean algebra. This contrasts
with the plump successor of 1, which is the set of all {∅ | P } for some proposition
P . This forms a complete Heyting algebra.
   We can define a transfinite operator TR. Intuitionistically, we cannot distinguish
zero, successor and limit cases, so TR is parametrized by a step function F : (set →
set) → set → set and the ordinal on which we iterate. Formally, TR is defined by
replacement using the following relation (defined impredicatively):
        TR_rel o y := ∀P. (∀f α.(∀β ∈ α.P β f (β)) ⇒ P α F (f, α)) ⇒ P o y,
which is functional on the class of ordinals. This shows clearly the role of F : it
produces the intended value for α, given (1) a function collecting all intended values
for ordinals β < α and (2) α itself. The general induction scheme associated to TR
is, given an ordinal α and a morphism P ,


       (∀β ≤ α. (∀γ < β. P γ (TR F γ)) ⇒ P β (F (TR F, β))) ⇒ P α (TR F α)
An easy consequence of this scheme is the recursive equation TR F α = F (TR F, α)
for all ordinal α.
  We define a specialized version of TR for the common cases where the limit case
corresponds to the union of the previous results: given F : set → set,
                                        [
                   TI F α := TR (λf β. {F (f (γ)) | γ ∈ β}) α
     The main property of TI is that
                                           [
                            TI F α ==       {F (TI F β) | β < α}
  This iterator has several interesting properties when F is monotone w.r.t. set
inclusion (∀x y. x ⊆ y ⇒ F (x) ⊆ F (y)): it forms an increasing sequence of sets all
included in any pre-fixpoint of F .
α ⊆ β ⇒ TI F α ⊆ TI F β              TI F α+ == F (TI F α)     F (x) ⊆ x ⇒ TI F α ⊆ x
  Grothendieck universes. The collection of Grothendieck universes grot_univ is
the collection of transitive sets U that are closed under all ZF operators: pairing,
powerset, union and replacement (without assuming it contains the empty set or
an infinite set). They have been introduced to avoid resorting to proper classes,
which can be replaced by subsets of a universe. A set U is a Grothendieck universe




Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                      Sets in Coq, Coq in Sets        ·     35

if it satisfies the following closure conditions:
                              y∈x ∧ x∈U             ⇒   y∈U
                             x∈U ∧ y∈U              ⇒   {x; y} ∈ U
                                      x∈U           ⇒   P
                                                        Sx ∈ U
      I ∈ U ∧ (∀x ∈ U. ∀y. R(x, y) ⇒ y ∈ U )        ⇒     {y | ∃x ∈ I. R(x, y)} ∈ U
                                                           (R functional)
It is straightforward to derive that Grothendieck universes are closed under depen-
dent product, this is the reason why they play an important role in the interpreta-
tion of the Type hierarchy of CCω and CIC.
   Grothendieck universes are stable by non-empty intersection, so we can define
a functional relation between a universe U and the least universe that contain U ,
called the successor of U :
  grot_succ x y := grot_univ y ∧ x ∈ y ∧ (∀U. grot_univ U ∧ x ∈ U ⇒ y ⊆ U )
Obviously, the successor universe cannot be built without an extra assumption. The
Tarski-Grothendieck set theory (the formalism of Mizar) is ZF where we assume
that for any set, there exists a universe that contains it. Clearly, in this theory, the
replacement axiom lets us build an infinite sequence of nested universes.

2.3   An attempt to build a model of IZF
  Model of IZF. Following Peter Aczel’s work [4], (well-founded) sets can be en-
coded in a tree-like datatype:
Inductive set : Type := sup (X:Type) (f:X->set).
Definition idx (x:set) : Type := let (X,f) := x in X.
Definition elts (x:set) : idx x -> set := let (X,f) := x in f.
Type X is used to index the direct elements of a set, and elts x i is the element of
x with index i. The predicativity of inductive types in sort Type implies that the
sort of X is lower than that of set so it is not possible to form the set of all sets
by sup set (fun x=>x).
   Most of IZF’s constructions can be implemented straightforwardly: pair {x; y}
can be coded by (sup bool (fun b => if b then x else y)); union of x is a
set indexed by a dependent pair formed of an index i of x, and an index of the
element of x with index i; powerset of x is a set indexed by predicates over indexes
of x, yielding the subset of x which index satisfy the predicate.
   We remark that we can define a weaker version of replacement where the relation
can be expressed as a function at the meta-level:
      replf:set->(set->set)->set            x ∈ replf a f ⇐⇒ ∃y ∈ a. x == f y
The set replf a f is indexed by the index set of a, and the element access func-
tion is just the composition of f with the access function of a. We remark that
all the definitions of the previous paragraphs can be carried out with functional
replacement, with the notable exception of ordinals.




                                           Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
36       ·    Bruno Barras

  The relational replacement is more delicate. Werner resorted to a type theoretical
axiom of choice:5
Axiom choice : forall (A B:Type) (R:A->B->Prop),
  (forall x:A, exists y:B, R x y) ->
  exists f:A->B, forall x:A, R x (f x).
This axiom can transform any relation between sets into an existentially quantified
function, which we can feed to replf. Thus, we can derive the existential version
of replacement:
         ∀a R.R functional ⇒ ∃z.∀y.(y ∈ z ⇐⇒ ∃x ∈ a.∃y 0 .y == y 0 ∧ R(x, y 0 ))
We slightly refined Werner’s result by not requiring the excluded-middle to prove
this.
  In fact, this axiom of choice is powerful enough to prove the collection axiom:
                 ∀a R.(∀x ∈ a.∃y.R(x, y)) ⇒ ∃z.(∀x ∈ a.∃y ∈ z.R(x, y))
  A specific instance of choice, where the co-domain type B is set and the relation
R is functional, is enough to prove replacement:
Axiom uchoice : forall (A:Type) (R:A->set->Prop),
  (forall x y y’, R x y -> R x y -> y == y’) ->
  (forall x:A, exists y:B, R x y) ->
  exists f:A->B, forall x, R x (f x).
We could not prove the collection axiom in that case. However, if we assume
excluded-middle and the foundation axiom, we can encode the usual proof that
replacement entails collection by choosing the images of R of least rank. See [8, 9]
for a more extensive account.
  In order to faithfully instantiate our IZF axiomatization, we need to Skolemize
the replacement axiom. We have built a functor that, given a model of IZF where
constructors are existentially quantified, produces a model of IZF as in section 2.1.
Sets of the skolemized signature are predicates over sets of the input signature, that
are satisfied by exactly one set.
  The formalization of this functor in Coq requires no axiom. This is because IZF’s
constructions introduce sets that are uniquely defined.6 The collection axiom and
the (set-theoretical) axiom of choice do not enjoy this uniqueness property (and do
not seem equivalent in IZF to an axiom enjoying this property), so we see no way
to extend this functor to those extensions of IZF.
5 This axiom, called Type Theoretical Description Axiom by Werner, is weaker than the set the-
oretical axiom of choice since it does not imply the law of excluded-middle. In [14], a model of
intuitionistic type theory based on ω-sets validates this axiom since the existence of an image
means the existence of a recursive function computing it. So it is possible to build the expected
function f : A → B. It is widely accepted that such a model extends to the theory of Coq.
Moreover, if we move all the logical connectives to sort Set (and using the option to make it
impredicative) instead of Prop, then this statement becomes provable. This means that the whole
development described here could be done without resorting to axioms but the one about the
existence of inaccessible cardinals.
6 The axiom of infinity does not define a uniquely defined set, but it is equivalent to the axiom

assuming the existence of the smallest set containing the empty set and closed by “successor”,
which is unique. So, the skolemization of this axiom is not a problem.
Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                     Sets in Coq, Coq in Sets        ·     37

  Universes. We are now trying to build a Grothendieck universe. For this we are
considering that the set of the previous paragraph represents “small sets” and we
are going to duplicate this set definition so that we can build a “big set” of all
“small sets”. We relate both types of sets by defining the copy of any small set at
the big set level (which enforces that small sets live in a universe level less than or
equal to that of big sets), and finally a big set U that contains a copy of every small
set. This latter definition enforces that small sets live in a universe level strictly
below that of big sets. The following definition already reflects this constraint.
Inductive bigset : Type := bigsup (X:Type) (f:X->bigset).
Fixpoint copy (x:set) : bigset :=
  match x with
  | sup X f => bigsup X (fun i => copy (f i))
  end.
Definition U : bigset := bigsup set copy.
Equality and membership of small sets and their copies coincide. The next step
would be to prove that U is a Grothendieck universe. Transitivity of U , closure of
U under pair, union and powerset are straightforward. The relational replacement
(repl) is also an internal operation of U .
   One might expect that we can avoid needing the choice axiom by working in IZ +
replf. Such a theory looks appealing since dependent products and λ-abstractions
can be expressed easily. Unfortunately, we failed to prove that Grothendieck uni-
verses are closed under functional replacement: given a function that produces big
sets and the logical assumption that those big sets are indeed in U , we cannot
derive a function producing small sets, which would, by replacement at the small
set level, witness that the big set built by replacement indeed belongs to U . Quite
ironically, choice seems to be the only way to fix this issue.
2.4   Related Work
There already exists several formalizations of set theory in Coq. We already men-
tioned Werner’s work [19]. The focus of this work is to study relationships between
set theoretical and type theoretical formalisms. A fragment of plump ordinal theory
is also formalized there.
   Another related work is Simpson’s which features an axiomatization of ZFC, and
develops common set theoretical notions. See user contribution Sophia-Antipolis/
FunctionsInZFC.
   We mention one last formalization of set theory: Miquel’s contribution Rocq/IZF.
The idea is to represent sets by pointed graphs, which allows to encode Aczel’s anti-
foundation axiom.
   Our present work takes from all of the above cited works, since it reconciles
foundational investigations (like Werner’s and Miquel’s work), and a toolbox to
mechanically verify proofs in set theory (like Simpson’s work and subsequent for-
malizations in algebraic geometry). The contribution of this paper is, on the one
hand, to study a bit further the encoding of Grothendieck universes (and inacces-
sible cardinals) in the sets-as-trees paradigm, and on the other hand, to develop as
much as possible an intuitionistic set theoretical toolbox usable at a large scale.

                                          Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
38     ·     Bruno Barras


                                      X    :   Type;
                                     ==    :   X → X → Prop;
                                      ∈    :   X → X → Prop;
                                      @    :   X → X → X;
                                      Λ    :   X → (X → X) → X;
                                      Π    :   X → (X → X) → X;
                                      ?    :   X

       (∀x, x == x) ∧ (∀x y. x == y ⇒ y == x) ∧ (∀x y z. x == y ∧ y == z ⇒ x == z)
                                           x == x0 ∧ y == y 0 ⇒ (x ∈ y ⇔ x0 ∈ y 0 )
                                           x == x0 ∧ y == y 0 ⇒ @(x, y) == @(x0 , y 0 )
        A == A0 ∧ (∀x x0 , x == x0 ∧ x ∈ A ⇒ f (x) == f 0 (x0 )) ⇒ Λ(A, f ) == Λ(A0 , f 0 )
       A == A0 ∧ (∀x x0 , x == x0 ∧ x ∈ A ⇒ B(x) == B 0 (x0 )) ⇒ Π(A, B) == Π(A0 , B 0 )

                  (∀x ∈ A, f (x) ∈ B(x))   ⇒    Λ(A, f ) ∈ Π(A, B)        (Π-I)
                  x ∈ Π(A, B) ∧ y ∈ A      ⇒    @(x, y) ∈ B(y)            (Π-E)
                                   x∈A     ⇒    @(Λ(A, f ), x) == f (x)   (β)
                     (∀x ∈ A, B(x) ∈ ?)    ⇒    Π(A, B) ∈ ?               (Imp)


                    Fig. 3.   Abstract model of the Calculus of Constructions

3.    SET THEORETICAL MODEL OF THE CALCULUS OF CONSTRUCTIONS
This section illustrates how these formalizations can be used to build set theoretical
models of the Calculus of Constructions.
3.1   An abstract model of CC
We define an abstract model of the Calculus of Constructions: a structure (X, ==,
∈, @, Λ, Π, ?). Such a structure is a model of the Calculus of Constructions if it
satisfies the properties of figure 3. The first block describes how these constants
are typed in Coq. The second block gathers some basic requirements: == is an
equivalence relation and the constants are all morphisms. Finally, the last block
shows the significative properties of the constants. This can be understood as the
definition of a (finite) variant of set theory where the basic operations deal with
functions and an “impredicative set” ?.
3.2   Building the model in HF
In this section, we show that we can build such a model in HF. The first three
conditions of an abstract model would suggest we can have @=app, Λ=lam and
Π=dep_func, but the last one (impredicativity) cannot be satisfied. To turn around
this, we use Peter Aczel’s encoding of functions [4], that consists of encoding a
function f by the set of pairs (x, y) such that y belongs (rather than being equal) to
f (x). Application is adapted so as to collect all the ys such that (x, y) belongs to the
function. This way, the empty set is the function that maps any set to the empty
set. Propositions are then either ∅ or {∅}, hence the classical and proof-irrelevant
nature of this model.
            cc_lam A f := {(x, y) | x ∈ A, y ∈ f (x)}
             cc_app x y := image {p ∈ x | fst p == y}
          cc_prod A B := {cc_lam A (λx. app f x) | f ∈ dep_func A B}
                 props := P {∅}
Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                    Sets in Coq, Coq in Sets        ·     39

3.3   Building the model in IZF
The abstract model of the Calculus of Constructions can also be instantiated in IZF,
using the same definitions as in the previous paragraph. However, in IZF, the same
definitions have a totally different meaning. Propositions are not mere booleans,
but form a complete Heyting algebra, reflecting the meta-level propositions up to
equivalence.
      x ∈ props ⇐⇒ x ∈ P {∅} ⇐⇒ x = {∅ | P }             for some proposition P
Thus, the model is proof-irrelevant, but not classical.
3.4   Soundness of the abstract model
Here we are going to prove that the abstract model described previously allows to
actually build an interpretation of terms and judgments of the Calculus of Con-
structions that will validate the typing rules of CC. The construction is independent
of the way we choose to instantiate the abstract model (either using HF or IZF).
   Our approach is to delay the introduction of the syntax as much as possible,
thus introducing first a shallow embedding of CC in our abstract model. We will
introduce the usual syntax of terms and typing rules (forming a deep embedding of
CC) only at the end of this section. It is then trivial to translate the syntax into
the semantics.
   Instead of defining the interpretation function by recursion on the syntax of
terms, we represent terms as their interpretation function, that is a function that
maps any valuation (assigning a set to every variable) to a set. The main benefit
of that approach is that our model is “open” in the sense that we can check the
validity of new constructions or typing rules in a modular way as we will see when
extending CC to CCω .
  Valuations and associated operations (dummy valuation, extension and shift).
Valuations assign a denotation to each variable. Here, we found simpler to encode
them as functions. In principle, this could be used to interpret notations involving
an infinite number of free variables.
Definition    val := nat -> X.
Definition    vnil : val := fun _ => props. (* dummy *)
Definition    vcons (x:X) (i:val) : val :=
  fun k =>    match k with 0 => x | S n => i n end.
Definition    vshift (n:nat) (i:val) : val := fun k => i (n+k).
   Denotation of Terms. Let us remark that our abstract model gives a way to
interpret all kinds (it contains Prop and is closed by product), but it does not
contain a set to interpret the sort Kind, which is not a finite type. So we use the
option type to represent terms as either Kind or a function f from valuations to
sets. Since we want our interpretation to be a morphism, we require f to respect
equalities, i.e. it maps equal valuations to equal denotations. This is precisely what
the Proper predicate is used for.
Definition term := option {f:val->X | Proper (eq_val ==> eqX) f}.
  Terms are viewed either as objects (and they are encoded by an element of X), or
as a type (a set of elements of X). The following two definitions reflect that remark
                                         Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
40     ·     Bruno Barras

(int gives the object level interpretation, and el the type level interpretation).
Observe how el encodes that the denotation of Kind is the whole model X. The
object level interpretation of Kind is a dummy value since this sort (like any top
sort of a PTS) can never appear in subject position in judgments.
       int : term → val → X                            el : term → val → X → Prop
       int (f, ) i := f i                              el (f, ) i x := x ∈ f i
       int None i := props (*dummy*)                   el None i x := True
  We can define the usual term constructors (using de Bruijn notations for vari-
ables). We leave out the proof that they are morphisms, which is straightforward.
           prop := (λ .props, )     kind := None      Ref n := (λi. i n, )
             App u v := (λi. app (int u i) (int v i), )
           Abs A M := (λi. lam (int A i) (λx. int M (vcons x i)), )
           Prod A B := (λi. prod (int A i) (λx. int B (vcons x i)), )
  Although we do not have introduced the syntax yet, lifting of de Bruijn variables
and substitution can be expressed as operations on the valuation:
                      lift : N → term → term
                      lift n (f, ) := (λi. f (vshift n i) , )
                      lift n None := None

                      subst : term → term → term
                      subst a (f, ) := (λi. f (vcons (int a i) i) , )
                      subst a None := None
  Environments. As usual in a de Bruijn setting, environments are lists of types,
and they are deemed to denote valuations that map each variable to a value in
the denotation of the type associated to this variable (nth_error e n is a function
that returns value T if the n-th element of the list e is T, or error if n is greater
than the list length).
Definition env := list term.
Definition val_ok (e:env) (i:val) := forall n T,
  nth_error e n = value T -> el (lift (S n) T) i (i n).
Note that this is slightly more permissive than the typing rules, which generally
rule out kind variables (when T = Kind).
  Judgments. We consider two semantic judgments, that intuitively correspond to
equality and membership in the model:
—eq_typ which corresponds to convertibility. We will discuss later on why this
 judgment depends on the environment.
—typ which expresses typing.
Definition eq_typ (e:env)             (M M’:term) :=
  forall i, val_ok e i ->             int M i == int M’ i.
Definition typ (e:env) (M             T:term) :=
  forall i, val_ok e i ->             el T i (int M i).

Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                            Sets in Coq, Coq in Sets       ·     41


                                                   Γ |= M = M 0
                                     (E-Refl)                       (E-Sym)
                       Γ |= M = M                  Γ |= M 0 = M
                         Γ |= M = M 0      Γ |= M 0 = M 00
                                                                (E-Trans)
                                  Γ |= M = M 00
                           Γ |= M = M 0      Γ |= N = N 0
                                                                (E-App)
                                Γ |= M N = M 0 N 0
                          Γ |= T = T 0     Γ; x : T |= M = M 0
                                                                   (E-λ)
                              Γ |= λx : T. M = λx : T 0 . M 0
                          Γ |= T = T 0     Γ; x : T |= U = U 0
                                                                  (E-Π)
                              Γ |= Πx : T. U = Πx : T 0 . U 0
            Γ; x : T |= M = M 0     Γ |= N = N 0      Γ |= N : T     T 6= Kind
                                                                                 (E-β)
                            Γ |= (λx : T. M ) N = M 0 [x\N 0 ]


             Fig. 4.   Semantic Equality Rules for the Calculus of Constructions

   Soundness of the model. The goal now is to prove that our model is sound, which
means that eq_typ admits all the rules of β-conversion (congruent equivalence
relation including β-reduction), and typ admits all of the rules of CC. The model
is not complete, which means that it validates judgments that cannot be derived
with the syntactic judgment. We purposely stated more general (and more liberal)
rules, in order to improve re-usability whenever we extend the type system.
   Figure 4 shows the semantic equality rules. The first three rules are easy conse-
quences of the fact that == is an equivalence relation, and the next three ones follow
from the assumptions that @, Λ and Π are morphisms. The last one, β-reduction,
requires a typing condition Γ |= N : T because in a set theoretical model, functions
do not behave like a λ-term outside their intended domain. So the property holds
only for well-typed terms. This is the reason why equality judgments have to keep
track of environments. Types are not needed because denotations are compared by
set equality, regardless of their type.
   This typing condition to β-reduction explains why it is not as easy as expected
(see [16]) to build set theoretical models of type systems which consider type con-
vertibility as an untyped relation.
   Next, figure 5 shows the semantic typing rules that our model validates. In
the rule for λ-abstraction, the side-condition U 6= kind plays a fundamental role.
Without it, and because we accepted kind variables, we could then build an infinite
object (a function with an infinite domain set), which would go beyond our finitary
model.
   Finally, by remarking that the denotation of ∀P. P is the intersection of all propo-
sition, and using the way we instantiated props, we can show that it is empty. This
proves the logical consistency of CC. The model does not make use of ordinals or
universes, so that the Coq development underlying our consistency proof uses no
axiom.
  Syntax. At this point, we may want to check that some given set of inference rules
form a consistent theory. To do so, we just have to write a recursive function that
maps syntactic terms to semantic terms (using the term constructors defined previ-

                                                Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
42      ·     Bruno Barras


                           Γ(n) = T
                                               (T-Var)                               (T-Prop)
                 Γ |= n : lift (n + 1) T                    Γ |= Prop : Kind
                       Γ |= M : Πx : A. B       Γ |= N : A          A 6= Kind
                                                                                 (T-App)
                                      Γ |= M N : B[x\N ]
                                  Γ; x : T |= M : U       U 6= Kind
                                                                         (T-λ)
                                    Γ |= λx : T. M : Πx : T. U
                               Γ; x : T |= U : s    s ∈ {Prop, Kind}
                                                                           (T-Π)
                                         Γ |= Πx : T. U : s
                           Γ |= M : T     Γ |= T = T 0       T 6= Kind
                                                                            (T-Conv)
                                         Γ |= M : T 0


                 Fig. 5.   Semantic Typing Rules for the Calculus of Constructions


                     Γ(n) = T
                                            (T// -Var)                                     (T// -Prop)
            Γ ` n B n : lift (n + 1) T                     Γ ` Prop B Prop : Kind
              Γ; x : T ` M B M 0 : U      Γ ` T B T 0 : s1         Γ; x : T ` U B U 0 : s2
                                                                                             (T// -λ)
                              Γ ` λx : T. M B λx : T 0 . M 0 : Πx : T. U
 Γ ` M B M 0 : Πx : A. B       Γ ` N B N0 : A       Γ ` A B A 0 : s1        Γ; x : A ` B B B 0 : s2
                                                                                                        (T// -App)
                                Γ ` M N B      M0   N0   : B[x\N ]
     Γ; x : A ` M B M 0 : B    Γ ` N B N0 : A       Γ ` A B A 0 : s1        Γ; x : A ` B B B 0 : s2
                                                                                                         (T// -β)
                            Γ ` (λx : T. M ) N B    M 0 [x\N 0 ]   : U [x\N ]
                            Γ ` T B T 0 : s1    Γ; x : T ` U B U 0 : s2
                                                                                (T// -Π)
                                 Γ ` Πx : T. U B Πx : T 0 . U 0 : s2
                              Γ ` M B M0 : T Γ ` T B T 0 : s
                                                             (T// -Red)
                                    Γ ` M B M0 : T 0
                              Γ ` M B M0 : T 0 Γ ` T B T 0 : s
                                                               (T// -Exp)
                                     Γ ` M B M0 : T


                 Fig. 6.    TPOSR Typing Rules for the Calculus of Constructions

ously), prove that syntactical lifting and substitution is equivalent to the semantic
operations. A final induction allows to prove that the typing judgments of CC
(presented with a judgmental equality) imply the semantic judgments. Formally,
we prove
                  Γ ` M B M 0 : T ⇒ Γ |= M : T ∧ Γ |= M = M 0 .
  As a final remark, we obtain models of the common presentation of CC (with un-
typed equality) by showing the equivalence between both presentations. Adams [5]
has proved this in the case of functional PTSs. We have formalized this proof, that
we will not detail here.
  Conclusions. Several models of the Calculus of Constructions can be found in
the literature [10, 16, 17]. We claim that this model is simpler in several respects:
—the definition of the interpretation function is straightforward and does not rely
 on excluded-middle, thanks to Aczel’s trick.
Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                     Sets in Coq, Coq in Sets        ·     43

—it does not consider a stratification of terms (as proof-terms, types and kinds),
 which do not generalize to universes.
—it admits extensions at the Kind level by any type whose denotation is a set
 constructible in IZF, since the denotation of Kind is the class of all IZF sets.
Building the model for system in judgmental equality presentation makes the sound-
ness proof much easier. The technical difficulties (either resorting to a stratification
of terms [10], or introducing some dynamic type-checking in the β-reduction [16])
are restrained to the equivalence proof with the untyped equality presentation.
   This model also supports not so trivial extensions like Prop⊂Kind, but we shall
remark that Adams’ proof does not apply anymore since we have lost type unique-
ness. So, the justification of such extension in a presentation of the calculus with
untyped conversion remains open, to our knowledge.

4.   MODEL OF THE CALCULUS OF CONSTRUCTIONS WITH UNIVERSES (CCω )
An abstract model of the Calculus of Constructions with universes (CCω ) is an
abstract model of CC, extended with a sequence (ui )i∈N that satisfies the following
properties:
                       ∗ ∈ u0   un ∈ un+1      un ⊂ un+1
                 A ∈ un ∧ (∀x ∈ A, B(x) ∈ un ) ⇒ Π(A, B) ∈ un
                 A ∈ ∗ ∧ (∀x ∈ A, B(x) ∈ un ) ⇒ Π(A, B) ∈ un
   CCω can be proven consistent in ZF [15]. But if we want a model that can cope
with inductive types, there is little hope that we can escape without resorting to
an infinite number of inaccessible cardinals, as shown in [19]. We found it easier to
reason with Grothendieck universes, which directly gives us a set that is closed under
all ZF set constructors, and thus closed under dependent products and inductive
types. It is straightforward to prove that if we assume the existence of an infinite
sequence of Grothendieck universes, the abstract model of CCω signature can be
instantiated.
   The model construction follows the same steps as for CC, with the difference that
CCω has no top sort, so in principle our interpretation domain could directly be
the type X. However, in order to reuse the model construction carried out so far,
we still have Kind in our model, but it is not relevant in CCω . In fact, we have that
the full Type hierarchy belongs to Kind, so we could build a model of CCω with a
super universe.
   To deal with cumulativity (inclusion of Typei in Typei+1 ), we introduce a sub-
typing judgment:
Definition sub_typ (e:env) (T T’:term) :=
  forall i x, val_ok e i -> x \in int T i -> x \in int T’ i.
Subtyping includes equality and is transitive. It also validates the covariant sub-
typing of products. Figure 7 gathers all the new rules. In a set theoretical model,
contravariant subtyping is not validated since functions on a domain are not func-
tions on s strict subset of that domain.
   If we do not consider cumulativity, type uniqueness holds and so does the equiv-
alence between untyped conversion and judgmental equality, and our model con-
struction applies to the presentation with untyped conversion. However, adding
                                          Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
44     ·     Bruno Barras



                                    (T-Prop’)                                (T-Type)
               Γ |= Prop : Type0                  Γ |= Typen : Typen+1
                         Γ |= T : Typen     Γ; x : T |= U : Typen
                                                                        (T-Π’)
                                   Γ |= Πx : T. U : Typen
                         Γ |= M : T     Γ |= T ≤ T 0    T 6= Kind
                                                                    (T-Sub)
                                       Γ |= M : T 0



            Γ |= M = M 0                 Γ |= M ≤ M 0       Γ |= M 0 ≤ M 00
                             (S-Refl)                                             (S-Trans)
            Γ |= M ≤    M0                         Γ |= M ≤ M 00

                                     (S-Prop)                                    (S-Type)
               Γ |= Prop ≤ Type0                  Γ |= Typen ≤ Typen+1
                                     Γ; x : T |= U ≤ U 0
                                                                (S-Π)
                                 Γ |= Πx : T. U ≤ Πx : T. U 0


                       Fig. 7.   Additional Semantic Typing Rules for CCω

cumulativity breaks type uniqueness and if we cannot generalize Adams’ result, we
will have to find another equivalence proof.
  Normalization by evaluation techniques might help here. Abel, Coquand and
Dybjer [3, 2] show how an arbitrary applicative structure (e.g. closures) can be
used to implement a conversion test that is both sound and complete w.r.t. typed
equality judgment systems. Such algorithm is very close to the one used for type-
checking systems with untyped equality (comparing normal forms).

5.    A MODEL OF NATURAL NUMBERS BASED ON SIZE ANNOTATION
In this section we show that a simple inductive type (Peano’s natural numbers)
can fit into our model construction. We are going to follow a very general scheme
so that the method generalizes to arbitrary inductive types. Inductive types are
traditionally thought of as the least fixpoint of a (monotonic) type transformer.
  Given the inductive structure of nat, we consider the type transformer NATf X
:= sum UNIT X (where UNIT is {0}). Constructor ZERO is inl zero and SUCC x is
inr x. We can show that ZERO belongs to NATf X for any X, and if n belongs to
X, then SUCC n belongs to NATf X.
5.1   The type of natural numbers with size annotations
In this paper, termination of functions defined by structural recursion is ensured
by type-checking [12], unlike the implementation of Coq which distinguishes the
pattern-matching operator from the fixpoint operator, and uses a syntactic crite-
rion to check that recursive calls are made only on structurally smaller terms as
described in [11]. In [6], we proposed a variant of [12] where inductive types bear
size annotations. Such an annotation is intended to denote an ordinal over which
we iterate the constructor operator.
   Type constructor. Using TI, we define N α the transfinite iteration of NATf, i.e.
it is the function α 7→ NATfα (∅) for any ordinal α. At this point we do not use the
Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                     Sets in Coq, Coq in Sets        ·     45

fact that N ω is a fixpoint of NATf.
  Pattern-matching. Let us assume that P is a morphism and α an ordinal. Pattern-
matching on a natural number n of size bounded by α leads to either n == ZERO,
or n == SUCC m for some m of size β < α:
          P (ZERO) ∧ (∀β < α.∀m ∈ N β .P (SUCC m)) ⇒ ∀n ∈ N α .P (n)
  The pattern-matching constant can be derived using replacement on the relation
λx y.(x == ZERO ⇒ y == f0 ) ∧ (∀k, x == SUCC k ⇒ y == fS (k)), which can be
proved to be total on N α . Constructor discrimination and injection is needed to
show that it is functional. We get a function NATCASE(f0 , fS ) such that
                             NATCASE(f0 , fS , ZERO) = f0
                         ∀k.NATCASE(f0 , fS , SUCC k) = fS (k)
From these two equations, we can derive the typing lemma for NATCASE for any
ordinal α and class P :
                f0 ∈ P (0) ∧ (∀n ∈ N α .fS (n) ∈ P (SUCC n))
                                      +
                           ⇒ ∀n ∈ N α .NATCASE(f0 , fS , n) ∈ P (n)
  Recursive functions. The fixpoint associated to natural numbers of size bounded
by α can be expressed without any reference to the constructors:
    (∀β ≤ α.(∀γ < β.∀m ∈ N γ .P (m)) ⇒ (∀n ∈ N β .P (n))) ⇒ ∀n ∈ N α .P (n)
If we omit the ordinal annotations, this specification looks like a fixpoint operator of
type ((nat → P ) → nat → P ) → nat → P . Of course, ordinals are the guarantee
that recursion terminates. The subtle relation between three sizes
—α the size of initial call to the recursive function,
—β(≤ α) the typical size of the input along the recursive calls
—and γ(< β) the maximum size on which recursive calls are allowed
is a (yet somewhat informal) justification of the typing rules of fixpoints based on
size annotation, as in [6].
   To be more precise, let F : set → set → set be an operator that, given an
ordinal α and a function with domain N α , extends it to a function with domain
    +
N α . We build a function of domain N β by transfinite iteration of F :
Definition NATFIX F :=
  TR (fun f o => union (replf o (fun o’ => F o’ (f o’)))).
Informally, the notation NATFIXβ (F ) stands for NATFIX F β. We would expect to
have the following fixpoint equation:
                         NATFIXβ (F ) == F (β, NATFIXβ (F )),
but this cannot hold in our model since the left hand-side is a function with domain
                                               +
N β while the right hand-side has domain N β . The best we can hope is
                ∀x ∈ N β . NATFIXβ (F )(x) == F (β, NATFIXβ (F ))(x).
  NATFIXα (F ) is the union of the images by F of the functions at ordinals smaller
than α. This can be a function only if these functions agree on a common domain
                                          Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
46      ·      Bruno Barras

(pairwise). Notation f =α g stands for ∀x ∈ N α . f (x) == g(x) (f and g agree on
the domain of stage α).
  If f and g are functions with respective domains N α and N β with α ≤ β, and
they agree on N α (in other word: g extends f ), then their images by F agree on
   +
N α (the image of g extends the image of f ):
                                                          +
                               f =α g ⇒ F (α, f ) =α F (β, g)
This requirement on F can be seen as a kind of monotonicity, but it also means
that F cannot really compute with its ordinal argument. The latter can be used
only to determine the domain of the function to build.
   To express the typing lemma for NATFIX, let U be a binary operator. U (α, x) is
intended to be the codomain of the recursive function obtained after α iterations
at x (with x ∈ N α ). Abel [1] has given examples of unsound definitions for some
U , for instance with negative occurrences of α. In this paper, we require U to be
monotone on α, which is more restrictive than Abel’s criterion.
   More formally, we prove that given F and U and an ordinal γ such that
                                                               +
     ∀α < γ. ∀f ∈ (Πx : N α .U (x, α)). F (α, f ) ∈ Πx : N α .U (x, α+ )       (F-typing)
     ∀α ≤ β ≤ γ. ∀x ∈ N α . U (x, α) ⊆ U (x, β)                                (U-mono)
     ∀α ≤ β ≤ γ. ∀f ∈ (Πx : N α .U (x, α)). ∀g ∈ (Πx : N β .U (x, β)).
                                                              +                (F-mono)
                                    f =α g ⇒ F (α, f ) =α F (β, g),
then we have
      NATFIXγ (F ) ∈ Πx : N γ .U (x, γ)       and      NATFIXγ (F ) =γ F (γ, NATFIXγ (F ))
  These two properties are proven by mutual transfinite induction of γ. Note that
the second property is exactly the fixpoint equation we wanted.
5.2    Building the fixpoint of the type constructor
We define NAT as N ω . In order to show that NAT is a fixpoint of NATf, we prove
that sum is continuous: for any I, (Xi )i∈I and (Yi )i∈I ,
                 [                 [                  [
            sum     {Xi | i ∈ I}     {Yi | i ∈ I} == {sum Xi Yi | i ∈ I}
                                   +                       ++
So, NATf NAT == {NATf (N n ) | n < ω} == {N n | n < ω} == NAT. From
                   S                                S
this fixpoint equation, it is straightforward to derive the usual eliminator on natural
numbers:
                  P (ZERO) ∧ (∀m ∈ NAT.P (SUCC m)) ⇒ ∀n ∈ NAT.P (n)
5.3    Examples
This section shows two simple examples of recursive functions that can be defined
with the NATFIX operator. First, we derive the recursor: given P ∈ NAT → props,
f0 ∈ P (ZERO) and fS ∈ Πn : NAT. P (n) → P (SUCC n), we have
            NATFIXω (λα F n. NATCASE(f0 , λk. fS (k, F (k)), n)) ∈ Πn : NAT. P (n).
  We also coded the minus function with type N α → NAT → N α for any ordinal
α, showing that the result of minus is not greater than its first input.

Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
                                                     Sets in Coq, Coq in Sets        ·     47



     NATFIXα (λα F m n. NATCASE(ZERO, λm0 . NATCASE(m, λn0 . F (m0 , n0 ), n), m))
                                                             ∈ N α → NAT → N α


6.    CONCLUSION AND FUTURE WORK
This article shows that formal semantics of expressive type theories are not out of
reach anymore. We claim this, although there is a gap between informal and formal
semantics that is often overlooked by authors. This work can be followed in several
directions.
  Formalizing general inductive types. This requires more support for transfinite
recursion and a characterization of the ordinal that makes all positive inductive
definitions reach their fixpoint. Such an ordinal can be related to the cardinal of
the universe in which the inductive definition lives in.
  It remains to be seen if this can be carried out in an purely intuitionistic setting,
without resorting to a significant piece of cardinal theory, which would require the
(set theoretical) axiom of choice.
   Realizability models. Set theoretical models are good to give an explanation of
CIC that is compatible with the intuition of mathematicians. However, from a
programming language viewpoint, one might prefer realizability models, which con-
siders only effectively computable denotations.
   Among realizability models, strong normalization models are of particular inter-
est. It should be interesting to investigate how our models (designed initially to
prove consistency) can be turned into strong normalization models.
   One specific property of such models is that every type should be inhabited,
to ensure normalization of terms with free variables. This is often thought as
incompatible with consistency models which precisely require that some type is not
inhabited. These two views can be reconciled if we consider that types contain both
total and partial objects. “Empty” types are indeed types that contain only partial
objects. So we can hope and prove strong normalization because every type is non
empty, and also consistency because the construction of the language are supposed
to only yield total objects.
   Scott domains seems to address this issue in a very natural way and there is
also a good fit with the incremental construction of recursive functions by iterating
an operator on partial functions until we get a total function. This is expected
to be the trickiest part because non-total recursive functions often break strong
normalization.

References
 [1] A. Abel. A Polymorphic Lambda-Calculus with Sized Higher-Order Types. PhD
     thesis, Ludwig-Maximilians-Universität München, 2006.
 [2] A. Abel. Towards normalization by evaluation for the calculus of construc-
     tions. In Tenth International Symposium on Functional and Logic Program-
     ming, FLOPS 2010, Sendai, Japan, 2010.


                                          Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
48     ·     Bruno Barras

 [3] A. Abel, T. Coquand, and P. Dybjer. Verifying a semantic βη-conversion test
     for martin-löf type theory. In P. Audebaud and C. Paulin-Mohring, editors,
     Mathematics of Program Construction, volume 5133 of Lecture Notes in Com-
     puter Science, pages 29–56. Springer Berlin / Heidelberg, 2008.
 [4] P. Aczel. Notes on constructive set theory, 1997.
 [5] R. Adams. Pure type systems with judgemental equality. Journal of Functional
     Programming, 16 (2):219–246, 2006.
 [6] B. Barras. Auto-validation d’un système de preuves avec familles inductives.
     Thèse de doctorat, Université Paris 7, Nov. 1999.
 [7] T. Coquand and G. Huet. The Calculus of Constructions. Information and
     Computation, 76(2/3), 1988.
 [8] H. Friedman. The consistency of classical set theory relative to a set theory
     with intuitionistic logic. Journal of Symbolic Logic, 38:315–319, 1973.
 [9] H. Friedman and A. Scedrov. The lack of definable witnesses and provably
     recursive functions in intuitionistic set theories. Advances in Mathmatics, 57:1–
     13, 1985.
[10] H. Geuvers and M. Stefanova. A simple model construction for the calculus
     of constructions. In Types for Proofs and Programs, pages 249–264. Springer-
     Verlag LNCS 1158, 1996.
[11] E. Giménez. Codifying guarded definitions with recursive schemes. In TYPES
     ’94: Selected papers from the International Workshop on Types for Proofs and
     Programs, pages 39–59, London, UK, 1995. Springer-Verlag.
[12] E. Giménez. Structural recursive definitions in type theory. In Proceedings
     of the International Colloquium on Automata, Languages and Programming,
     pages 397–408, Aalborg, Denmark, 1998. Springer-Verlag LNCS 1443.
[13] J. Harrison. Towards self-verification of hol light. In U. Furbach and
     N. Shankar, editors, Proceedings of the third International Joint Conference,
     IJCAR 2006, volume 4130 of Lecture Notes in Computer Science, pages 177–
     191, Seattle, WA, 2006. Springer-Verlag.
[14] G. Longo and E. Moggi. Constructive natural deduction and its ”omega-set”
     interpretation. Mathematical Structures in Computer Science, 1(2):215–253,
     1991.
[15] Z. Luo. An Extended Calculus of Constructions. PhD thesis, University of
     Edinburgh, 1990.
[16] A. Miquel and B. Werner. The not so simple proof-irrelevent model of CC. In
     TYPES, 2002.
[17] M.-O. Stehr. Programming, Specification, and Interactive Theorem Proving -
     Towards a Unified Language based on Equational Logic, Rewriting Logic, and
     Type Theory. Doctoral thesis, Universität Hamburg, 2002.
[18] P. Taylor. Intuitionistic sets and ordinals. Journal of Symbolic Logic, 61:705–
     744, 1996.
[19] B. Werner. Sets in types, types in sets. In Proceedings of TACS’97, pages
     530–546. Springer-Verlag, 1997.


Journal of Formalized Reasoning Vol. 3, No. 1, 2010.
