Homotopy Type Theory

HoTT at JMM

Posted on 13 November 2017 by Mike Shulman

At the 2018 U.S. Joint Mathematics Meetings in San Diego, there will be an AMS special session about homotopy type theory. It’s a continuation of the HoTT MRC that took place this summer, organized by some of the participants to especially showcase the work done during and after the MRC workshop. Following is the announcement from the organizers.

We are pleased to announce the AMS Special Session on Homotopy Type Theory, to be held on January 11, 2018 in San Diego, California, as part of the Joint Mathematics Meetings (to be held January 10 – 13).

Homotopy Type Theory (HoTT) is a new field of study that relates constructive type theory to abstract homotopy theory. Types are regarded as synthetic spaces of arbitrary dimension and type equality as homotopy equivalence. Experience has shown that HoTT is able to represent many mathematical objects of independent interest in a direct and natural way. Its foundations in constructive type theory permit the statement and proof of theorems about these objects within HoTT itself, enabling formalization in proof assistants and providing a constructive foundation for other branches of mathematics.

This Special Session is affiliated with the AMS Mathematics Research Communities (MRC) workshop for early-career researchers in Homotopy Type Theory organized by Dan Christensen, Chris Kapulkin, Dan Licata, Emily Riehl and Mike Shulman, which took place last June.

The Special Session will include talks by MRC participants, as well as by senior researchers in the field, on various aspects of higher-dimensional type theory including categorical semantics, computation, and the formalization of mathematical theories. There will also be a panel discussion featuring distinguished experts from the field.

Further information about the Special Session, including a schedule and abstracts, can be found at: http://jointmathematicsmeetings.org/meetings/national/jmm2018/2197_program_ss14.html.
Please note that the early registration deadline is December 20, 2017.

If you have any questions about about the Special Session, please feel free to contact one of the organizers. We look forward to seeing you in San Diego.

Simon Cho (University of Michigan)
Liron Cohen (Cornell University)
Ed Morehouse (Wesleyan University)

Posted in News, Publicity | Leave a comment

Impredicative Encodings of Inductive Types in HoTT

Posted on 11 October 2017 by Sam Speight

I recently completed my master’s thesis under the supervision of Steve Awodey and Jonas Frey. A copy can be found here.

Known impredicative encodings of various inductive types in System F, such as the type

$\forall X. (X\rightarrow X) \rightarrow X \rightarrow X,$

of natural numbers do not satisfy the relevant $\eta$ -computation rules. The aim of this work is to refine the System F encodings by moving to a system of HoTT with an impredicative universe, so that the relevant $\eta$ -rules are satisfied (along with all the other rules). As a result, the so-determined types have their expected universal properties. The main result is the construction of a type of natural numbers which is the initial algebra for the expected endofunctor $X\mapsto X+\mathbf{1}$ .

For the inductive types treated in the thesis, we do not use the full power of HoTT; we need only postulate $\Sigma$ -types, identity types, “large” $\Pi$ -types over an impredicative universe $\mathcal{U}$ and function extensionality. Having large $\Pi$ -types over an impredicative universe $\mathcal{U}$ means that given a type $\Gamma\vdash A \:\mathsf{type}$ and a type family $\Gamma, x:A \vdash B:\mathcal{U}$ , we may form the dependent function type

$\displaystyle{ \Gamma\vdash \prod_{x:A} B:\mathcal{U}}.$

Note that this type is in $\mathcal{U}$ even if $A$ is not.

We obtain a translation of System F types into type theory by replacing second order quantification by dependent products over $\mathcal U$ (or alternatively over the subtype of $\mathcal{U}$ given by some h-level).

For brevity, we will focus on the construction of the natural numbers (though in the thesis, the coproduct of sets and the unit type is first treated with special cases of this method). We consider categories of algebras for endofunctors:

$T:\mathbf{Set}\rightarrow\mathbf{Set},$

where the type of objects of $\mathbf{Set}$ is given by

$\mathsf{Set} :\equiv \displaystyle{\sum_{X:\mathcal{U}}}\mathsf{isSet}(X),$

(the type of sets (in $\mathcal{U}$ )) and morphisms are simply functions between sets.

We can write down the type of $T$ -algebras:

$\mathsf{TAlg} :\equiv \displaystyle{\sum_{X:\mathsf{Set}}} T(X)\rightarrow X$

and homomorphisms between algebras $\phi$ and $\psi$ :

$\mathsf{THom}(\phi,\psi) :\equiv \displaystyle{\sum_{f:\mathsf{pr_1}(\phi)\rightarrow\mathsf{pr_1}(\psi)}} \mathsf{pr_2}(\psi) \circ T(f) = f \circ \mathsf{pr_2}(\phi),$

which together form the category $\mathbf{TAlg}$ .

We seek the initial object in $\mathbf{TAlg}$ . Denote this by $0$ and moreover let $U$ be the forgetful functor to $\mathbf{Set}$ and $y:\mathbf{TAlg}^{\textnormal{op}}\rightarrow \mathbf{Set}^{\mathbf{TAlg}}$ be the covariant Yoneda embedding. We reason as follows:

$U0 \cong \textnormal{Hom}_{\mathbf{Set}^\mathbf{TAlg}}(y0,U) \\{}\:\,\,\,\,\,\, = \textnormal{Hom}_{\mathbf{Set}^\mathbf{TAlg}}(1,U) \\{}\:\,\,\,\,\,\, = \textnormal{Hom}_{\mathbf{Set}^\mathbf{TAlg}}(\Delta 1,U) \\{}\:\,\,\,\,\,\, = \textnormal{Hom}_{\mathbf{Set}}(1, \textnormal{lim}_{\phi\in\textbf{TAlg}} U\phi) \\{}\:\,\,\,\,\,\, \cong \textnormal{lim}_{\phi\in\textbf{TAlg}} U\phi,$

using the fact that the diagonal functor is left adjoint to the limit functor for the last step. With this, we have a proposal for the definition of the underlying set of the initial $T$ -algebra as the limit of the forgetful functor. Using the fact that $U0$ is defined as a limit, we obtain an algebra structure $\epsilon:TU0\rightarrow U0$ . As $U$ creates limits, $(U0,\epsilon)$ is guaranteed to be initial in $\mathbf{TAlg}$ .

But we want to define $U0$ in type theory. We do this using products and equalizers as is well known from category theory. Explicitly, we take the equalizer of the following two maps between products:

$P_1,P_2 : \left(\displaystyle{\prod_{\phi:\mathbf{TAlg}}}U(\phi)\right) \rightarrow \displaystyle{\prod_{\phi,\psi:\mathbf{TAlg}}} \: \displaystyle{\prod_{\mu:\mathbf{THom}(\phi,\psi)}}U(\psi),$

given by:

$P_1 :\equiv \lambda\Phi.\lambda\phi.\lambda\psi.\lambda\mu.\Phi(\psi), \\ P_1 :\equiv \lambda\Phi.\lambda\phi.\lambda\psi.\lambda\mu. \mathsf{pr_1}(\mu)(\Phi(\phi)).$

The equalizer is, of course:

$E :\equiv \displaystyle{\sum_{\Phi : \prod_{(\phi:\mathbf{TAlg})} U(\phi)}} P_1(\Phi)=P_2(\Phi),$

which inhabits $\mathsf{Set}$ . Impredicativity is crucial for this: it guarantees that the product over $\mathbf{TAlg}$ lands in $\mathcal{U}$ .

This method can be used to construct an initial algebra, and therefore a fixed-point, for any endofunctor $T : \mathsf{Set}\rightarrow\mathsf{Set}\,$ ! We won’t pursue this remarkable fact here, but only consider the case at hand, where the functor $T$ is $X\mapsto X+\mathbf{1}$ . Then the equalizer $E$ becomes our definition of the type of natural numbers (so let us rename $E$ to $\mathbb{N}$ for the remainder). Observe that this encoding can be seen as a subtype of (a translation of) the System F encoding given at the start. Indeed, the indexing object $\prod_{(\phi:\mathbf{TAlg})} U(\phi)$ of $E$ is equivalent to $\prod_{(X:\mathbf{Set})}(X\rightarrow X)\rightarrow X \rightarrow X$ , by

$\begin{aligned} \quad\quad\displaystyle{\prod_{\phi:\mathbf{TAlg}}} U(\phi) \quad &\cong\quad \displaystyle{\prod_{\phi:{\displaystyle{\sum_{X:\mathsf{Set}}} T(X)\rightarrow X}}} U(\phi)\\ &\cong\quad \displaystyle{\prod_{X:\mathsf{Set}}}\, \displaystyle{\prod_{f:T(X)\rightarrow X}} X\\ &\cong\quad \displaystyle{\prod_{X:\mathsf{Set}}}\, (T(X)\rightarrow X) \rightarrow X\\ &\cong\quad \displaystyle{\prod_{X:\mathbf{Set}}}(X\rightarrow X)\rightarrow X \rightarrow X \,. \end{aligned}$

With this, we can define a successor function and zero element, for instance:

$0 :\equiv \left( \lambda\phi. \mathsf{pr_2}(\phi)\mathsf{inr}(\star), \lambda\phi.\lambda\psi.\lambda\mu. \mathsf{refl}_{\mathsf{pr_2}(\psi)\mathsf{inr}(\star)}\right)$

(the successor function takes a little more work). We can also define a recursor $\mathsf{rec}_{\mathbb{N}}(e,c)$ , given any $C:\mathsf{Set}, e:C\rightarrow C$ and $c:C$ . In other words, the introduction rules hold, and we can eliminate into other sets. Further, the $\beta$ -rules hold definitionally – as expected, since they hold for the System F encodings.

Finally we come to the desired result, the $\eta$ -rule for $\mathbb{N}$ :

Theorem. Let $C:\mathsf{Set}, e:C\rightarrow C$ and $c:C$ . Moreover, let $f:\mathbb{N}\rightarrow C$ such that:

$f(0)=c, \\ f(\mathsf{succ}(x) = e(f(x))$

for any $x:\mathbb{N}$ . Then

$\mathsf{rec}_{\mathbb{N}}(e,c) =f.$

Note that the $\eta$ -rule holds propositionally. By Awodey, Gambino, and Sojakova we therefore also have, equivalently, the induction principle for $\mathbb{N}$ , aka the dependent elimination rule. As a corollary, we can prove the universal property that any $T$ -algebra homomorphism is propositionally equal to the appropriate recursor (as a $T$ -algebra homomorphism). Again we emphasise the need for impredicativity: in the proof of $\eta$ , we have to be able to plug $\mathbb{N}$ into quantifiers over $\mathsf{Set}$ .

A semantic rendering of the above is that we have built a type that always determines a natural numbers object—whereas the System F encoding need not always do so (see Rummelhoff). In an appendix, we discuss a realizability semantics for the system we work in. Building more exotic types (that need not be sets) becomes more complicated; we leave this to future work.

Posted in Applications, Foundations, Uncategorized | 5 Comments

In memoriam: Vladimir Voevodsky

Posted on 1 October 2017 by Steve Awodey

VVinLyon

https://www.ias.edu/news/2017/vladimir-voevodsky

Posted in Uncategorized | Leave a comment

A hands-on introduction to cubicaltt

Posted on 16 September 2017 by mortberg

Some months ago I gave a series of hands-on lectures on cubicaltt at Inria Sophia Antipolis that can be found at:

https://github.com/mortberg/cubicaltt/tree/master/lectures

The lectures cover the main features of the system and don’t assume any prior knowledge of Homotopy Type Theory or Univalent Foundations. Only basic familiarity with type theory and proof assistants based on type theory is assumed. The lectures are in the form of cubicaltt files and can be loaded in the cubicaltt proof assistant.

cubicaltt is based on a novel type theory called Cubical Type Theory that provides new ways to reason about equality. Most notably it makes various extensionality principles, like function extensionality and Voevodsky’s univalence axiom, into theorems instead of axioms. This is done such that these principles have computational content and in particular that we can transport structures between equivalent types and that these transports compute. This is different from when one postulates the univalence axiom in a proof assistant like Coq or Agda. If one just adds an axiom there is no way for Coq or Agda to know how it should compute and one looses the good computational properties of type theory. In particular canonicity no longer holds and one can produce terms that are stuck (e.g. booleans that are neither true nor false but don’t reduce further). In other words this is like having a programming language in which one doesn’t know how to run the programs. So cubicaltt provides an operational semantics for Homotopy Type Theory and Univalent Foundations by giving a computational justification for the univalence axiom and (some) higher inductive types.

Cubical Type Theory has a model in cubical sets with lots of structure (symmetries, connections, diagonals) and is hence consistent. Furthermore, Simon Huber has proved that Cubical Type Theory satisfies canonicity for natural numbers which gives a syntactic proof of consistency. Many of the features of the type theory are very inspired by the model, but for more syntactically minded people I believe that it is definitely possible to use cubicaltt without knowing anything about the model. The lecture notes are hence written with almost no references to the model.

The cubicaltt system is based on Mini-TT:

"A simple type-theoretic language: Mini-TT" (2009)
Thierry Coquand, Yoshiki Kinoshita, Bengt Nordström and Makoto Takeya
In "From Semantics to Computer Science; Essays in Honour of Gilles Kahn"

Mini-TT is a variant Martin-Löf type theory with datatypes and cubicaltt extends Mini-TT with:

Path types
Compositions
Glue types
Id types
Some higher inductive types

The lectures cover the first 3 of these and hence correspond to sections 2-7 of:

"Cubical Type Theory: a constructive interpretation of the univalence axiom"
Cyril Cohen, Thierry Coquand, Simon Huber and Anders Mörtberg
To appear in post-proceedings of TYPES 2016
https://arxiv.org/abs/1611.02108

I should say that cubicaltt is mainly meant to be a prototype implementation of Cubical Type Theory in which we can do experiments, however it was never our goal to implement a competitor to any of the more established proof assistants. Because of this there are no implicit arguments, type classes, proper universe management, termination checker, etc… Proofs in cubicaltt hence tend to get quite verbose, but it is definitely possible to do some fun things. See for example:

binnat.ctt – Binary natural numbers and isomorphism to unary numbers. Example of data and program refinement by doing a proof for unary numbers by computation with binary numbers.
setquot.ctt – Formalization of impredicative set quotients á la Voevodsky.
hz.ctt – $\mathbb{Z}$ defined as an (impredicative set) quotient of nat * nat.
category.ctt – Categories. Structure identity principle. Pullbacks. (Due to Rafaël Bocquet)
csystem.ctt – Definition of C-systems and universe categories. Construction of a C-system from a universe category. (Due to Rafaël Bocquet)

For a complete list of all the examples see:

https://github.com/mortberg/cubicaltt/tree/master/examples

For those who cannot live without implicit arguments and other features of modern proof assistants there is now an experimental cubical mode shipped with the master branch of Agda. For installation instructions and examples see:

https://agda.readthedocs.io/en/latest/language/cubical.html
https://github.com/Saizan/cubical-demo

In this post I will give some examples of the main features of cubicaltt, but for a more comprehensive introduction see the lecture notes. As cubicaltt is an experimental prototype things can (and probably will) change in the future (e.g. see the paragraph on HITs below).

The basic type theory

The basic type theory on which cubicaltt is based has Π and ∑ types (with eta and surjective pairing), a universe U, datatypes, recursive definitions and mutually recursive definitions (in particular inductive-recursive definitions). Note that general datatypes and (mutually recursive) definitions are not part of the version of Cubical Type Theory in the paper.

Below is an example of how natural numbers and addition are defined:

data nat = zero
         | suc (n : nat)

add (m : nat) : nat -> nat = split
  zero -> m
  suc n -> suc (add m n)

If one loads this in the cubicaltt read-eval-print-loop one can compute things:

> add (suc zero) (suc zero)
EVAL: suc (suc zero)

Path types

The homotopical interpretation of equality tells us that we can think of an equality proof between a and b in a type A as a path between a and b in a space A. cubicaltt takes this literally and adds a primitive Path type that should be thought of as a function out of an abstract interval $\mathbb{I}$ with fixed endpoints.

We call the elements of the interval $\mathbb{I}$ names/directions/dimensions and typically use i, j, k to denote them. The elements of the interval $\mathbb{I}$ are generated by the following grammar (where dim is a dimension like i, j, k…):

r,s := 0
     | 1
     | dim
     | - r
     | r /\ s
     | r \/ s

The endpoints are 0 and 1, – corresponds to symmetry (r in $\mathbb{I}$ is mapped to 1-r), while /\ and \/ are so called “connections”. The connections can be thought of mapping r and s in $\mathbb{I}$ to min(r,s) and max(r,s) respectively. As Path types behave like functions out of the interval there is both path abstraction and application (just like for function types). Reflexivity is written:

refl (A : U) (a : A) : Path A a a = <i> a

and corresponds to a constant path:

        <i> a
   a -----------> a

with the intuition is that <i> a is a function \(i : ) -> a. However for deep reasons the interval isn’t a type (as it isn’t fibrant) so we cannot write functions out of it directly and hence we have this special notation for path abstraction.

If we have a path from a to b then we can compute its left end-point by applying it to 0:

face0 (A : U) (a b : A) (p : Path A a b) : A = p @ 0

This is of course convertible to a. We can also reverse a path by using symmetry:

sym (A : U) (a b : A) (p : Path A a b) : Path A b a =
  <i> p @ -i

Assuming that some arguments could be made implicit this satisfies the equality

sym (sym p) == p

judgmentally. This is one of many examples of equalities that hold judgmentally in cubicaltt but not in standard type theory where sym would be defined by induction on p. This is useful for formalizing mathematics, for example we get the judgmental equality C^op^op == C for a category C that cannot be obtained in standard type theory with the usual definition of category without using any tricks (see opposite.ctt for a formal proof of this).

We can also directly define cong (or ap or mapOnPath):

cong (A B : U) (f : A -> B) (a b : A) (p : Path A a b) :
     Path B (f a) (f b) = <i> f (p @ i)

Once again this satisfies some equations judgmentally that we don’t get in standard type theory where this would have been defined by induction on p:

cong id p == p
cong g (cong f p) == cong (g o f) p

Finally the connections can be used to construct higher dimensional cubes from lower dimensional ones (e.g. squares from lines). If p : Path A a b then <i j> p @ i /\ j is the interior of the square:

                  p
        a -----------------> b
        ^                    ^
        |                    |
        |                    |
  <j> a |                    | p
        |                    |
        |                    |
        |                    |
        a -----------------> a
                <i> a

Here i corresponds to the left-to-right dimension and j corresponds to the down-to-up dimension. To compute the left and right sides just plug in i=0 and i=1 in the term inside the square:

<j> p @ 0 /\ j = <j> p @ 0 = <j> a   (p is a path from a to b)
<j> p @ 1 /\ j = <j> p @ j = p       (using eta for Path types)

These give a short proof of contractibility of singletons (i.e. that the type (x : A) * Path A a x is contractible for all a : A), for details see the lecture notes or the paper. Because connections allow us to build higher dimensional cubes from lower dimensional ones they are extremely useful for reasoning about higher dimensional equality proofs.

Another cool thing with Path types is that they allow us to give a direct proof of function extensionality by just swapping the path and lambda abstractions:

funExt (A B : U) (f g : A -> B)
       (p : (x : A) -> Path B (f x) (g x)) :
       Path (A -> B) f g = <i> \(a : A) -> (p a) @ i

To see that this makes sense we can compute the end-points:

(<i> \(a : A) -> (p a) @ i) @ 0 = \(a : A) -> (p a) @ 0
                                = \(a : A) -> f a
                                = f

and similarly for the right end-point. Note that the last equality follows from eta for Π types.

We have now seen that Path types allows us to define the constants of HoTT (like cong or funExt), but when doing proofs with Path types one rarely uses these constants explicitly. Instead one can directly prove things with the Path type primitives, for example the proof of function extensionality for dependent functions is exactly the same as the one for non-dependent functions above.

We cannot yet prove the principle of path induction (or J) with what we have seen so far. In order to do this we need to be able to turn any path between types A and B into a function from A to B, in other words we need to be able to define transport (or cast or coe):

transport : Path U A B -> A -> B

Composition, filling and transport

The computation rules for the transport operation in cubicaltt is introduced by recursion on the type one is transporting in. This is quite different from traditional type theory where the identity type is introduced as an inductive family with one constructor (refl). A difficulty with this approach is that in order to be able to define transport in a Path type we need to keep track of the end-points of the Path type we are transporting in. To solve this we introduce a more general operation called composition.

Composition can be used to define the composition of paths (hence the name). Given paths p : Path A a b and q : Path A b c the composite is obtained by computing the missing top line of this open square:

        a                   c
        ^                   ^
        |                   |
        |                   |
  <j> a |                   | q
        |                   |
        |                   |
        |                   |
        a ----------------> b
                p @ i

In the drawing I’m assuming that we have a direction i : in context that goes left-to-right and that the j goes down-to-up (but it’s not in context, rather it’s implicitly bound by the comp operation). As we are constructing a Path from a to c we can use the i and put p @ i as bottom. The code for this is as follows:

compPath (A : U) (a b c : A)
  (p : Path A a b) (q : Path A b c) : Path A a c =
   <i> comp (<_> A) (p @ i)
                    [ (i = 0) -> <j> a
                    , (i = 1) -> q ]

One way to summarize what compositions gives us is the so called “box principle” that says that “any open box has a lid”. Here “box” means (n+1)-dimensional cube and the lid is an n-dimensional cube. The comp operation takes as second argument the bottom of the box and then a list of sides. Note that the collection of sides doesn’t have to be exhaustive (as opposed to the original cubical set model) and one way to think about the sides is as a collection of constraints that the resulting lid has to satisfy. The first argument of comp is a path between types, in the above example this path is constant but it doesn’t have to be. This is what allows us to define transport:

transport (A B : U) (p : Path U A B) (a : A) : B =
  comp p a []

Combining this with the contractibility of singletons we can easily prove the elimination principle for Path types. However the computation rule does not hold judgmentally. This is often not too much of a problem in practice as the Path types satisfy various judgmental equalities that normal Id types don’t. Also, having the possibility to reason about higher equalities directly using path types and compositions is often very convenient and leads to very nice and new ways to construct proofs about higher equalities in a geometric way by directly reasoning about higher dimensional cubes.

The composition operations are related to the filling operations (as in Kan simplicial sets) in the sense that the filling operations takes an open box and computes a filler with the composition as one of its faces. One of the great things about cubical sets with connections is that we can reduce the filling of an open box to its composition. This is a difference compared to the original cubical set model and it provides a significant simplification as we only have to explain how to do compositions in open boxes and not also how to fill them.

Glue types and univalence

The final main ingredient of cubicaltt are the Glue types. These are what allows us to have a direct algorithm for composition in the universe and to prove the univalence axiom. These types add the possibility to glue types along equivalences (i.e. maps with contractible fibers) onto another type. In particular this allows us to directly define one of the key ingredients of the univalence axiom:

ua (A B : U) (e : equiv A B) : Path U A B =
  <i> Glue B [ (i = 0) -> (A,e)
             , (i = 1) -> (B,idEquiv B) ]

This corresponds to the missing line at the top of:

        A           B
        |           |
      e |           | idEquiv B
        |           |
        V           V
        B --------> B
              B

The sides of this square are equivalences while the bottom and top are lines in direction i (so this produces a path from A to B as desired).

We have formalized three proofs of the univalence axiom in cubicaltt:

A very direct proof due to Simon Huber and me using higher dimensional glueing.
The more conceptual proof from section 7.2 of the paper in which we show that the unglue function is an equivalence (formalized by Fabian Ruch).
A proof from ua and its computation rule (uabeta). Both of these constants are easy to define and are sufficient for the full univalence axiom as noted in a post by Dan Licata on the HoTT google group.

All of these proofs can be found in the file univalence.ctt and are explained in the paper (proofs 1 and 3 are in Appendix B).

Note that one often doesn’t need full univalence to do interesting things. So just like for Path types it’s often easier to just use the Glue primitives directly instead of invoking the full univalence axiom. For instance if we have proved that negation is an involution for bool we can directly get a non-trivial path from bool to bool using ua (which is just a Glue):

notEq : Path U bool bool = ua boob bool notEquiv

And we can use this non-trivial equality to transport true and compute the result:

> transport notEq true
EVAL: false

This is all that the lectures cover, in the rest of this post I will discuss the two extensions of cubicaltt from the paper and their status in cubicaltt.

Identity types and higher inductive types

As pointed out above the computation rule for Path types doesn’t hold judgmentally. Luckily there is a neat trick due to Andrew Swan that allows us to define a new type that is equivalent to Path A a b for which the computation rule holds judgmentally. For details see section 9.1 of the paper. We call this type Id A a b as it corresponds to Martin-Löf’s identity type. We have implemented this in cubicaltt and proved the univalence axiom expressed exclusively using Id types, for details see idtypes.ctt.

For practical formalizations it is probably often more convenient to use the Path types directly as they have the nice primitives discussed above, but the fact that we can define Id types is very important from a theoretical point of view as it shows that cubicaltt with Id is really an extension of Martin-Löf type theory. Furthermore as we can prove univalence expressed using Id types we get that any proof in univalent type theory (MLTT extended with the univalence axiom) can be translated into cubicaltt.

The second extension to cubicaltt are HITs. We have a general syntax for adding these and some of them work fine on the master branch, see for example:

circle.ctt – The circle as a HIT. Computation of winding numbers.
helix.ctt – The loop space of the circle is equal to Z.
susp.ctt – Suspension and n-spheres.
torsor.ctt – Torsors. Proof that S1 is equal to BZ, the classifying
space of Z. (Due to Rafaël Bocquet)
torus.ctt – Proof that Torus = S1 * S1 in only 100 loc (due to Dan
Licata).

However there are various known issues with how the composition operations compute for recursive HITs (e.g. truncations) and HITs where the end-points contain function applications (e.g. pushouts). We have a very experimental branch that tries to resolve these issues called “hcomptrans”. This branch contains some new (currently undocumented) primitives that we are experimenting with and so far it seems like these are solving the various issues for the above two classes of more complicated HITs that don’t work on the master branch. So hopefully there will soon be a new cubical type theory with support for a large class of HITs.

That’s all I wanted to say about cubicaltt in this post. If someone plays around with the system and proves something cool don’t hesitate to file a pull request or file issues if you find some bugs.

Posted in Uncategorized | 63 Comments

Type theoretic replacement & the n-truncation

Posted on 31 January 2017 by Egbert Rijke

This post is to announce a new article that I recently uploaded to the arxiv:

https://arxiv.org/abs/1701.07538

The main result of that article is a type theoretic replacement construction in a univalent universe that is closed under pushouts. Recall that in set theory, the replacement axiom asserts that if $F$ is a class function, assigning to any set $X$ a new set $F(X)$ , then the image of any set $A$ , i.e. the set $\{F(X)\mid X\in A\}$ is again a set. In homotopy type theory we consider instead a map $f : A\to X$ from a small type $A:U$ into a locally small type $X$ , and our main result is the construction of a small type $\mathrm{im}(f)$ with the universal property of the image of $f$ .

We say that a type is small if it is in $U$ , and for the purpose of this blog post smallness and locally smallness will always be with respect to $U$ . Before we define local smallness, let us recall the following rephrasing of the `encode-decode method’, which we might also call the Licata-Shulman theorem:

Theorem. Let $A$ be a type with $a:A$ , and let $P: A\to U$ be a type with $p:P(a)$ . Then the following are equivalent.

The total space $\Sigma_{(b:A)} P(b)$ is contractible.
The canonical map $\Pi_{(b:A)} (a=b)\to P(b)$ defined by path induction, mapping $\mathrm{refl}_a$ to $p$ , is a fiberwise equivalence.

Note that this theorem follows from the fact that a fiberwise map is a fiberwise equivalence if and only if it induces an equivalence on total spaces. Since for path spaces the total space will be contractible, we observe that any fiberwise equivalence establishes contractibility of the total space, i.e. we might add the following equivalent statement to the theorem.

There (merely) exists a family of equivalences $e:\Pi_{(b:B)} (a=b)\simeq P(b)$ . In other words, $P$ is in the connected component of the type family $b\mapsto (a=b)$ .

There are at least two equivalent ways of saying that a (possibly large) type $X$ is locally small:

For each $x,y:X$ there is a type $(x='y):U$ and an equivalence $e_{x,y}:(x=y)\simeq (x='y)$ .
For each $x,y:X$ there is a type $(x='y):U$ ; for each $x:X$ there is a term $r_X:x='x$ , and the canonical dependent function $\Pi_{(y:X)} (x=y)\to (x='y)$ defined by path induction by sending $\mathrm{refl}_x$ to $r_x$ is an equivalence.

Note that the data in the first structure is clearly a (large) mere proposition, because there can be at most one such a type family $(x='y)$ , while the equivalences in the second structure are canonical with respect to the choice of reflexivity $r_x$ . To see that these are indeed equivalent, note that the family of equivalences in the first structure is a fiberwise equivalence, hence it induces an equivalence on total spaces. Therefore it follows that the total space $\Sigma_{(y:X)} (x='y)$ is contractible. Thus we see by Licata’s theorem that the canoncial fiberwise map is a fiberwise equivalence. Furthermore, it is not hard to see that the family of equivalences $e_{x,y}$ is equal to the canonical family of equivalences. There is slightly more to show, but let us keep up the pace and go on.

Examples of locally small types include any small type, any mere proposition regardless of their size, the universe is locally small by the univalence axiom, and if $A$ is small and $X$ is locally small then the type $A\to X$ is locally small. Observe also that the univalence axiom follows if we assume the `uncanonical univalence axiom’, namely that there merely exists a family of equivalences $e_{A,B} : (A=B)\simeq (A\simeq B)$ . Thus we see that the slogan ‘identity of the universe is equivalent to equivalence’ actually implies univalence.

Main Theorem. Let $U$ be a univalent universe that is closed under pushouts. Suppose that $A:U$ , that $X$ is a locally small type, and let $f:A\to X$ . Then we can construct

a small type $\mathrm{im}(f):U$ ,
a factorization
such that $i_f$ is an embedding that satisfies the universal property of the image inclusion, namely that for any embedding $g$ , of which the domain is possibly large, if $f$ factors through $g$ , then so does $i_f$ .

Recall that $f$ factors through an embedding $g$ in at most one way. Writing $\mathrm{Hom}_X(f,g)$ for the mere proposition that $f$ factors through $g$ , we see that $i_f$ satisfies the universal property of the image inclusion precisely when the canonical map

$\mathrm{Hom}_X(i_f,g)\to\mathrm{Hom}_X(f,g)$

is an equivalence.

Most of the paper is concerned with the construction with which we prove this theorem: the join construction. By repeatedly joining a map with itself, one eventually arrives at an embedding. The join of two maps $f:A\to X$ and $g:B\to X$ is defined by first pulling back, and then taking the pushout, as indicated in the following diagram

join_maps

In the case $X \equiv \mathbf{1}$ , the type $A \ast_X B$ is equivalent to the usual join of types $A \ast B$ . Just like the join of types, the join of maps with a common codomain is associative, commutative, and it has a unit: the unique map from the empty type into $X$ . The join of two embeddings is again an embedding. We show that the last statement can be strengthened: the maps $f:A\to X$ that are idempotent in a canonical way (i.e. the canonical morphism $f \to f \ast f$ in the slice category over $X$ is an equivalence) are precisely the embeddings.

Below, I will indicate how we can use the above theorem to construct the n-truncations for any $n\geq -2$ on any univalent universe that is closed under pushouts. Other applications include the construction of set-quotients and of Rezk-completion, since these are both constructed as the image of the Yoneda-embedding, and it also follows that the univalent completion of any dependent type $P:A\to U$ can be constructed as a type in $U$ , namely $\mathrm{im}(P)$ , without needing to resort to more exotic higher inductive types. In particular, any connected component of the universe is equivalent to a small type.

Theorem. Let $U$ be a univalent universe that is closed under pushouts. Then we can define for any $n\geq -2$

an n-truncation operation $\|{-}\|_n:U\to U$ ,
a map $|{-}|:\Pi_{(A:U)} A\to \|A\|_n$
such that for any $A:U$ , the type $\|A\|_n$ is n-truncated and satisfies the (dependent) universal property of n-truncation, namely that for every type family $P:\|A\|_n\to\mathrm{Type}$ of possibly large types such that each $P(x)$ is n-truncated, the canonical map
$(\Pi_{(x:\|A\|_n)} P(x))\to (\Pi_{(a:A)} P(|a|_n))$
given by precomposition by $|{-}|_n$ is an equivalence.

Construction. The proof is by induction on $n\geq -2$ . The case $n\equiv -2$ is trivial (take $A\mapsto \mathbf{1}$ ). For the induction hypothesis we assume an n-truncation operation with structure described in the statement of the theorem.

First, we define $\mathcal{Y}_n:A\to (A\to U)$ by $\mathcal{Y}_n(a,b):\equiv \|a=b\|_n$ . As we have seen, the universe is locally small, and therefore the type $A\to U$ is locally small. Therefore we can define

$\|A\|_{n+1} :\equiv \mathrm{im}(\mathcal{Y}_n)$
$|{-}|_{n+1} :\equiv q_{\mathcal{Y}_n}$ .

For the proof that $\|A\|_{n+1}$ is indeed $(n+1)$ -truncated, and satisfies the universal property of the n-truncation we refer to the article.

Posted in Uncategorized | Leave a comment

Parametricity, automorphisms of the universe, and excluded middle

Posted on 26 January 2017 by Auke Booij

Specific violations of parametricity, or existence of non-identity automorphisms of the universe, can be used to prove classical axioms. The former was previously featured on this blog, and the latter is part of a discussion on the HoTT mailing list. In a cooperation between Martín Escardó, Peter Lumsdaine, Mike Shulman, and myself, we have strengthened these results and recorded them in a paper that is now on arXiv.

In this blog post, we work with the full repertoire of HoTT axioms, including univalence, propositional truncations, and pushouts. For the paper, we have carefully analysed which assumptions are used in which theorem, if any.

Parametricity

Parametricity is a property of terms of a language. If your language only has parametric terms, then polymorphic functions have to be invariant under the type parameter. So in MLTT, the only term inhabiting the type $\prod_{X:\mathcal{U}}X \to X$ of polymorphic endomaps is the polymorphic identity $\lambda (X:\mathcal{U}). \mathsf{id}_X$ .

In univalent foundations, we cannot prove internally that every term is parametric. This is because excluded middle is not parametric (exercise 6.9 of the HoTT book tells us that, assuming LEM, we can define a polymorphic endomap that flips the booleans), but there exist classical models of univalent foundations. So if we could prove this internally, excluded middle would be false, and thus the classical models would be invalid.

In the abovementioned blog post, we observed that exercise 6.9 of the HoTT book has a converse: if $f:\prod_{X:\mathcal{U}}X\to X$ is the flip map on the type of booleans, then excluded middle holds. In the paper on arXiv, we have a stronger result:

Theorem. There exist $f:\prod_{X:\mathcal{U}}X\to X$ and a type $X$ and a point $x:X$ with $f_X(x)\neq x$ if and only if excluded middle holds.

Notice that there are no requirements on the type $X$ or the point $x$ . We have also applied the technique used for this theorem in other scenarios, for example:

Theorem. There exist $f:\prod_{X:\mathcal{U}}X\to \mathbf{2}$ and types $X, Y$ and points $x:X, y:Y$ with $f_X(x)\neq f_Y(y)$ if and only if weak excluded middle holds.

The results in the paper illustrate that different violations of parametricity have different proof-theoretic strength: some violations are impossible, while others imply varying amounts of excluded middle.

Automorphisms of the universe

In contrast to parametricity, which proves that terms of some language necessarily have some properties, it is currently unknown if non-identity automorphisms of the universe are definable in univalent foundations. But some believe that this may not be the case.

In the presence of excluded middle, we can define non-identity automorphisms of the universe. Given a type $X$ , we use excluded middle to decide if $X$ is a proposition. If it is, we map $X$ to $\neg X$ , and otherwise we map $X$ to itself. Assuming excluded middle, we have $\neg\neg X=X$ for any proposition, so this is an automorphism.

The above automorphism swaps the empty type $\mathbf{0}$ with the unit type $\mathbf{1}$ and leaves all other types unchanged. More generally, assuming excluded middle we can swap any two types with equivalent automorphism ∞-groups, since in that case the corresponding connected components of the universe are equivalent. Still more generally, we can permute arbitrarily any family of types all having the same automorphism ∞-group.

The simplest case of this is when all the types are rigid, i.e. have trivial automorphism ∞-group. The types $\mathbf{0}$ and $\mathbf{1}$ are both rigid, and at least with excluded middle no other sets are; but there can be rigid higher types. For instance, if $G$ is a group that is a set (i.e. a 1-group), then its Eilenberg-Mac Lane space $B G$ is a 1-type, and its automorphism ∞-group is a 1-type whose $\pi_0$ is the outer automorphisms of $G$ and whose $\pi_1$ is the center of $G$ . Thus, if $G$ has trivial outer automorphism group and trivial center, then $BG$ is rigid. Such groups are not uncommon, including for instance the symmetric group $S_n$ for any $n\neq 2,6$ . Thus, assuming excluded middle we can permute these $BS_n$ arbitrarily, producing uncountably many automorphisms of the universe.

In the converse direction, we recorded the following.

Theorem. If there is an automorphism of the universe that maps some inhabited type to the empty type, then excluded middle holds.

Corollary. If there is an automorphism $g:\mathcal{U}\to\mathcal{U}$ of the universe with $g(\mathbf{0})\neq\mathbf{0}$ , then the double negation

$\neg\neg\prod_{P:\mathcal{U}}\mathsf{isProp}(P)\to P+\neg P$

of the law of excluded middle holds.

This corollary relates to an unclaimed prize: if from an arbitrary equivalence $f:\mathcal{U}\to\mathcal{U}$ such that $f(X) \neq X$ for a particular $X:\mathcal{U}$ you get a non-provable consequence of excluded middle, then you get $X$ -many beers. So this corollary wins you 0 beers. Although perhaps sober, we think this is an achievement worth recording.

Using this corollary, in turn, we can win $\mathsf{LEM}_\mathcal{U}$ -many beers, where $\mathsf{LEM}_\mathcal{U}$ is excluded middle for propositions in the universe $\mathcal{U}$ . If $\mathcal{U} :\mathcal{V}$ we have $\mathsf{LEM}_\mathcal{U}:\mathcal{V}$ . Suppose $g$ is an automorphism of $\mathcal{V}$ with $g(\mathsf{LEM}_\mathcal{U})\neq\mathsf{LEM}_\mathcal{U}$ , then $\neg\neg\mathsf{LEM}_\mathcal{U}$ . For suppose that $\neg\mathsf{LEM}_\mathcal{U}$ , and hence $\mathsf{LEM}_\mathcal{U}=\mathbf{0}$ . So by the corollary, we obtain $\neg\neg\mathsf{LEM}_\mathcal{V}$ . But $\mathsf{LEM}_\mathcal{V}$ implies $\mathsf{LEM}_\mathcal{U}$ by cumulativity, so $\neg\neg\mathsf{LEM}_\mathcal{U}$ also holds, contradicting our assumption that $\neg\mathsf{LEM}_\mathcal{U}$ .