And here’s a 3-cell, similarly represented:

As a topologist would say it: the (n+1)-disc is the cone on the n-sphere. To implement this logically, we first construct the spheres as a 1-HIT, using iterated suspension:

Inductive Sphere : Nat -> Type :=
  | north (n:Nat) : Sphere n
  | south (n:Nat) : Sphere n
  | longitude (n:Nat) (x:Sphere n) : Paths (north (n+1)) (south (n+1)).

Then we define (it’s a little fiddly, but do-able) a way to, given any parallel pair s, t of n-cells in a space X, represent them as a map rep s t : Sphere n -> X. (I’m suppressing a bunch of implicit arguments for the lower dimensional sources/targets.)

Now, whenever we have an (n+1)-cell constructor in a higher inductive type

HigherInductive X : Type :=
  (…earlier constructors…)
  | constr (a:A) : HigherPaths X (n+1) (constr_s a) (constr_t a)
  (…later constructors…)

we replace it by a pair of constructors

  | constr_hub (a:A) : X
  | constr_spoke (a:A) (t : Sphere n) : Paths X (rep (s a) (t a)) (constr_hub a)

Assuming functional extensionality, we can give from this a derived term constr_derived : forall (a:A), HigherPaths (n+1) (constr_s a) (constr_t a); we use this for all occurences of constr in later constructors. The universal property of the modified HIT should then be equivalent to that of the original one.

(Here for readability X was non-dependent and constr had only one argument; but the general case has no essential extra difficulties.)

What can one gain from this? Again analogously with the traditional reduction of inductive types to a few special cases, the main use I can imagine is in constructing models: once you’ve modeled 1-HIT’s, arbitrary n-HIT’s then come for free. It also could be a stepping-stone for reducing yet further to a few specific 1-HIT’s… ideas, anyone?

On a side note, while I’m here I’ll take the opportunity to briefly plug two notes I’ve put online recently but haven’t yet advertised much:

• Model Structures from Higher Inductive Types, which pretty much does what it says on the tin: giving a second factorisation system on syntactic categories C_T (using mapping cylinders for the factorisations), which along with the Gambino-Garner weak factorisation system gives C_T much of the structure of a model category — all but the completeness and functoriality conditions. The weak equivalences are, as one would hope, the type-theoretic Equiv we know and love.
• Univalence in Simplicial Sets, joint with Chris Kapulkin and Vladimir Voevodsky. This gives essentially the homotopy-theoretic aspects of the construction of the univalent model in simplicial sets, and these aspects only — type theory isn’t mentioned. Specifically, the main theorems are the construction of a (fibrant) universe that (weakly) classifies fibrations, and the proof that it is (in a homotopy-theoretic sense) univalent. The results are not new, but are taken from Voevodsky’s Notes on Type Systems and Oberwolfach lectures, with some proofs modified; the aim here is to give an accessible and self-contained account of the material.

(Photos above by ne*, brandsvig, and JPott, via the flickr Creative Commons pool, licensed under CC-NonCom-Attrib-NoDerivs.)

Definition. If and are dependent types over , we define

of which the terms are called dependent transformations. We will say that a transformation is an equivalence if is an equivalence for each .

The case where is the dependent space over with for some fixed in is of special importance. We will denote this dependent type by to emphasize on the similarity of the role it plays to the Yoneda embedding of in the category of presheaves over . Indeed, we will soon be able to prove that . We call a transformation from to also a local section of at .

Example. If is a path in , then there is the transformation defined by . So sends for each the paths to the concatenation .

Note that we didn’t require the naturality in our definition of transformations. This is, however, something that we get for free:

Lemma. Suppose that and are dependent types over and that is a transformation from to . Then the diagram

commutes up to homotopy for every path in . Here, denotes transportation along with respect to the dependent type . We define when and .

Proof. Let be the type . Since it follows that is inhabited by the canonical term . The assertion follows now by the induction principle for identity types.
QED.

Transformations of dependent types may be composed and just as in the case with natural transformations this is done pointwise.

Lemma (Yoneda lemma for dependent types). Assuming function extensionality we have: for any dependent type over and any there is an equivalence

commutes for every and .

Originally, I had a two page long proof featuring some type theoretical relatives of the key ideas of the proof of the categorical Yoneda lemma, like considering for a presheaf on a category and a natural transformation . But as I wrote this blog post, the following short proof occured to me:

Proof. Note that if is inhabited, then is equivalent to . Hence we have

In the last equivalence, we used that is contractible.

By looking at what each of the equivalences does, it is not so hard to see that the equivalence is the map

.

Following the above commutative square from the top right first to the left and then downwards, we get for a transformation , a path and a transformation , we get the term

of .

Going first downwards and then to the left we get the term . Induction on reveals that there is a path between the two.
QED.

Corollary. Taking for we get the equivalence .

Loosely speaking, every function which takes and to a path from to is itself a path from to . Using the Yoneda lemma, we can derive three basic adjunctions from presheaf theory:

We will use the remainder of this post to state and prove them. Hopefully, we can distill a good notion of adjunction in the discussion thread below.

Definition. Suppose that and let be the function from to given by substitution along , i.e. for . We may also define the function given by

Remark. Consider the projection . Then

We have used that the space is contractible. What this shows is that is equivalent to our original dependent sum when is a projection.

Lemma. For all and we have the equivalence

Proof. We use the Yoneda lemma:

QED.

Definition. Suppose that is a function. Define the function given by

Remark. Again, we may consider the map to verify that .

Thus, generalizes the original dependent product construction.

Lemma. For all and we have the equivalence

Proof. In a similar calculation as before, we derive

QED.

Definition. We may define the dependent type over by

The product of two dependent types over is defined pointwise as .

Lemma. For any triple , and of dependent types over there is an equivalence

Proof. Note that if there is a path from to , then the spaces and are equivalent. Thus we can make the following calculation proving the assertion:

QED.

Remark. That the categorical definition of exponentiation doesn’t fail is no surprise. But actually we could get exponentiation easier by defining to be the dependent type over given by . The correspondence

is then immediate. By taking to be and using the Yoneda lemma, we get

Hence the dependent types and are equivalent, which comes down to the fact that we could have gotten away with the naive approach regarding exponentiation.

There is also a simple slight improvement of the theorem, stating that “local decidability of equality” implies “local UIP”. I use the definition of the identity type and some basic properties from Andrej Bauer’s github.

A file containing the complete Coq code (inclusive the lines that are necessary to make the code below work) can be found here.

I first prove a (local) lemma, namely that any identity proof is equal to one that can be extracted from the decidability term dec. Of course, this is already nearly the complete proof. I do that as follows: given and and a proof that they are equal, I check what “thinks” about and (as well as and ). If tells me they are not equal, I get an obvious contradiction. Otherwise, precisely says that they are in the same “contractible component”, so I can just go on as in the proof that the h-level is upwards closed. With this lemma at hand, the rest is immediate.

Theorem hedberg A : dec_equ A -> uip A.
Proof.
  intros A dec x y.

  assert ( 
    lemma :
    forall proof : x ~~> y,  
    match dec x x, dec x y with
    | inl r, inl s => proof ~~> !r @ s
    | _, _ => False
    end
  ).
  Proof.
    induction proof.
    destruct (dec x x) as [pr | f].
    apply opposite_left_inverse.
    exact (f (idpath x)).

  intros p q.
  assert (p_given_by_dec := lemma p).
  assert (q_given_by_dec := lemma q).
  destruct (dec x x).
  destruct (dec x y).
  apply (p_given_by_dec @ !q_given_by_dec).
  contradiction.
  contradiction.
Qed.

Christian Sattler has pointed out to me that the above proof can actually be used to show the following slightly stronger version of Hedberg’s theorem (again, see here), stating that “local decidability implies local UIP”:

Theorem hedberg_strong A (x : A) : 
  (forall y : A, decidable (x ~~> y)) -> 
  (forall y : A, proof_irrelevant (x ~~> y)).

• The univalence axiom for inverse diagrams.

For completeness, I also included a sketch of how to use a universe object to deal with coherence in the categorical interpretation of type theory, and of the meaning of various basic notions in homotopy type theory under categorical semantics in homotopy theory.

An inverse category is one that contains no infinite composable strings of nonidentity arrows. An equivalent, but better, definition is that the relation “x receives a nonidentity arrow from y” on its objects is well-founded.

This means that we can use well-founded induction to construct diagrams, and morphisms between diagrams, on an inverse category. Homotopy theorists have exploited this to define the Reedy model structure for diagrams indexed on an inverse category in any model category. The Reedy cofibrations and weak equivalences are levelwise, and a diagram is Reedy fibrant if for each , the map from to the limit of the values of on “all objects below ” is a fibration. The Reedy model structure for simplicial sets is a presentation of the -presheaf topos .

For example, if is the arrow category , then a diagram is Reedy fibrant if the following two conditions hold.

1. is a fibration (i.e. is fibrant). Here 1 is the limit of the empty diagram (there being no objects below )
2. is a fibration. Here is the limit of the corresponding singleton diagram, since 0 is the unique object below .

The central observation which makes this useful for modeling type theory is that

Reedy fibrant diagrams on an inverse category can be identified with certain contexts in type theory.

For instance, in a Reedy fibrant diagram on the arrow category, we have firstly a fibrant object , which represents a type, and then we have a fibration , which represents a type dependent on . Thus the whole diagram can be considered as a context of the form

Similar interpretations are possible for all inverse categories (possibly involving “infinite contexts” if the category is infinite). This view of contexts as diagrams appears in Makkai’s work on “FOLDS”, and seems likely to have occurred to others as well.

Using this observation, we can inductively build a (Reedy fibrant) universe in out of a universe in . For instance, suppose is a fibrant object representing a universe in , and let be the arrow category . Then the universe we obtain in is the fibration that is the universal dependent type. Regarded as a dependent type in context, this fibration is

We can then prove, essentially working only in the internal type theory of , that the objects of classified by this universe are closed under all the type forming operations, and moreover that this universe inherits univalence from the universe we started with in . In particular, starting with Voevodsky’s universal Kan fibration for simplicial sets, we obtain a model of univalence in simplicial diagrams on , hence in the -presheaf topos .

Combining this with my previous idea, we should be able to get models in -toposes of sheaves for any topology on an inverse category. But unfortunately, inverse categories don’t seem likely to support very many interesting topologies.

So far, I haven’t been able to generalize this beyond inverse categories. The Reedy model structure exists whenever is a Reedy category, which is more general than an inverse category. But in the general case, the cofibrations are no longer levelwise, and the dependent products seem to involve equalizers, and I haven’t been able to get a handle on things. A different idea is to use diagrams on inverse categories to “bootstrap” our way up to other models, but I haven’t been able to get anything like that to work yet either.

In the traditional view of Coq, we think of types in Prop as propositions and their inhabitants as proofs. Thus, knowing that a type of sort Prop is inhabited is considered more important than knowing anything about a particular inhabitant of it. This point of view is officially enshrined in Coq’s mechanism for “extraction” to executable code (such as ML or Haskell), which purposely discards all information about inhabitants of types in Prop. (Something like this is important for developing verified computer software in Coq — we don’t want the resulting software to have to carry along the baggage of the proofs that it is correct.)

In homotopy type theory, it’s natural to want to interpret this by thinking of Prop as a universe of h-propositions (types of h-level 1, which are contractible as soon as they are inhabited). But for better or for worse, this is an invalid way to think — at least, given the way Coq currently treats Prop. For one thing, nowhere inside the Coq type system is the “proof-irrevelance” of Prop enforced: it appears perfectly consistent for a type in Prop to have multiple distinct inhabitants. In particular, nothing forces Coq’s built-in Prop-valued identity types “eq” to be extensional (other than an axiom to that effect).

But actually, things are even worse than that: as soon as there are types anywhere in Coq that are not h-sets, then there must be types in Prop that are not h-props. Specifically, the Prop-valued equality of any type is provably equivalent, in Coq, to its Type-valued equality (i.e. its path type) — thus the Prop-valued equality of a non-hset must be a non-hprop.

Why must the two equalities be equivalent? The short answer is that they have the same inductive definition, hence the same universal property. But something has to be said about why that is, since in general an inductive type in sort Prop doesn’t have the same universal property as the corresponding one in sort Type. And the reason for that goes back to thinking of Prop as consisting of h-propositions again (see what I mean about being undecided?).

Specifically, if Prop were to consist of h-props, then we would then have to regard inductively defined types in sort Prop (which include propositional operations like “and”, “or”, and “there exists”, and also the equality eq) as being obtained from ordinary inductive types (in sort Type) by applying the h-prop reflection (= bracket type, squash type, support, is_inhab, etc.). In particular, the Prop-valued equality eq would be the h-prop reflection of the path type (and in particular would be an h-prop). And if inductive types in Prop were defined in this way, we would only be able to eliminate out of them into other types in Prop (by combining the eliminator of the original inductive type with the universal property of the h-prop reflection). Reflective subcategories are like one-way driveways: once you’ve been reflected into h-prop, you can’t back up without suffering Severe Tire Damage.

And, indeed, Coq does mostly adhere to this philosophy in its treatment of Prop: the eliminators for inductively defined types in Prop can generally only be applied when the target is also of sort Prop. However, Coq also includes a sneaky back alley leading out of Prop: singleton elimination. If an inductive type in sort Prop has at most one constructor and all arguments of that constructor are in Prop, then Coq allows us to eliminate out of it into all types, not just those in Prop. One argues, I guess, that in this case, the singleton constructor is “uninformative” and so it causes no harm to eliminate out of it.

In particular, since equality/identity types can be defined as an inductive family using only one constructor which takes no arguments, this rule applies to them. Hence, Coq’s Prop-valued equality has exactly the same universal property as the Type-valued path-types, and so they are equivalent.

(It’s a tiny bit tricky to prove this in Coq, though, since the induction principles that Coq builds for inductive types of sort Prop are hamstrung compared to those for ordinary inductive types: they don’t allow for dependency of the target on the inductive type itself. This is, again, in keeping with the “proof-irrelevance” philosophy; nothing can depend interestingly on an inhabitant of a proposition. However, Coq’s induction principles like eq_rect are not basic but are implemented in terms of match syntax, and the latter still allows full dependent elimination even for inductive types in Prop. We can tell Coq to build us a better induction principle for eq by saying Scheme eq_ind' := Induction for eq Sort Prop., and then use it with induction p using eq_ind'.)

It follows that if we add to Coq an axiom which contradicts extensionality (such as univalence), then while the type system need not become inconsistent (since, as I said, nowhere internally does Coq enforce proof-irrelevance for Prop), the extraction process (which does assume proof-irrelevance) becomes inconsistent. What I mean by that is, assuming univalence (and nothing else), we can define a term inside of Coq which extracts to a term claiming to inhabit the empty type.

How does this work? First consider a simpler claim: we can define a term X : bool and prove in Coq that X = true, yet observe that X extracts to false. To define such an X, consider the automorphism not : bool -> bool. It’s easy to prove that this is an equivalence, so by univalence, it induces a path from bool to itself (as a term of type Type). Since path-types are equivalent to eq-types, this induces an inhabitant of Coq’s Prop-valued equality bool = bool. Now, eliminate along this equality to transport false : bool into a new term X : bool.

Since transporting along a path in Type is equivalent to applying the equivalence it came from, X is provably equal to not false, i.e. to true. However, upon extraction, the Prop-valued equality proof bool = bool is discarded, and we are left only with false.

Now we simply define a family P : bool -> Type for which P true := unit and P false := Empty. Since X is provably true, we can define in Coq an inhabitant of P X, and upon extraction this will give us a term of type Empty. (Thanks to Peter Lumsdaine for pointing out this improvement of my example.) Rather than supply the code, I’ll leave formalizing this as an amusing exercise.

So what is this term of the empty type that we get when we do the extraction? To express it, the extractor has to resort to Obj.magic (in the case of ML) or unsafeCoerce (in the case of Haskell), both of which are end-runs around the type system: they convert a value of any type to one of any other type. But even worse, the extractor actually extracts empty types to unit types for both languages — thereby sadly depriving us of the chance to find out what an inhabitant of the empty type looks like.

The point of all this silliness, of course, is that if we want to add univalence to Coq and at the same time continue to use it to develop verified software, something has to give. Specifically, the extractor should really only be throwing away terms that inhabit h-props. So if we want to use Prop as a syntactic marker meaning “bath-water”, then we need to enforce that all types in Prop are h-props — or at least ensure that it is consistent to suppose that they are. (We might want to use Prop to store type information that isn’t provably an h-prop, just as a marker to tell the extractor to throw that information away.)

And finally, that means that singleton elimination will no longer be valid — at least, not in the generality with which Coq currently permits it. We ought still to be able to characterize a subclass of singleton eliminations that are valid, including eq for h-sets — which applies to most data types encountered in real-world programming — but not eq for arbitrary types. But that’s probably another blog post.

Inductive types in Homotopy Type Theory, S. Awodey, N. Gambino, K. Sojakova, January 2012, arXiv:1201.3898v1.

The main theorem is that in HoTT, what we call the rules for homotopy W-types are equivalent to the existence of homotopy-initial algebras for polynomial functors. The required definitions are as follows:

• the rules for homotopy W-types: the usual rules for W-types of formation, introduction, (dependent) elimination, and computation — but the latter is formulated as a propositional rather than a definitional equality.
• a weak map of algebras is a map together with an identity proof , where is the polynomial functor, and a -algebra is just a map , as usual.
• an algebra is homotopy-initial if for every algebra , the type of all weak maps is contractible.

So in brief, the extensional situation where “W-type = initial -algebra” now becomes “homotopy W-type = homotopy-initial -algebra”. Perhaps not very surprising, once one finds the right concepts; but satisfying nonetheless.

We focus mainly on W-types because most conventional inductive types like can be reduced to these; in fact, the possibility of such reductions is itself part of our investigation. There are some results in extensional type theory (cited in the paper) showing that many inductive types are reducible to W-types, and there is some literature (also cited) showing how such reductions can fail in the purely intensional theory. We show that in HoTT some of these reductions go through, provided both the W-types and the inductive types are understood in the appropriate “homotopical” way, with propositional computation rules. The detailed investigation of more such reductions is left as future work.

Of course, the entire development has been formalized in Coq. The files are available in the HoTT repo on GitHub:

https://github.com/HoTT/HoTT/tree/master/Coq/IT

There are also some slides (and even a video somewhere) from a talk I recently gave about this at the MAP Workshop, at the Lorentz Center in Leiden. These can be found here.

The punchline is, roughly: all forms of functional extensionality seem to be derivable from almost the weakest form you might think of. In the terminology of Richard’s paper, [Π-ext] and [Π-ext-comp] together imply [Π-ext-app], [Π-Id-elim], and so on; and in fact even the assumption of [Π-ext-comp] is negotiable.

Coq code for most of what I say here can be found in my fork of Funext.v.

The most traditional form of functional extensionality is the statement

Naive functional extensionality: If functions take equal values, then they are equal.

We can put a nice gloss on this in homotopical language. If f, g are dependent functions of type ∏_x:A B_x, a homotopy h: f == g is a function giving for each x:A a path h(x) : f(x) = g(x). Then naive functional extensionality just posits a map ext_f,g: (f == g) → (f = g), converting homotopies to paths. (This is the rule [Π-ext] in Richard’s paper.)

In a world where UIP held, this would be quite satisfactory on its own. But with non-trivial path spaces, one often needs to know more!

For instance, when we feed ext the identity homotopy on a function f, it should give just the identity path on f, not some potentially non-trivial loop. In other words, we want a path ext-comp f: ext(λx, r(f(x))) = r(f). Or we could even ask this to be a definitional equality; this is [Π-ext-comp] in Richard’s paper, and if we think of ext as an eliminator, this is the appropriate computation rule, telling us how it acts on canonical forms. Let’s call our propositional version [Π-ext-comp-prop].

On the other hand, we might want to know at least something about how the paths produced by ext behave under path-elimination. In particular, there’s always a canonical function going in the opposite direction, converting homotopies into paths: happly_f,g: (f = g) → (f == g). (It’s defined just by path-elimination.) If we produce a path with ext and then take it back with happly, we’d like to get back the homotopy we first thought of, i.e. to have for each h a path ext-app h: happly(ext h) = h.

This is easily interderivable with [Π-ext-app] in the paper; again it has an associated computation principle, [Π-ext-app-comp], but this will be a bit peripheral to our main story, so I won’t go into its details.

In other words, though, [Π-ext-app] just says that ext_f,g is a right up-to-homotopy inverse for happly_f,g. So we could also consider the principle that it should be a left homotopy inverse for happly_f,g — except that we already have, pretty much! It’s easy to show — try it as an exercise! — that [Π-ext-comp-prop] is equivalent to ext_f,g being a left homotopy inverse for happly_f,g.

So, taken together [Π-ext], [Π-ext-comp-prop], and [Π-ext-app] imply that happly_f,g is an equivalence; and on the other hand, it clearly implies them all back. So this can be taken as an alternative form of functional extensionality:

Strong functional extensionality: The canonical map happly_f,g: (f = g) → (f == g) is an equivalence.

This is more clearly a homotopically-good statement than the others. In particular, being an equivalence is a mere proposition — so in assuming this, we don’t need to worry about the particular choice of witness being canonical in any sense. No computation rules needed!

Richard Garner doesn’t discuss this statement in the paper, but he has a closely related rule [Π-Id-elim], which together with its computation rule [Π-Id-elim-comp] says that the types of homotopies (f == g) have the same universal property as the path types (f = g), with the identity homotopy playing the role of the identity path. It’s not hard to show that modulo making [Π-Id-elim-comp] propositional, this is equivalent to strong functional extensionality — an instance of the general principle that two things with the same universal property should be equivalent.

So now, the question is: to what extent does naive functional extensionality — [Π-ext] alone — imply any of the others?

For a warmup, let’s think about [Π-ext-comp]. Does [Π-ext] imply it? Yes and no. [Π-ext-comp] is an assertion about the specific witness ext for [Π-ext]; and while an arbitrary witness ext may not necessarily satisfy [Π-ext-comp], but it can always be “corrected” to one that does. Proof? Try this, it’s a nice exercise; solution here.

So, that’s an encouraging start! Can we similarly get from these to [Π-ext-app], or equivalently to strong functional extensionality? It’s far from obvious; but this was the surprising theorem that I originally found in Funext.v:

Theorem (Voevodsky). Naive functional extensionality implies strong functional extensionality.

What follows is my distillation of the proof I first found, which was itself a cleanup by Mike Shulman of Voevodsky’s original proof. It’s still fairly fiddly, though; so if you’re not in the mood, I recommend skipping to the end.

From what we’ve seen above, it’s enough to show:

Theorem. [Π-ext] and [Π-ext-comp-prop] imply [Π-ext-app].

Proof. We need to show that for any functions f, g and homotopy f: g == h, we can construct some path happly(ext h) = h.

Fix f, and think of g and h as varying. In the case where (g,h) is the pair (f,(λx. r(f(x)))), it’s easy to construct the desired path, using [Π-ext-comp-prop] together with the computational behaviour of happly.

So to show it for arbitrary g,h, it’s sufficent to give a path from the pair (g,h) to the pair (f,(λx. r(f(x)))). In other words, we want to show that the space of such pairs (g,h) is contractible. (This statement itself could be considered as another form of functional extensionality.)

To do this, we’ll look at the space of such pairs as a retract, up to homotopy, of another space — of functions into pairs — which we’ll then show contractible. In other words, we need to show two lemmas:

Lemma 1. Assume [Π-ext]. Given any function f : ∏_x:A B_x, the space of pairs of functions { g : ∏_x:A B_x & h : f == g } is a retract up to homotopy of the space of functions into pairs, ∏_x:A { y : B_x & p : x = y }. (I’m using roughly Coq’s notation for Σ-types here; I hope it’s clear what it means.)

Lemma 2. Assume [Π-ext]. Then for any f as above, the type ∏_x:A { y : B_x & p : x = y } is contractible.

Proof of Lemma 1. It’s easy to write down functions going between the two types. To see that they give a retraction, take a pair (g,h), and send it out and back; what we get back is the pair ((λx. gx),(λx. hx)) — with η-expansions of the original functions. So, we need to use an η-rule somehow.

Since we have functional extensionality, it’s easy to show the necessary η-rule: any function k has a path η_k to its own η-expansion. But using it is a little subtle: we’re trying to construct a path between pairs, (g,h) = ((λx. gx),(λx. hx)), and the obvious thing to try is the fact that a path between pairs comes from a pair of paths. But if we do that, using η_g as the first path, then the second path needed involves transport along η_g — and the behaviour under transport of terms produced from ext is exactly what we’re trying to get a handle on in the first place!

Instead, we approach it a bit differently: we use the η-rule at the point where the hypotheses g,h are introduced. So given g, but with h still generalised, we want to show that for all h, (g,h) = ((λx. gx),(λx. hx)). By eta-expansion, it’s enough to show this with (λx. gx) in place of g: so, that for all appropriate h, ((λx. gx),h) = ((λx. gx),(λx. hx)). Only then do we introduce h; and this time, there’s no transport along η_g involved in the goal, so we’re home and dry.

(This approach to η-expansion — essentially, assuming as soon as a function is introduced that WLOG it’s already η-expanded — seems to work quite cleanly in general, so I wrapped it up in a couple of tactics eta_intro, eta_expand, which others may also find useful. They’re still a bit limited, though, so someone with more Ltac experience might well be able to improve them, which would be great! Of course, if Coq gets a definitional η-rule then these won’t be necessary…)

Proof of Lemma 2. We need to show that given f as above, the type ∏_x:A { y : B_x & p : x = y } is contractible. Certainly, for each individual x the type { y : B_x & p : x = y } is contractible — you probably knew it already, and if not, it’s nice and easy to prove.

But now, by [Π-ext], it’s easy to show that a product of contractible spaces is contractible; so we’re done! □

(In the code, I handle the contractibility statements slightly differently. Contractibility seems the conceptually clearer way of stating them; but one can make the overall proof slightly more compact by working just with the contractions, since the basepoints in all cases are obvious.

We thus have strong functional extensionality from weak — and moreover, we have a kicker:

Scholium. If the witness ext-app for [Π-ext-app] is as constructed as above, and moreover [Π-ext-comp] holds definitionally, then so does [Π-ext-app-comp].

Proof. By appropriate contemplation of the preceding proof. □

(Unlike the rest, this can’t be formalised in Coq, since one can’t take a definitional equality as a hypothesis.) The results of Section 5 of Garner then show that these imply the definitional forms of [Π-Id-elim(-comp)] and other rules.

So — what’s the moral of this proof? It was moderately long and rather fiddly; but what actually makes the whole thing tick? I’d say: Σ-types. We’re trying to show how paths produced by ext behave under happly, or more generally under path-elimination. The retraction of Lemma 2 lets us relate them to paths in Σ-types; and for paths in Σ-types, or rather for their projections to the base space, we do know something about transport, thanks to their “second projections” to a path in a fiber. And this is just enough that with some leverage, we can work up to the more general statements.

Extra bonus exercise. In the view of [Π-ext-comp-prop] and [Π-ext-app] as making ext an inverse to happly, what does [Π-ext-app-comp-prop] correspond to?

Hopefully some people will find some use for it. It is pretty slowly going, and it might motivate some of the strange things going on in Equivalences.v.

• As Steve Awodey mentioned, the (effective epi, mono) factorization system is an example. It can be constructed inside type theory using the higher inductive type is_inhab (see here), which is a version of the Awodey-Bauer “bracket” operation on types.
• More generally, we should be able to construct the n-truncated factorization system for any n, once we write down the n-truncation as a HIT. In particular, for n=0 we get as the reflector.
• There’s one that we can construct without any HITs: any h-proposition U gives rise to an open subtopos whose reflector is fun A => U -> A (see here). The objects of the subcategory are those for which const : A -> (U -> A) is an equivalence.
• I think we should be able to construct closed subtoposes using the HIT that defines homotopy pushouts (the reflector there should take A to the pushout of the two projections ), but I haven’t checked this yet.

However, in category theory (and -category theory) there is an important, uniform way of constructing reflective subcategories and factorization systems — by localization. Given a family of maps F, we define an object X to be F-local if is an equivalence for all in F. When F is small in a well-behaved category (such as a Grothendieck topos), the F-local objects are a reflective subcategory, and moreover every (accessible) reflective subcategory arises in this way.

Can we mimic this in type theory? Given a family of maps

Hypothesis I : Type.
Hypothesis S T : I -> Type.
Hypothesis f : forall i, S i -> T i.

it’s easy to define locality:

Definition is_local Z := forall i,
  is_equiv (fun g : T i -> Z => g o f i).

but how can we prove the local objects are reflective? In both classical homotopy theory and -category theory, the reflector is obtained with a transfinite cell-complex construction (sometimes disguised by other machinery, such as accessibility). But this is exactly the sort of thing that higher inductive types do even better! Consider the following HIT (I’ve switched to using the notation == for identity/path types, following a discussion on the HoTT mailing list):

Inductive localize X :=
| to_local : X -> localize X
| local_extend : forall (i:I) (h : S i -> localize X),
    T i -> localize X
| local_extension : forall (i:I) (h : S i -> localize X) (s : S i),
    local_extend i h (f i s) == h s
| local_unextension : forall (i:I) (g : T i -> localize X) (t : T i),
    local_extend i (g o f i) t == g t
| local_triangle : forall (i:I) (g : T i -> localize X) (s : S i),
    local_unextension i g (f i s) == local_extension i (g o f i) s.

The first constructor to_local says that localize X comes with a map from X. And the other four say exactly that localize X is F-local! Specifically, the second constructor local_extend says that any map S i -> localize X can be extended along f i to T i. The third says that this extension is an extension (that is, the extension operation is right inverse to restriction), while the fourth says that it is left inverse, and the fifth supplies one triangle identity for these homotopies. Thus, together they form an element of the space of “adjoint equivalence data” for fun g : T i -> localize X => g o f i, which is an h-proposition that’s equivalent to Voevodsky’s definition of is_equiv.

Axiomatizing localize in Coq as usual for HITs, I’ve been able to prove that it does, in fact, make the local objects into a reflective subfibration, in the sense discussed here. The code (still rather ugly, alas) can be found here. The reason we can get a reflective subfibration rather than merely a reflective subcategory is that we are automatically performing an internal localization: the local objects see the maps f i as equivalences not only on external hom-spaces (which we don’t have access to internally anyway) but on the internal-homs. (More precisely, they see all pullbacks of F along maps into I as equivalences, which means that if I is interesting, it influences the localization as well — see below.) As discussed here, being this sort of internal localization is exactly what we need to make a reflective subcategory into a reflective subfibration — and conveniently, the latter is also exactly what we can describe internally.

In other words, higher inductive types allow us to construct localizations by just saying “the localization of X is the universal object equipped with a map from X and which is local,” which is exactly what we want. I find this very intuitively attractive and quite pleasing. It also makes very precise the vague idea mentioned here that is “inductively generated” by X together with “sharpness” — here “sharpness” means “F-locality”, and the inductive type says exactly that.

Moreover, lots of useful things are special cases of localization:

• The (-1)-truncation is_inhab is equivalently localization at .
• Similarly, the n-truncation is localization at .
• The reflector of an open subtopos is equivalently localization at .
• Modulo size questions, every reflective subcategory is a localization (at the large class of maps inverted by the reflector).
• Unlike Set, which (classically) has no interesting reflective subcategories, has many interesting reflective subcategories even classically, many of which are naturally constructed as localizations. Moreover, since in the internal and external-homs are identical, all these localizations are internal. For instance, in classical homotopy theory, it is important to be able to localize a space by “inverting a prime number”. One way to do this is to localize at the degree-p map . Another way (probably distinct in general, but agreeing for a large class of spaces) is to localize at the class of -homology isomorphisms (which is not small, but you can find a small generating set for it). We might be able to do this in type theory if we knew how to define homology.
• Any -topos is a (left exact) localization of an -category of presheaves. Thus, combining this with my previous post, we should be able to reduce the question of modeling univalence in -toposes to the case of presheaf -toposes. Moreover, if the HIT localize satisfies the computation rule for the constructor to_local definitionally (this is a 0-level constructor, which are the ones that it’s most sensible to expect to have definitional computation), then the corresponding should also have definitional computation, so that we can model (higher) inductive types in the subcategory strictly as well.

It’s natural to ask what properties of the family F being localized at will make the reflective subfibration into a stable factorization system or a lex-reflective subcategory. The main result in that direction I have is that we get a stable factorization system if the family of targets T is constant at the terminal object. In this case, what we are essentially doing is localizing at the class of all pullbacks of the projection . And as discussed here, localization at a pullback-stable class always gives a stable factorization system. I don’t know any general conditions on F to ensure that we get a lex-reflective subcategory, though.