init

.gitattributes

@@ -1,4 +1,5 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
+*.xcf filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.avro filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text

.github/dependabot.yml

@@ -0,0 +1,11 @@
+# Set update schedule for GitHub Actions
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every weekday
+      interval: "daily"
+    labels:
+      - "dependencies"

.github/workflows/ci.yml

@@ -0,0 +1,74 @@
+name: Build
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  build:
+    name: Build and update nightlies
+    runs-on: ubuntu-latest
+    container: danteev/texlive:2025-07-15
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v6
+
+      - name: Consider all directories safe
+        run: git config --global --add safe.directory '*'
+
+      - name: Fetch all tags for `git describe`
+        run: git fetch --force --prune --unshallow --tags
+
+      - name: Check em dash style
+        run: "! grep -r '[^ ]---[^ ]' --include='*.tex' || { echo 'Please space the em dashes'; exit 1; }"
+
+      - name: Update ./errata.tex
+        # ./mark-errata should only run on the master branch of the main repo.
+        # This job is thus disabled for pull requests and forked repos.
+        if: ${{ github.repository_owner == 'HoTT' && github.ref == 'refs/heads/master' }}
+        run: |
+          ./mark-errata
+          if ! git diff --quiet -- ./errata.tex; then
+            git config --global user.name "github-actions"
+            git config --global user.email "github-actions@github.com"
+            git add errata.tex
+            git commit -m "Mark Errata (auto)"
+            git push
+          fi
+
+      - name: Generate nightlies
+        run: ./generate-nightlies "./_www_dir/" "./_wiki_dir/"
+
+      - name: Check if errata.tex is clean
+        # Interrupt the uploading if errata.tex somehow is not clean.
+        # This should not happen, but it does not hurt to check.
+        if: ${{ github.repository_owner == 'HoTT' && github.ref == 'refs/heads/master' }}
+        run: ./check-errata
+
+      - name: Push GitHub pages
+        # This step is disabled for all forked repos. The idea is that the nightlies will
+        # not be useful for most usage of forked repos. However, there are no technical
+        # reasons not to enable it, if one wishes to do so.
+        if: ${{ github.repository_owner == 'HoTT' && github.ref == 'refs/heads/master' }}
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          force_orphan: true
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: "./_www_dir/"
+
+      - name: Install gh
+        # Needed for using Andrew-Chen-Wang/github-wiki-action@v5
+        run: |
+          apt-get update
+          apt-get install -y gh
+
+      - name: Push GitHub wiki pages
+        # This step would err if the forked repo does not already have wiki pages.
+        # As a workaround, it is disabled for all forked repos.
+        if: ${{ github.repository_owner == 'HoTT' && github.ref == 'refs/heads/master' }}
+        uses: Andrew-Chen-Wang/github-wiki-action@v5
+        with:
+          path: _wiki_dir

.gitignore

@@ -0,0 +1,612 @@
+.svn
+*.pyc
+*.aux
+*.aux.bak
+hott-*.pdf
+main.pdf
+errata*.pdf
+*.dvi
+*.bbl
+*.fls
+*.toc
+*.blg
+*.brf
+*.log
+*.out
+*.out.ps
+*.sed
+*.synctex.gz
+*.nav
+*.snm
+*.idx
+*.idx.bak
+*.ilg
+*.ind
+auto/*
+*~
+\#*
+.\#*
+cover/torus/preimg/*
+cover/torus/srcimg/*
+cover/torus/dstimg/*
+_region_*
+TAGS
+.DS_Store
+*.fdb_latexmk
+main.labels
+main.labelnumbers
+exercise_solutions.pdf
+indexterms.txt
+cover-*.pdf
+version.tex
+hott-arxiv.tex
+hott-arxiv.tar.gz
+/Ustmry.fd
+/barrdoc.pdf
+/base.zip
+/base/
+/braket.sty
+/color.cfg
+/comment.sty
+/dvitogif89a
+/empheq.drv
+/empheq.dtx
+/empheq.ins
+/empheq.sty
+/enumitem.sty
+/etoolbox.def
+/etoolbox.sty
+/install-tds
+/mathtools.drv
+/mathtools.dtx
+/mathtools.ins
+/mathtools.sty
+/mathtools.zip
+/mathtools/
+/mhsetup.drv
+/mhsetup.dtx
+/mhsetup.ins
+/mhsetup.sty
+/movie.cls
+/nextpage.sty
+/pgf.cfg
+/pgf.revision.tex
+/pgf.sty
+/pgf.tex
+/pgfarrows.sty
+/pgfautomata.sty
+/pgfbaseimage.sty
+/pgfbaseimage.tex
+/pgfbaselayers.sty
+/pgfbaselayers.tex
+/pgfbasematrix.sty
+/pgfbasematrix.tex
+/pgfbasepatterns.sty
+/pgfbasepatterns.tex
+/pgfbaseplot.sty
+/pgfbaseplot.tex
+/pgfbaseshapes.sty
+/pgfbaseshapes.tex
+/pgfbasesnakes.sty
+/pgfbasesnakes.tex
+/pgfcalendar.code.tex
+/pgfcalendar.sty
+/pgfcalendar.tex
+/pgfcomp-version-0-65.sty
+/pgfcomp-version-1-18.sty
+/pgfcore.code.tex
+/pgfcore.sty
+/pgfcore.tex
+/pgfcorearrows.code.tex
+/pgfcoreexternal.code.tex
+/pgfcoregraphicstate.code.tex
+/pgfcoreimage.code.tex
+/pgfcorelayers.code.tex
+/pgfcoreobjects.code.tex
+/pgfcorepathconstruct.code.tex
+/pgfcorepathprocessing.code.tex
+/pgfcorepathusage.code.tex
+/pgfcorepatterns.code.tex
+/pgfcorepoints.code.tex
+/pgfcorequick.code.tex
+/pgfcorerdf.code.tex
+/pgfcorescopes.code.tex
+/pgfcoreshade.code.tex
+/pgfcoretransformations.code.tex
+/pgfcoretransparency.code.tex
+/pgfexternal.tex
+/pgfexternalwithdepth.tex
+/pgffor.code.tex
+/pgffor.sty
+/pgffor.tex
+/pgfheaps.sty
+/pgfint.code.tex
+/pgfkeys.code.tex
+/pgfkeys.sty
+/pgfkeys.tex
+/pgfkeysfiltered.code.tex
+/pgflibraryarrows.code.tex
+/pgflibraryarrows.meta.code.tex
+/pgflibraryarrows.spaced.code.tex
+/pgflibraryarrows.sty
+/pgflibraryautomata.sty
+/pgflibrarybbox.code.tex
+/pgflibrarycurvilinear.code.tex
+/pgflibrarydatavisualization.barcharts.code.tex
+/pgflibrarydatavisualization.formats.functions.code.tex
+/pgflibrarydatavisualization.polar.code.tex
+/pgflibrarydecorations.footprints.code.tex
+/pgflibrarydecorations.fractals.code.tex
+/pgflibrarydecorations.markings.code.tex
+/pgflibrarydecorations.pathmorphing.code.tex
+/pgflibrarydecorations.pathreplacing.code.tex
+/pgflibrarydecorations.shapes.code.tex
+/pgflibrarydecorations.text.code.tex
+/pgflibraryfadings.code.tex
+/pgflibraryfixedpointarithmetic.code.tex
+/pgflibraryfpu.code.tex
+/pgflibrarygraphdrawing.circular.code.tex
+/pgflibrarygraphdrawing.code.tex
+/pgflibrarygraphdrawing.examples.code.tex
+/pgflibrarygraphdrawing.force.code.tex
+/pgflibrarygraphdrawing.layered.code.tex
+/pgflibrarygraphdrawing.trees.code.tex
+/pgflibraryintersections.code.tex
+/pgflibrarylindenmayersystems.code.tex
+/pgflibraryluamath.code.tex
+/pgflibrarypatterns.code.tex
+/pgflibrarypatterns.meta.code.tex
+/pgflibraryplothandlers.code.tex
+/pgflibraryplothandlers.sty
+/pgflibraryplotmarks.code.tex
+/pgflibraryplotmarks.sty
+/pgflibraryprofiler.code.tex
+/pgflibraryshadings.code.tex
+/pgflibraryshapes.arrows.code.tex
+/pgflibraryshapes.callouts.code.tex
+/pgflibraryshapes.code.tex
+/pgflibraryshapes.gates.ee.IEC.code.tex
+/pgflibraryshapes.gates.ee.code.tex
+/pgflibraryshapes.gates.logic.IEC.code.tex
+/pgflibraryshapes.gates.logic.US.code.tex
+/pgflibraryshapes.gates.logic.code.tex
+/pgflibraryshapes.geometric.code.tex
+/pgflibraryshapes.misc.code.tex
+/pgflibraryshapes.multipart.code.tex
+/pgflibraryshapes.sty
+/pgflibraryshapes.symbols.code.tex
+/pgflibrarysnakes.code.tex
+/pgflibrarysnakes.sty
+/pgflibrarysvg.path.code.tex
+/pgflibrarytikzbackgrounds.sty
+/pgflibrarytikztrees.sty
+/pgflibrarytimelines.code.tex
+/pgfmath.code.tex
+/pgfmath.sty
+/pgfmath.tex
+/pgfmathcalc.code.tex
+/pgfmathfloat.code.tex
+/pgfmathfunctions.base.code.tex
+/pgfmathfunctions.basic.code.tex
+/pgfmathfunctions.code.tex
+/pgfmathfunctions.comparison.code.tex
+/pgfmathfunctions.integerarithmetics.code.tex
+/pgfmathfunctions.misc.code.tex
+/pgfmathfunctions.random.code.tex
+/pgfmathfunctions.round.code.tex
+/pgfmathfunctions.trigonometric.code.tex
+/pgfmathode.code.tex
+/pgfmathparser.code.tex
+/pgfmathtestsuite.tex
+/pgfmathutil.code.tex
+/pgfmoduleanimations.code.tex
+/pgfmodulebending.code.tex
+/pgfmoduledatavisualization.code.tex
+/pgfmoduledecorations.code.tex
+/pgfmodulematrix.code.tex
+/pgfmodulenonlineartransformations.code.tex
+/pgfmoduleoo.code.tex
+/pgfmoduleparser.code.tex
+/pgfmoduleplot.code.tex
+/pgfmoduleshapes.code.tex
+/pgfmodulesnakes.code.tex
+/pgfmodulesorting.code.tex
+/pgfnodes.sty
+/pgfpages.sty
+/pgfpict2e.sty
+/pgfrcs.code.tex
+/pgfrcs.sty
+/pgfrcs.tex
+/pgfshade.sty
+/pgfsys-common-pdf-via-dvi.def
+/pgfsys-common-pdf.def
+/pgfsys-common-postscript.def
+/pgfsys-common-svg.def
+/pgfsys-dvi.def
+/pgfsys-dvipdfm.def
+/pgfsys-dvipdfmx.def
+/pgfsys-dvips.def
+/pgfsys-dvisvgm.def
+/pgfsys-luatex.def
+/pgfsys-pdftex.def
+/pgfsys-tex4ht.def
+/pgfsys-textures.def
+/pgfsys-vtex.def
+/pgfsys-xetex.def
+/pgfsys.code.tex
+/pgfsys.sty
+/pgfsys.tex
+/pgfsysanimations.code.tex
+/pgfsysprotocol.code.tex
+/pgfsyssoftpath.code.tex
+/pgfutil-common-lists.tex
+/pgfutil-common.tex
+/pgfutil-context.def
+/pgfutil-latex.def
+/pgfutil-plain.def
+/pnmrawtopcropwhite.c
+/soul.dtx
+/soul.ins
+/soul.sty
+/stmary10.600pk
+/stmary10.657pk
+/stmary10.mf
+/stmary10.tfm
+/stmary5.600pk
+/stmary5.mf
+/stmary5.tfm
+/stmary6.600pk
+/stmary6.mf
+/stmary6.tfm
+/stmary7.600pk
+/stmary7.mf
+/stmary7.tfm
+/stmary8.600pk
+/stmary8.mf
+/stmary8.tfm
+/stmary9.600pk
+/stmary9.mf
+/stmary9.tfm
+/stmaryaj.mf
+/stmaryba.mf
+/stmarych.mf
+/stmaryjg.mf
+/stmaryrd.dtx
+/stmaryrd.ins
+/stmaryrd.mf
+/stmaryrd.sty
+/stmaryrd.zip
+/stmaryrd/
+/supertabular.dtx
+/supertabular.ins
+/supertabular.sty
+/svgnam.def
+/t-pgf.tex
+/t-pgfbim.tex
+/t-pgfbla.tex
+/t-pgfbma.tex
+/t-pgfbpl.tex
+/t-pgfbpt.tex
+/t-pgfbsh.tex
+/t-pgfbsn.tex
+/t-pgfcal.tex
+/t-pgfcor.tex
+/t-pgffor.tex
+/t-pgfkey.tex
+/t-pgfmat.tex
+/t-pgfmod.tex
+/t-pgfrcs.tex
+/t-pgfsys.tex
+/t-tikz.tex
+/tikz.code.tex
+/tikz.sty
+/tikz.tex
+/tikzexternal.sty
+/tikzexternalshared.code.tex
+/tikzexternaltest.code.tex
+/tikzexternaltest.sharedpreamble.tex
+/tikzexternaltest.tex
+/tikzexternaltestmakefile.tex
+/tikzlibrary3d.code.tex
+/tikzlibraryangles.code.tex
+/tikzlibraryanimations.code.tex
+/tikzlibraryarrows.code.tex
+/tikzlibraryautomata.code.tex
+/tikzlibrarybabel.code.tex
+/tikzlibrarybackgrounds.code.tex
+/tikzlibrarybending.code.tex
+/tikzlibrarycalc.code.tex
+/tikzlibrarycalendar.code.tex
+/tikzlibrarychains.code.tex
+/tikzlibrarycircuits.code.tex
+/tikzlibrarycircuits.ee.IEC.code.tex
+/tikzlibrarycircuits.ee.code.tex
+/tikzlibrarycircuits.logic.CDH.code.tex
+/tikzlibrarycircuits.logic.IEC.code.tex
+/tikzlibrarycircuits.logic.US.code.tex
+/tikzlibrarycircuits.logic.code.tex
+/tikzlibrarydatavisualization.3d.code.tex
+/tikzlibrarydatavisualization.barcharts.code.tex
+/tikzlibrarydatavisualization.code.tex
+/tikzlibrarydatavisualization.formats.functions.code.tex
+/tikzlibrarydatavisualization.polar.code.tex
+/tikzlibrarydatavisualization.sparklines.code.tex
+/tikzlibrarydecorations.code.tex
+/tikzlibrarydecorations.footprints.code.tex
+/tikzlibrarydecorations.fractals.code.tex
+/tikzlibrarydecorations.markings.code.tex
+/tikzlibrarydecorations.pathmorphing.code.tex
+/tikzlibrarydecorations.pathreplacing.code.tex
+/tikzlibrarydecorations.shapes.code.tex
+/tikzlibrarydecorations.text.code.tex
+/tikzlibraryer.code.tex
+/tikzlibraryexternal.code.tex
+/tikzlibraryfadings.code.tex
+/tikzlibraryfit.code.tex
+/tikzlibraryfixedpointarithmetic.code.tex
+/tikzlibraryfolding.code.tex
+/tikzlibraryfpu.code.tex
+/tikzlibrarygraphdrawing.code.tex
+/tikzlibrarygraphdrawing.evolving.code.tex
+/tikzlibrarygraphs.code.tex
+/tikzlibrarygraphs.standard.code.tex
+/tikzlibraryintersections.code.tex
+/tikzlibrarylindenmayersystems.code.tex
+/tikzlibrarymath.code.tex
+/tikzlibrarymatrix.code.tex
+/tikzlibrarymindmap.code.tex
+/tikzlibrarypatterns.code.tex
+/tikzlibrarypatterns.meta.code.tex
+/tikzlibraryperspective.code.tex
+/tikzlibrarypetri.code.tex
+/tikzlibraryplothandlers.code.tex
+/tikzlibraryplotmarks.code.tex
+/tikzlibrarypositioning.code.tex
+/tikzlibraryquotes.code.tex
+/tikzlibraryrdf.code.tex
+/tikzlibraryscopes.code.tex
+/tikzlibraryshadings.code.tex
+/tikzlibraryshadows.code.tex
+/tikzlibraryshapes.arrows.code.tex
+/tikzlibraryshapes.callouts.code.tex
+/tikzlibraryshapes.code.tex
+/tikzlibraryshapes.gates.logic.IEC.code.tex
+/tikzlibraryshapes.gates.logic.US.code.tex
+/tikzlibraryshapes.geometric.code.tex
+/tikzlibraryshapes.misc.code.tex
+/tikzlibraryshapes.multipart.code.tex
+/tikzlibraryshapes.symbols.code.tex
+/tikzlibrarysnakes.code.tex
+/tikzlibraryspy.code.tex
+/tikzlibrarysvg.path.code.tex
+/tikzlibrarythrough.code.tex
+/tikzlibrarytopaths.code.tex
+/tikzlibrarytrees.code.tex
+/tikzlibraryturtle.code.tex
+/tikzlibraryviews.code.tex
+/titleps.sty
+/titlesec.sty
+/titlesec.zip
+/titlesec/
+/titletoc.sty
+/unittest_luamathparser.tex
+/wallpaper.sty
+/x11nam.def
+/xcolor.dtx
+/xcolor.ins
+/xcolor.lox
+/xcolor.pro
+/xcolor.sty
+/xcolor1.tex
+/xcolor2.tex
+/xcolor3.tex
+/xcolor4.tex
+/xstring.sty
+/xstring.tex
+/xxcolor.sty
+/xy.sty
+/xy.tex
+/xy16textures.tex
+/xy17oztex.tex
+/xy2cell.tex
+/xy389dict.pro
+/xy389src.tar.gz
+/xyall.tex
+/xyarc.tex
+/xyarrow.tex
+/xyatip.mf
+/xyatip10.afm
+/xyatip10.mf
+/xyatip10.pfb
+/xyatip10.pfm
+/xyatip10.tfm
+/xyatri.mf
+/xybarr.tex
+/xybsql10.afm
+/xybsql10.mf
+/xybsql10.pfb
+/xybsql10.pfm
+/xybsql10.tfm
+/xybtip.mf
+/xybtip10.afm
+/xybtip10.mf
+/xybtip10.pfb
+/xybtip10.pfm
+/xybtip10.tfm
+/xybtri.mf
+/xycirc.enc
+/xycirc10.afm
+/xycirc10.mf
+/xycirc10.pfb
+/xycirc10.pfm
+/xycirc10.tfm
+/xycm.mf
+/xycmactex.tex
+/xycmat10.afm
+/xycmat10.mf
+/xycmat10.pfb
+/xycmat10.pfm
+/xycmat10.tfm
+/xycmat11.afm
+/xycmat11.mf
+/xycmat11.pfb
+/xycmat11.pfm
+/xycmat11.tfm
+/xycmat12.afm
+/xycmat12.mf
+/xycmat12.pfb
+/xycmat12.pfm
+/xycmat12.tfm
+/xycmbt10.afm
+/xycmbt10.mf
+/xycmbt10.pfb
+/xycmbt10.pfm
+/xycmbt10.tfm
+/xycmbt11.afm
+/xycmbt11.mf
+/xycmbt11.pfb
+/xycmbt11.pfm
+/xycmbt11.tfm
+/xycmbt12.afm
+/xycmbt12.mf
+/xycmbt12.pfb
+/xycmbt12.pfm
+/xycmbt12.tfm
+/xycmtip.tex
+/xycolor.tex
+/xycrayon.tex
+/xycurve.tex
+/xyd.enc
+/xyd.mf
+/xyd2.enc
+/xyd2.mf
+/xydash10.afm
+/xydash10.mf
+/xydash10.pfb
+/xydash10.pfm
+/xydash10.tfm
+/xydummy.tex
+/xydvidrv.tex
+/xydvips.tex
+/xydvitops.tex
+/xyemtex.tex
+/xyeuat10.afm
+/xyeuat10.mf
+/xyeuat10.pfb
+/xyeuat10.pfm
+/xyeuat10.tfm
+/xyeuat11.afm
+/xyeuat11.mf
+/xyeuat11.pfb
+/xyeuat11.pfm
+/xyeuat11.tfm
+/xyeuat12.afm
+/xyeuat12.mf
+/xyeuat12.pfb
+/xyeuat12.pfm
+/xyeuat12.tfm
+/xyeubt10.afm
+/xyeubt10.mf
+/xyeubt10.pfb
+/xyeubt10.pfm
+/xyeubt10.tfm
+/xyeubt11.afm
+/xyeubt11.mf
+/xyeubt11.pfb
+/xyeubt11.pfm
+/xyeubt11.tfm
+/xyeubt12.afm
+/xyeubt12.mf
+/xyeubt12.pfb
+/xyeubt12.pfm
+/xyeubt12.tfm
+/xyeuler.mf
+/xyframe.tex
+/xygraph.tex
+/xyguide.pdf
+/xyidioms.tex
+/xyimport.tex
+/xyknot.tex
+/xyline.tex
+/xyline10.mf
+/xyline10.tfm
+/xylu.mf
+/xyluat10.afm
+/xyluat10.mf
+/xyluat10.pfb
+/xyluat10.pfm
+/xyluat10.tfm
+/xyluat11.afm
+/xyluat11.mf
+/xyluat11.pfb
+/xyluat11.pfm
+/xyluat11.tfm
+/xyluat12.afm
+/xyluat12.mf
+/xyluat12.pfb
+/xyluat12.pfm
+/xyluat12.tfm
+/xylubt10.afm
+/xylubt10.mf
+/xylubt10.pfb
+/xylubt10.pfm
+/xylubt10.tfm
+/xylubt11.afm
+/xylubt11.mf
+/xylubt11.pfb
+/xylubt11.pfm
+/xylubt11.tfm
+/xylubt12.afm
+/xylubt12.mf
+/xylubt12.pfb
+/xylubt12.pfm
+/xylubt12.tfm
+/xymacpat.xyp
+/xymatrix.tex
+/xymisc10.mf
+/xymisc10.tfm
+/xymovie.tex
+/xynecula.tex
+/xyoztex.tex
+/xypdf-co.tex
+/xypdf-cu.tex
+/xypdf-fr.tex
+/xypdf-li.tex
+/xypdf-ro.tex
+/xypdf.pdf
+/xypdf.tex
+/xypic.map
+/xypic.sty
+/xypic.tex
+/xypic.zip
+/xypic/
+/xypicture.tex
+/xypoly.tex
+/xyps-c.tex
+/xyps-col.tex
+/xyps-f.tex
+/xyps-l.tex
+/xyps-pro.tex
+/xyps-ps.tex
+/xyps-r.tex
+/xyps-s.tex
+/xyps-t.tex
+/xyps.tex
+/xypsdict.tex
+/xypspatt.tex
+/xyqc10.mf
+/xyqc10.tfm
+/xyrecat.tex
+/xyrefer.pdf
+/xyrotate.tex
+/xysmart.tex
+/xysource.pdf
+/xytech.mf
+/xytextures.tex
+/xytile.tex
+/xytips.tex
+/xytp-f.tex
+/xytpic.tex
+/xyv2.tex
+/xyweb.tex
+/xyxdvi.tex

.travis.yml

@@ -0,0 +1,47 @@
+language: c
+
+sudo: true
+
+cache:
+  directories:
+    - $HOME/.cache/latex
+
+addons:
+  apt:
+    packages:
+      - wget
+      - curl
+      - sed
+      - grep
+      - texlive
+      - texlive-generic-extra
+      - texlive-latex-base
+      - texlive-latex-extra
+      - texlive-latex-recommended
+      - texlive-math-extra
+      - texlive-metapost
+      - texlive-omega
+      - texlive-plain-extra
+      - texlive-xetex
+
+env:
+ global:
+   - secure: "ehec8FC6y923UXtB2fMULF/xkQJkwWwzD6xFxyz0lc80IqR8Rmxh16nLKGxI9jD11qjbYSzp1yPVadXyBoSheop5aZPxeXixL49y26ikIRkyuQQdHyjsM34etoPmCKw2vVXvD+JAwjTa6qYpihSOdDXltog8ZNHF6Wp28ZaWW8g="
+
+matrix:
+ include:
+   # only one of these should have UPDATE_ERRATA set to "yes", otherwise we risk race conditions on pushing
+   - env: LATEXMK="yes" UPDATE_ERRATA=""     UPDATE_NIGHTLIES=""     TARGETS=""
+   - env: LATEXMK=""    UPDATE_ERRATA="yes"  UPDATE_NIGHTLIES="yes"  TARGETS=""
+   - env: LATEXMK=""    UPDATE_ERRATA=""     UPDATE_NIGHTLIES=""     TARGETS="dvi"
+
+install:
+ - if test "$LATEXMK" = yes ; then sudo apt-get install latexmk ; fi
+
+script: make $TARGETS
+
+# add -f to force a push even if we're not on HoTT/HoTT.
+# generally only useful for debugging
+after_script:
+ - etc/ci/update_errata.sh
+ - etc/ci/update_nightlies.sh

CONTRIBUTING.md

@@ -0,0 +1,79 @@
+We are very happy to receive suggestions which fix typos, formatting,
+and obvious mathematical errors; which clarify exposition in a
+straightforward way; or which add new technical functionality (such as
+versions for other devices).  We are not asking for new mathematical
+content from the public at this time.
+
+We are very grateful to everyone who is showing interest in our project,
+and to anyone who helps us improve it!  However, in order to avoid any
+misunderstanding later, we should mention upfront that your
+contributions will only be recorded on github commit logs, but not in
+the book itself (because the book is officially an IAS project).
+
+Note that the version of the book you are working from (including the
+version posted on the public web site) may not be the most recent one.
+If you've found an error and want to check whether it has already been
+corrected in the most recent version, you may need to clone the git
+repository and compile the sources yourself, or else look at the
+source code on github.
+
+If you only want to point out the existence of an error or make a
+general suggestion, you can open an issue on the github project.  The
+authors will (eventually) respond and either implement a fix or decide
+that no fix is necessary.  If you would like to fix an error yourself
+or suggest a specific concrete change, you can fork the github
+project, commit the change in a branch on your fork, and open a pull
+request to the parent project.
+
+Please make sure that your pull request is attached to the correct
+branch.  Changes which add new mathematics, or which alter the
+numbering of existing sections, theorems, or equations, must wait for
+the second edition.  Other changes, as long as they are not of
+unreasonable size, can be released as updates to the first edition.
+To ensure that your change does not alter existing numberings, you can
+run "make labelcheck".
+
+Corrections of mathematical typos and other errors, as well as changes
+in exposition, should also be listed in the errata for the first
+edition (`errata.tex`).
+
+- The first column in the errata table should be the nearest
+  surrounding numbered label, be it a section, theorem, or exercise.
+
+- The second column is obtained by running `git describe` on the
+  commit where the fix was merged into the master branch.  You don't
+  know this when writing your fix, of course, so the correct thing to
+  put here is a comment of the form
+
+      % merge of 1234567
+  
+  where `1234567` is the commit hash in which you made the fix.  (This
+  necessitates making two commits, one to make the fix and one to
+  record the erratum.)  Please use _exactly_ this syntax so that it can
+  be automatically updated by the errata-marking script.
+
+- The third column is a description of the change.  Please be specific
+  enough that someone looking at only a printed version (which may
+  have page breaks in different places) could easily find its
+  location.
+
+It is generally a good idea not to submit github pull requests from
+your master branch.  This is because whatever branch you submit a pull
+request from, any new commits on that branch that happen before the
+pull request is merged get added to the pull request.  Thus, if you
+submit pull requests from your master branch, you cannot have multiple
+unrelated pull requests open at once, or do unrelated work on your
+master branch before your pull request is merged.  To create a special
+branch for your pull request, run
+
+    git checkout -b BRANCHNAME
+
+Make your commits in that branch, then run
+
+    git push origin BRANCHNAME:BRANCHNAME
+
+assuming that your git remote `origin` is set up to be your github
+fork (rather than the main `HoTT/book` repository).  The main page of
+your github fork should then have a little prompt asking you whether
+you want to issue a pull request from your most recently pushed
+branch.

CONVENTIONS.txt

@@ -0,0 +1,71 @@
+	       Authorial conventions for the HoTT Book
+
+1. To denote equality/identity/path types, you can write simply "="
+   infix.  Of course, this works for chains of equalities "a=b=c=d"
+   and also vertically-stacked ones.  An alternative notation is
+   "\id{x}{y}", or "\id[A]{x}{y}" if you want to notate the type to
+   which x and y belong; this notation might produce "x=y" or
+   "Id(x,y)" in the future.  If you want to be sure of producing
+   "Id(x,y)", write instead "\idtype{x}{y}" or "\idtype[A]{x}{y}".
+   Note that single-character non-optional arguments do not need
+   braces, so you can write "\idtype xy", but you need to write
+   "\idtype{(x+1)^2}{x^2+2x+1}".
+
+2. There are two macros that denote definitional/judgmental equality.
+   \jdeq or \judgeq should be used for an equality judgment being made
+   about two extant terms, while \defeq should be used when the
+   left-hand side is currently being defined to equal the right-hand
+   side.  Both are used infix, and currently produce \equiv and
+   \coloneqq (that is, :=), respectively.
+
+3. Here is a cheatsheet of some more macros.  Arguments in [brackets]
+   are optional and can be omitted.
+
+   x = y     		identity type (fixed notation "x=y")
+   \id[A]{x}{y}		identity type (agnostic notation)
+   \idtype[A]{x}{y}	identity type (fixed notation "Id(x,y)")
+   x \jdeq y		x is judged to be definitionally equal to y
+   x \defeq y		x is currently being defined to equal y
+   \refl{x}  		reflexivity term at x
+   p \ct q		concatenation of equalities p and q (diagrammatic order)
+   \opp{p} or \rev{p}	the opposite equality of p
+   \trans{p}{x}		covariant transport of x along p
+   \map{f}{p}		map the path p under the function f
+   \mapdep{f}{p}	likewise, for a dependently typed function f
+   \idfunc[A]		the identity function of a type A 
+   \eqv{A}{B}		the type of equivalences from A to B
+   \type,\set,\prop	universes of types, sets, and propositions
+
+3. In the style of a textbook or lecture notes, generally try to keep
+   citations and references out of the main text.  Rather, each
+   chapter should have an unnumbered "Notes" section at the end
+   containing references to the literature and relevant comments.
+   References should go in the references.bib file in BibTeX format.
+   Use \cite for your citations so that they will all have a uniform
+   appearance.
+
+4. The following theorem-type environments are predefined:
+
+   thm 		 Theorem
+   cor		 Corollary
+   lem		 Lemma
+   defn		 Definition
+   rmk		 Remark
+   eg		 Example
+   egs		 Examples
+   ex		 Exercise
+
+   When referring to a theorem defined elsewhere, use the macro
+   \autoref.  This automatically produces words before numbers, such
+   as "Theorem 3.1", and automatically changes them if (for instance)
+   you change a theorem to a lemma.
+
+   Similarly, try to add \label{}s to all of your theorem-environments
+   so that other people can refer to them. If you find yourself needing
+   a lemma that you think should appear in someone else's chapter, you
+   can add a stub to their chapter with a \label. Only the following
+   characters should be used in labels: letters, digits, colon : and
+   dash -.
+
+5. Each chapter is encouraged to also have an unnumbered section of
+   "Exercises" at the end.

GIT_CHEATSHEET.txt

@@ -0,0 +1,45 @@
+# SETUP 1: Install git
+# see  http:/git-scm.com/downloads
+# Remember to set user.name and user.email:
+git config --global user.name "James Bond"
+git config --global user.email "007@mi6.gov.uk"
+
+# SETUP 2: signup for GitHub account
+# see  http://github.com
+# Remember to email your username to:
+#     mshulman@ias.edu
+
+# SETUP 3: clone
+cd dir_where_you_want_book_dir
+git clone https://github.com/HoTT/book.git
+cd book
+#...
+
+# NOTE: Remaining commands must be run inside book/
+
+# USAGE 1: add + commit
+# To have git record your changes:
+git commit -m "description of edit" <files-you-changed>
+
+# USAGE 2: pull
+# To pull changes by others from GitHub:
+# (Your local directory will still have your changes.)
+# FIRST commit your changes as above, then
+git pull
+
+# USAGE 3: compile + push
+# To push your changes to GitHub:
+# FIRST, commit your changes as above
+# SECOND, pull changes from GitHub as above, then
+latex main.tex 
+git push
+
+
+# Which files did I change since the last commit?
+git status
+
+# What changes did I make in those files?
+git diff
+
+# Who wrote the crap in this file?
+git blame

Makefile

@@ -0,0 +1,192 @@
+.PHONY: default all clean version.tex dvi
+
+# Default top-level LaTeX to generate
+DEFAULTTOPTEX = hott-online.tex
+
+# Top-level LaTeX files from which HoTT book can be generated
+TOPTEXFILES = $(DEFAULTTOPTEX) hott-ustrade.tex hott-letter.tex hott-letter-exercises.tex hott-a4.tex hott-a4-exercises.tex hott-ebook.tex hott-ebook-wide.tex hott-ebook-narrow.tex hott-arxiv.tex
+
+# LaTeX files that actually comprise the book
+# (that is, all of them except configuration)
+BOOKTEXFILES = 	main.tex \
+	macros.tex \
+	version.tex \
+	frontpage.tex \
+	front.tex \
+	preface.tex \
+	introduction.tex \
+	preliminaries.tex \
+	basics.tex \
+	logic.tex \
+	equivalences.tex \
+	induction.tex \
+	hits.tex \
+	hlevels.tex \
+	homotopy.tex \
+	categories.tex \
+	setmath.tex \
+	reals.tex \
+	formal.tex \
+	symbols.tex \
+	back.tex \
+	blurb.tex
+
+# Configuration files
+OPTFILES = opt-letter.tex \
+	   opt-a4.tex \
+	   opt-ustrade.tex \
+	   opt-ebook.tex \
+	   opt-ebook-wide.tex \
+	   opt-ebook-narrow.tex \
+	   opt-color.tex \
+	   opt-black-white.tex \
+	   opt-cover.tex \
+	   opt-no-cover.tex \
+	   opt-bastard.tex \
+	   opt-no-bastard.tex
+
+# Image files
+LORESPNGFILES = cover-lores-back-bw.png \
+		cover-lores-back.png \
+		cover-lores-front-bw.png \
+		cover-lores-front.png \
+		cover-lores.png \
+		torus-lores-bw.png
+HIRESPNGFILES = cover-hires-back-bw.png \
+		cover-hires-back.png \
+		cover-hires-front-bw.png \
+		cover-hires-front.png \
+		cover-hires.png \
+		cover-hires-bw.png \
+		torus-hires-bw.png
+
+# All the LaTeX files for the HoTT book in order of dependency
+TEXFILES = $(TOPTEXFILES) $(BOOKTEXFILES) $(OPTFILES)
+
+# aux files to be used when combining info from HoTT book with
+# exercises
+BOOKAUXFILES := $(BOOKTEXFILES:.tex=.aux)
+
+# PDF and DVI files corresponding to HoTT book files
+TOPPDFFILES:=$(TOPTEXFILES:.tex=.pdf)
+TOPDVIFILES:=$(TOPTEXFILES:.tex=.dvi)
+
+# Default PDF file to make
+DEFAULTPDF:=$(DEFAULTTOPTEX:.tex=.pdf)
+
+default: $(DEFAULTPDF)
+
+all: $(TOPPDFFILES) exercise_solutions.pdf errata.pdf cover-lulu-hardcover.pdf cover-lulu-paperback.pdf cover-letter.pdf cover-a4.pdf
+
+dvi: $(TOPDVIFILES) exercise_solutions.dvi errata.dvi cover-lulu-hardcover.dvi cover-lulu-paperback.dvi cover-letter.dvi cover-a4.dvi
+
+# Main targets
+$(TOPPDFFILES) : %.pdf : %.tex $(TEXFILES) references.bib cover-lores-front.png cover-lores-back.png
+	if which latexmk > /dev/null 2>&1 ;\
+	then latexmk -interaction=batchmode -g -pdf $< ;\
+	else (echo "run 1: pdflatex $<"; pdflatex -halt-on-error -interaction=batchmode $< 2>&1 >/dev/null) && \
+	     bibtex $(patsubst %.tex,%,$<) && \
+	     makeindex $(patsubst %.tex,%,$<) && \
+	     (echo "run 2: pdflatex $<"; pdflatex -halt-on-error -interaction=batchmode $< 2>&1 >/dev/null) ;\
+	     pdflatex -halt-on-error $< ;\
+	     echo "HINT: If you think this took a long time you should install latexmk." ;\
+	fi
+
+$(TOPDVIFILES) : %.dvi : %.tex $(TEXFILES) references.bib cover-lores-front.png cover-lores-back.png
+	if which latexmk > /dev/null 2>&1 ;\
+	then latexmk -interaction=batchmode -dvi $< ;\
+	else (echo "run 1: latex $<"; latex -halt-on-error -interaction=batchmode $< 2>&1 >/dev/null) && \
+	     bibtex $(patsubst %.tex,%,$<) && \
+	     makeindex $(patsubst %.tex,%,$<) && \
+	     (echo "run 2: latex $<"; latex -halt-on-error -interaction=batchmode $< 2>&1 >/dev/null) ;\
+	     latex -halt-on-error $< ;\
+	     echo "HINT: If you think this took a long time you should install latexmk." ;\
+	fi
+
+all default: log-check
+log-check:
+	: check for indexing errors
+	! grep -n "!! Input index error" hott-online.ilg /dev/null
+
+version.tex:
+	printf '\\newcommand{\\OPTversion}{%s}\n' "`git describe --always --long`" > version.tex
+
+# these warnings are mostly spurious, and could have been prevented by a better makeindex algorithm
+log-check-for-warnings:
+	: check for indexing warnings
+	- ! grep -n "## Warning" hott-online.ilg /dev/null
+
+$(BOOKAUXFILES) : %.aux : %.tex
+	echo "WARNING: assuming $@ is up-to-date"
+
+# Generate labels for the solutions
+main.labels: $(BOOKAUXFILES)
+	cat $^ | grep ^.newlabel >$@
+
+# Extract label numbers for verifying that they haven't changed within an edition.
+# Discard symbol index numbers (not seen by user) and page numbers (we don't care about them).
+main.labelnumbers: main.labels
+	sed 's/.*symindex.*//g' main.labels | sed 's/{\({[^}]*}\).*/\1/g' | sort >main.labelnumbers
+
+# Check that no labels have changed, by making sure that all label
+# numbers from the first edition are still present
+labelcheck: main.labelnumbers
+	diff -u main.labelnumbers.first-edition main.labelnumbers | grep '^-\\newlabel' && echo Some label numbers have changed since the first edition!
+
+cover-lulu-hardcover.pdf cover-lulu-paperback.pdf cover-letter.pdf cover-a4.pdf exercise_solutions.pdf errata.pdf : %.pdf : %.tex
+	if which latexmk > /dev/null 2>&1 ;\
+	then latexmk -interaction=batchmode -pdf $<;\
+	else pdflatex -halt-on-error $<; fi
+
+cover-lulu-hardcover.dvi cover-lulu-paperback.dvi cover-letter.dvi cover-a4.dvi exercise_solutions.dvi errata.dvi : %.dvi : %.tex
+	if which latexmk > /dev/null 2>&1 ;\
+	then latexmk -interaction=batchmode -dvi $<;\
+	else latex -halt-on-error $<; fi
+
+cover-lulu-hardcover.pdf cover-lulu-paperback.pdf cover-lulu-hardcover.dvi cover-lulu-paperback.dvi: cover-hires.png $(OPTFILES)
+
+cover-letter.pdf cover-a4.pdf cover-letter.dvi cover-a4.dvi: cover-lores-front.png cover-lores-back.png $(OPTFILES)
+
+hott-arxiv.tex: hott-online.tex main.tex
+	echo '% hott-arxiv.tex AUTOGENERATED FROM hott-online.tex AND main.tex' >hott-arxiv.tex
+	cat hott-online.tex >>hott-arxiv.tex
+	sed 's/\\input{main}//' <hott-arxiv.tex >hott-arxiv.tex.tmp
+	mv hott-arxiv.tex.tmp hott-arxiv.tex
+	cat main.tex >>hott-arxiv.tex
+
+hott-arxiv.tar.gz: hott-arxiv.pdf
+	tar -czf hott-arxiv.tar.gz hott-arxiv.tex hott-arxiv.bbl hott-arxiv.ind $(BOOKTEXFILES) $(OPTFILES) $(LORESPNGFILES) mathpartir.sty
+
+exercise_solutions.pdf exercise_solutions.dvi: main.labels
+
+errata.pdf errata.dvi: version.tex main.labels
+
+clean:
+	rm -f *~ *.aux {exercise_solutions,errata,hott-*}.{out,log,pdf,dvi,fls,fdb_latexmk,aux,brf,bbl,idx,ilg,ind,toc,sed}
+	if which latexmk > /dev/null 2>&1 ; then latexmk -interaction=batchmode -C hott-*.tex; fi
+
+# list the tex files explicitly because:
+#   - we want to tag them in the same order they appear in the book, so tag search is in logical sequence
+#   - there are many *.tex garbage files in this directory
+TAGS: $(TEXFILES) exercise_solutions.tex errata.tex
+	etags $^ -o $@.tmp
+	mv $@.tmp $@
+
+indexterms.txt:					\
+	other/index-helper.py			\
+	front.tex				\
+	preface.tex				\
+	introduction.tex			\
+	preliminaries.tex			\
+	basics.tex				\
+	logic.tex				\
+	equivalences.tex			\
+	induction.tex				\
+	hits.tex				\
+	hlevels.tex				\
+	homotopy.tex				\
+	categories.tex				\
+	setmath.tex				\
+	reals.tex				\
+	formal.tex
+		other/index-helper.py >$@

README.md

@@ -0,0 +1,72 @@
+This is a textbook on informal homotopy type theory.
+It is part of the [Univalent foundations of mathematics](http://www.math.ias.edu/sp/univalent)
+project that took place at the Institute for Advanced Study in 2012/13.
+
+## License
+
+This work is licensed under the
+[Creative Commons Attribution-ShareAlike 3.0 Unported License](http://creativecommons.org/licenses/by-sa/3.0/).
+
+## Distribution
+
+Compiled and printed versions of the book are available at the
+[homotopy type theory website](http://homotopytypetheory.org/book),
+and nightly builds are available on the
+[github wiki](https://github.com/HoTT/book/wiki/Nightly-Builds).
+
+## Editing the book
+
+This book is not a community project, but we do welcome our readers to suggest improvements. The best way to propose an edit is to [open a pull request](https://github.com/HoTT/book/compare) with your suggested change. You can also [open an issue](https://github.com/HoTT/book/issues/new/choose) if you do not have a concrete proposal yet. The issues and the pull requests are dedicated to improvements, questions, and other issues pertaining to the HoTT book itself. General discussions about homotopy type theory and topics related to the wider HoTT community are welcome at the [homotopytypetheory google group](https://groups.google.com/g/homotopytypetheory) or at the [HoTT zulip](https://hott.zulipchat.com). For further directions about editing the book, see the [guidelines for contributions](https://github.com/HoTT/book/blob/master/CONTRIBUTING.md)
+
+## Code of conduct
+
+For many, the HoTT book is their introduction to our subject and our diverse community, including people from any nationality, gender identity, sexual orientation, race, color, ability, and background. In order to ensure for everyone a welcoming and inclusive environment in our discussions, we follow the guidelines of the [GitHub code of conduct](https://docs.github.com/en/site-policy/github-terms/github-community-forum-code-of-conduct). You can expect from the authors and any participant that we are kind and respectful in discussions, that we use inclusive language, and that we do our best to understand each other's different perspectives. It might not always be that we accept the change in the way you proposed it, but we always value your input, regardless of your level of experience or status within the community.
+
+## Prerequisites and compilation
+
+To compile the book for yourself you need a fairly new version of LaTeX.
+[Texlive](http://www.tug.org/texlive/) 2012 is confirmed to work. You might need
+to install some packages; see `main.tex` for packages that are used by the book.
+
+[BasicTeX](http://www.tug.org/mactex/morepackages.html), which is a minimalistic
+version of MacTeX, is confirmed to work once the following packages have been
+installed: `tlmgr`, `install`, `braket`, `comment`, `courier`, `enumitem`,
+`helvetic`, `mathpazo`, `nextpage`, `ntheorem`, `palatino`, `rsfs`, `stmaryrd`,
+`symbol`, `titlesec`, `wallpaper`, `wasy`, `wasysym`, `xstring`, `zapfding`.
+
+You also need the `make` utility. The book is a fairly complex piece of LaTeX
+code. Also, the file `version.tex` is generated on the fly, so you will need the
+`make` utility with which you can compile the main files, as follows:
+
+* `make hott-online.pdf` -- the book appropriate for online reading, with colors and green links
+* `make hott-ebook.pdf` -- the book with small margins, suitable for ebook readers
+* `make hott-ebook-wide.pdf` -- the book with small margins, suitable for ebook readers, wider page
+* `make hott-ebook-narrow.pdf` -- the book with small margins, suitable for ebook readers, narrower page
+* `make hott-letter.pdf cover-letter.pdf` -- the book in black & white, letter paper format,
+   for printing at home, as well as a color cover (just two pages)
+* `make hott-a4.pdf cover-a4.pdf` -- the book in black & white, A4 paper format,
+   for printing at home, as well as a color cover (just two pages)
+* `make hott-arxiv.pdf` -- the version that is uploaded to arXiv
+* `make hott-letter-exercises.pdf` -- the book in black & white, letter paper format, but with exercises one-per-page
+* `make hott-a4-exercises.pdf` -- the book in black & white, A4 paper format, but with exercises one-per-page
+* `make hott-ustrade.pdf cover-lulu-hardcover.pdf cover-lulu-paperback.pdf` --
+   the book in US Trade format, without cover, used for the bound copy available
+   at http://lulu.com/
+* `make exercise_solutions.pdf` -- (some) solutions to exercises
+* `make errata.pdf` -- errata for the HoTT Book, first edition
+
+Note: once `make` is run so that `version.tex` is generated, you need not run `make` every time you make
+a change to the source file. You can just perform the usual LaTeX cycle from your favorite editor.
+
+#### Compiling without `make`
+
+If you do not have `make` (for example, because you are on MacOS and you did not
+install the XCode command-line utilities), you can still fake it as follows.
+Create the file `version.tex` and put in it (where "Joe Hacker" should be
+replaced with your name):
+
+    \newcommand{\OPTversion}{Joe-Hacker-version}
+
+Then use whatever tools you normally do to compile LaTeX. The main LaTeX files are called 
+`hott-XXX.tex`. But you really should have `make`, you know.
+

back.tex

@@ -0,0 +1,17 @@
+\ifOPTcover
+\cleartooddpage[\thispagestyle{empty}]
+\pagestyle{empty}
+\cleartoevenpage
+
+%%%%%%%%%%%%%%%%%%%% Back cover %%%%%%%%%%%%%%%%%%%%
+\ThisLRCornerWallPaper{0.7}{\OPTbackimage}
+\pagecolor{covercolor}
+\color{covertext}
+\input{blurb.tex}
+\else
+\fi
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "hott-online"
+%%% End: 

blurb.tex

@@ -0,0 +1,32 @@
+% Blurb on back cover, gets included in lulu cover as well
+% as regular version, so be careful with formatting
+
+{
+\parindent=0pt
+\parskip=\baselineskip
+{\OPTbacktitlefont
+\textit{From the Introduction:}}
+\OPTbackfont
+
+\emph{Homotopy type theory} is a new branch of mathematics that combines aspects of several different fields in a surprising way. It is based on a recently discovered connection between \emph{homotopy theory} and \emph{type theory}.
+It touches on topics as seemingly distant as the homotopy groups of spheres, the algorithms for type checking, and the definition of weak $\infty$-groupoids.
+
+Homotopy type theory brings new ideas into the very foundation of mathematics.
+On the one hand, there is Voevodsky's subtle and beautiful \emph{univalence axiom}.
+The univalence axiom implies, in particular, that isomorphic structures can be identified, a principle that mathematicians have been happily using on workdays, despite its incompatibility with the ``official'' doctrines of conventional foundations.
+On the other hand, we have \emph{higher inductive types}, which provide direct, logical descriptions of some of the basic spaces and constructions of homotopy theory: spheres, cylinders, truncations, localizations, etc.
+Both ideas are impossible to capture directly in classical set-theoretic foundations, but when combined in homotopy type theory, they permit an entirely new kind of ``logic of homotopy types''.
+
+This suggests a new conception of foundations of mathematics, with intrinsic homotopical content, an ``invariant'' conception of the objects of mathematics --- and convenient machine implementations, which can serve as a practical aid to the working mathematician.
+This is the \emph{Univalent Foundations} program.
+
+The present book is intended as a first systematic exposition of the basics of univalent foundations, and a collection of examples of this new style of reasoning --- but without requiring the reader to know or learn any formal logic, or to use any computer proof assistant.
+We believe that univalent foundations will eventually become a viable alternative to set theory as the ``implicit foundation'' for the unformalized mathematics done by most mathematicians.
+
+\bigskip
+
+\begin{center}
+  {\Large
+  \textit{Get a free copy of the book at HomotopyTypeTheory.org.}}
+\end{center}
+}

bmpsize-hack.tex

@@ -0,0 +1,38 @@
+\RequirePackage{bmpsize-base}
+\RequirePackage{ifpdf}
+\makeatletter
+% Fix \includegraphics for dvi mode, but only if not making a pdf
+\ifpdf
+  \expandafter\@gobble
+\else
+  \expandafter\@firstofone
+\fi{%
+\AtBeginDocument{%
+\let\Gin@ii@old=\Gin@ii
+\def\Gin@ii[#1]#2{%
+  \begingroup
+    \let\@found\@empty
+    \@for\@type:=\bmpsize@types\do{%
+      \ifx\@found\@empty
+        \@nameuse{bmpsize@read@\@type}{#2.\@type}%
+        \ifbmpsize@ok
+          \let\@found=\@type
+        \fi
+      \fi
+      \ifx\@found\@empty
+        \@nameuse{bmpsize@read@\@type}{#2}%
+        \ifbmpsize@ok
+          \let\@found=\@type
+        \fi
+      \fi
+    }%
+    \ifx\@found\@empty
+      \Gin@ii@old[#1]{#2}%
+    \else
+      \Gin@ii@old[natwidth=\bmpsize@width bp,natheight=\bmpsize@height bp,#1]{#2}%
+    \fi
+  \endgroup
+}%
+}
+}
+\makeatother

check-errata

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+! grep -o '% merge of.\+' errata.tex

coq_introduction/.gitignore

@@ -0,0 +1,7 @@
+*.vo
+*.glob
+N*.cmi
+N*.cmx
+N*.cmxs
+N*.native
+N*.o

coq_introduction/Makefile

@@ -0,0 +1,32 @@
+.PHONY: all pdf html tex glob tidy clean
+
+all: pdf html tex glob
+
+glob: Reading_HoTT_in_Coq.v
+	coqc Reading_HoTT_in_Coq.v
+
+tex: glob 
+	coqdoc --latex --no-lib-name --toc Reading_HoTT_in_Coq.v
+
+html: glob
+	coqdoc --html  --no-lib-name --toc --no-index Reading_HoTT_in_Coq.v
+
+pdf: tex
+	pdflatex Reading_HoTT_in_Coq.tex
+
+tidy:
+	-rm Reading_HoTT_in_Coq.vo
+	-rm Reading_HoTT_in_Coq.out
+	-rm Reading_HoTT_in_Coq.log
+	-rm Reading_HoTT_in_Coq.aux
+	-rm NReading_HoTT_in_Coq*
+	-rm coqdoc.sty
+
+clean: tidy
+	-rm Reading_HoTT_in_Coq.tex
+	-rm Reading_HoTT_in_Coq.html
+	-rm Reading_HoTT_in_Coq.glob
+	-rm Reading_HoTT_in_Coq.pdf
+	-rm coqdoc.css
+	-rm index.html
+

coq_introduction/Reading_HoTT_in_Coq.v

@@ -0,0 +1,1602 @@
+(** * Reading Coq Files
+*)
+
+(**
+----------------------
+If you're reading a #HTML# %PDF% file, it was generated from a Coq
+file using Coq's documentation tool, "coqdoc".  
+
+If the file extension is ".v", you have the original Coq file and can
+read it in any text editor ("Notepad" on Windows, "TextEdit" on Macs).
+If you've installed CoqIDE, Coq's graphical editor, you can open it
+there and verify the proofs.  It can also be used on the web at
+http://prover.cs.ru.nl/
+*)
+(* When reading the Coq file, you will see the coqdoc commands.  
+These include special text #only for HTML# or %only for LaTeX% 
+(or $LaTeX's math mode$). *)
+(* The following stop coqdoc from changing the operators for HTML/PDF *)
+(** remove printing -> *)
+(** remove printing * *)
+(** remove printing => *)
+(** remove printing forall *)
+(**
+----------------------
+*)
+
+(**
+This document is a light-weight introduction to Coq using examples
+from the first half of the book "Homotopy Type Theory".  Our goal is
+to give readers a taste of using a proof assistant.  When you're done,
+you will be able to read what other people have proven in Coq and
+possibly prove some simple theorems of your own.
+
+If you are interested in going further with Coq, at the end of this
+document are instructions on how to install Coq, links to full
+tutorials, and links to the Coq Reference Manual.
+
+This file is written in "plain" Coq 8.4.  This so it can be used with
+the official distribution or on the web at http://prover.cs.ru.nl/.
+This will prevent us from doing proofs that use "higher inductive
+types", a feature that is only available with a special version of
+Coq.
+
+While this file stands on its own, where possible, we use the same
+theorem names as the "HoTT" library for Coq.  When you're done reading
+this file, you should be able to read most of what has been proven in
+that library.
+*)
+
+(** ** Background *)
+(**
+Coq is a good platform for homotopy type theory ("HoTT") work.  Coq
+has a long history - created in 1984 - and is supported by INRIA.  Coq
+has a number of features that have allowed it to be used for
+significant proofs.  Those proofs include the formalization of the
+Four Color Theorem and the Feit-Thompson Theorem.
+
+Coq uses a dependent type theory derived from "The Calculus of
+Constructions".  It differs from Martin-Loef's intentional
+type theory, but, as we'll see, its propositional equality has the
+same higher-groupoid structure that allows us to do HoTT.
+*)
+
+(** * Introduction *)
+(**
+Coq mostly works with two concepts:
+  - dependent functions (#Pi#$\Pi$-types) 
+  - inductive types 
+
+Inductive types are used to implement the common types of type theory:
+dependent pairs (#Sigma#$\Sigma$-types), disjoint unions, etc..  We'll
+use those types as many of our examples.
+
+We'll start with the familiar example of Peano's natural numbers.
+*)
+
+(** ** Natural Numbers *)
+(**
+The book's description of natural numbers says:
+-   the type N:U of natural numbers.
+whose elements are constructed using
+-   0:N, and
+-   the successor operation succ:N->N.
+
+The equivalent in Coq is:
+*)
+
+Inductive nat : Set :=
+  | O : nat
+  | S : nat -> nat.
+
+(**
+As you can see, Coq's default library uses different names:
+-   [nat] instead of "N",
+-   [Set] instead of "U",
+-   [O] (the capital letter "oh") instead of "0", and
+-   [S] instead of "succ".
+
+The command [Inductive] creates a new type.  In this case, the type is
+called [nat].  The type [nat] will live in the universe type called
+[Set], which in Coq is the first universe or "the universe of small
+types".
+
+After the [:=] symbol comes the constructors for the new type.  The
+first says [O] (the capital letter "oh") is a term of type [nat].  The
+second says [S] is a function from [nat]s to [nat]s.
+
+After the last constructor is a period (".").  The command that
+started with the word "Inductive" ends at the period.  Every command
+in Coq ends with a period.
+*)
+
+(** *** Properties of Constructors *)
+(**
+The constructors of an inductive type have a number of properties.  In
+a rough description, the major properties are:
+
+- Constructors are axiomatic.  The function [S] exists without any
+  definition - while it can be called, it cannot be evaluated.
+
+- The constructors are exhaustive.  There is no other way to create a
+  term of type [nat].
+
+- Constructors create well-founded terms.  There is no way to create a
+  self-referential [nat], such as having an [S] that returns itself.
+
+- Terms created with different constructors are not equal.  [O] is not
+  equal to [S] called with any other [nat].
+
+If you know Peano's Axioms, these should all seem familiar.  But these
+conditions apply to every inductive type, not just [nat].
+
+NOTE: Homotopy type theory changes some of these properties.  The
+univalence axiom and the path constructors of higher inductive types
+create new elements of the identity type.  Higher inductive types can
+define terms created with different constructors as propositionally
+equal.
+*)
+
+(** *** Examples of Natural Numbers *)
+(**
+Coq's command [Check] will print out the type of a term.  Obviously,
+[O] is a valid term and the [Check] will print the type [nat].
+(Remember, [O] here is the capital letter "oh".)
+*)
+(* CoqIDE users: In CoqIDE, the Check command does nothing.  Instead,
+highlight the term, open the "Queries" menu, and select [Check]. *)
+
+Check O.
+
+(**
+To get the number one, we have to call the function [S].  A function
+call (or "function application") in Coq is done by juxtaposition, so
+-   gcd 4 6
+instead of 
+-   gcd(4, 6)
+
+Thus, the number one is written:
+*)
+
+Check S O.
+
+(**
+For the number two, we have to add parentheses so that the second S is
+interpreted as a function call rather than as a second argument to the
+first S.
+*)
+
+Check S (S O).
+
+(**
+The number five is 
+*)
+
+Check S (S (S (S (S O)))).
+
+
+(** 
+By default, Coq loads a plugin that interprets decimal numbers as [nat]s.
+*)
+
+Require Import Datatypes.
+Declare ML Module "nat_syntax_plugin".
+
+(**
+Thus, we could have checked the number five simply by doing
+*)
+
+Check 5.
+
+(** 
+Now that we have seen the basics of Coq's inductive types, let's see
+its other main feature: dependent functions.
+*)
+
+(** ** Identity function *)
+(**
+We'll start by defining the identity function on natural numbers and
+then we'll write a dependently-typed identity function that works for
+any type.  
+
+The identity function (or identity map) for natural numbers is:
+*)
+
+Definition idmap_nat : nat -> nat :=
+  fun (n:nat) => n.
+
+(**
+The [Definition] command assigns a value of a given type to a name.
+Its format is:
+-   Definition <name> : <type> := <value> .
+
+In our example, the name is "idmap_nat".  The type is a function from
+[nat] to [nat].  (Notice how the "->" operator approximates the arrow
+used in the book for non-dependently typed functions.)  The value for
+"idmap_nat" is a function.
+
+In Coq, a function is written:
+-   fun <params> => <term>
+
+In the book, this would have been written as
+-   <param> #\mapsto# $\mapsto$ <term>
+or
+-   #\lambda# $\lambda$ <param>.<term>
+
+In the example, the function has one parameter, "n", which has type
+[nat].  The function's result is simply "n" itself, since this is the
+identity function.
+*)
+
+(** *** Shorthand *)
+(**
+Coq has a shorthand for defining functions.  Here is the identity
+function for [nat]s again.
+*)
+
+Definition idmap_nat_short (n:nat) : nat :=
+  n.
+
+(**
+Notice that the parameter is put immediately after the function's name
+and we no longer need "fun ... =>".
+*)
+
+(** *** Examples of idmap_nat *)
+(**
+The Coq command [Compute] will evaluate a function and print the result.
+*)
+(* !!! There is no equivalent in CoqIDE? *)
+
+Compute idmap_nat (S O).
+
+(** prints (S O), like an identity function should. *)
+
+
+(** *** Dependant types *)
+(**
+"idmap_nat" is not dependently typed, so we were able to use the arrow
+("->") to denote its type.  We could have written the function's type
+as if it was dependently typed. In the book, dependent types are
+declared with a capital "#Pi#$\Pi$".  Coq uses the keyword [forall].
+*)
+
+Definition idmap_nat_dep : forall nn:nat, nat :=
+  fun n:nat => n.
+
+(** 
+In Coq, a dependent function type is written:
+-   forall <params> , <type>
+
+In the book, this would have used capital #Pi#$\Pi$ and a subscript:
+-   #\Pi#$\Pi$ (<param>) <type>
+
+As you'd expect, the names in the param list of a [forall] expression
+are only bound inside the "<type>" part of the [forall].  In this
+example, the parameter "nn" cannot be used when defining the function.
+(Usually, we use the same name in the [forall] and the [fun] parts;
+different ones were used here to demonstrate the point.)
+
+A [forall] can have multiple parameters.  If a parameter is
+dependently typed on another parameter, the dependent one must come
+later in the list.  (We'll see an example soon.)
+
+
+Now that we know how to write a dependent function type, we can
+write an identity function that works for any type.
+*)
+
+Definition idmap : forall A:Type, A -> A := 
+  fun (A:Type) (x:A) => x.
+
+(** 
+"idmap" is a dependently-typed function: its return type depends on the
+type of its first parameter.  Therefore, we had to use the [forall]
+operator for that parameter.  
+
+In Coq, the type "Type" refers to _some_ universe type.  Coq will do
+the work of figuring out which universe type, as long as we don't
+implicitly cause impredicativity.
+
+We can, of course, rewrite the definition of "idmap" using Coq's
+shorthand for functions.
+*)
+
+Definition idmap_short (A:Type) (x:A) : A := 
+  x.
+
+(** *** Examples of idmap *)
+
+Compute idmap nat (S (S O)).
+
+(** Prints (S (S O)), like an identity function should. *)
+
+(**
+Coq has a number of features for making it easier to define and call functions.  We've already seen the "shorthand" for definitions.  In the rest of this section, we'll see:
+- partial application, 
+- implicit arguments, and 
+- type inferencing.
+*)
+
+(** *** Partial application *)
+(**
+Since we've defined the identity function for any type, we can now
+define the identity function for [nat]s in terms of it.
+*)
+
+Definition idmap_nat_from_idmap : nat -> nat :=
+  idmap nat.
+
+(**
+The value "idmap nat" is a function call.  It calls the function
+"idmap" with the type [nat].  Since "idmap" expected 2 arguments and
+we only provided 1, this is called a "partial application".  The
+result of the partial application is a function that is still waiting
+for 1 more argument.  That function is the identity function on [nat]s
+and this command assigns it a name.
+
+
+We can check this new function by passing the second of the two arguments.
+*)
+
+Compute idmap_nat_from_idmap (S (S (S O))).
+
+
+(** *** Implicit Arguments *)
+(**
+Calling "idmap nat (S O)" seems repetitive because Coq can determine
+that "(S O)" has type [nat].  (Remember, in type theory, an element
+can belong to only one type.)  We can use Coq's implicit arguments
+feature to tell Coq to always infer some argument values.
+
+Curly braces are used to mark a parameter for implicit arguments.
+*)
+
+Definition idmap_implicit {A:Type} (x:A) : A := 
+  x.
+
+(**
+Now, we can call the general identity function with just one argument.
+*)
+
+Compute  idmap_implicit (S O).
+
+(**
+Implicit arguments are usually handy, but sometimes they get in the
+way.  Before, we declared a version of "idmap_nat" by calling "idmap".
+We did it by passing "nat" as the first parameter to "idmap".
+
+If we call "idmap_implicit" with "nat", Coq will assume that [nat] is
+"x" and use the type of [nat], which is [Set], for the implicit
+parameter.  Obviously, we don't want that.  We can prevent Coq from
+using implicit arguments by putting an "at sign" ("@") in front of the
+function name.
+*)
+
+Definition idmap_nat_from_idmap_implicit : nat -> nat :=
+  @idmap_implicit nat.
+
+Compute idmap_nat_from_idmap_implicit (S O).
+
+(**
+Another way to mark parameters for implicit arguments is with the
+"Arguments" command.  Because that command has a lot of features and
+complex syntax, we won't go into its details in this document.
+Nonetheless, we will use the command so that our examples look like
+those of the HoTT Coq library.
+*)
+
+
+(** *** Type Inferencing *)
+(**
+In many cases, Coq can infer the type of a parameter or even a whole
+function without us have to state it explicitly.  
+*)
+
+Definition idmap_inferred {A} (n:A) :=
+  n.
+
+(**
+Here, both the type of "A" (which is [Type]) and the returned type of
+the function (which is "A") are both inferred.  As you can see, this
+allows very concise definitions.
+*)
+
+Compute idmap_inferred (S (S O)).
+
+
+(** ** Addition of Natural Numbers *)
+(**
+As the last part of our introduction, we define addition as a function
+on natural numbers and show how to use the operator "+" to call it.
+*)
+(** *** Induction *)
+(**
+When we issued the command [Inductive] to create the type [nat], Coq
+also created a function "nat_rect" for induction on natural numbers.
+Its type is:
+[[
+  nat_rect
+     : forall P : nat -> Type,
+       P 0 -> 
+       (forall n : nat, P n -> P (S n)) -> 
+       forall n : nat, P n
+]]
+This is identical to the induction constant named "ind_N" in the HoTT
+book.  We can use this function to define addition.  
+*)
+
+Definition plus (m n: nat) :  nat :=
+  nat_rect (fun _ => nat) n (fun m' sum => S sum) m.
+
+(**
+The function "plus" is defined by a call to "nat_rect" with 4
+arguments:
+
+The first argument determines the type of the result.  Addition always
+results in a [nat], so the first argument is a function that always
+returns the type [nat].  When specifying the function, we used
+underscore ("_") which is a special parameter name that indicate to
+Coq that the parameter isn't used in the function.  (Multiple
+parameters can be named "_" if they are all not needed.)
+
+The second argument to "nat_rect" is "n".  This is the base case; the
+result when "m" is zero.
+
+The third argument is the inductive case.  It takes "m"-prime and the
+result (sum) upto "m"-prime and produces the result for the successor
+of "m"-prime, which is just the sum plus one.
+
+The fourth argument is "m", the value to calculate the sum at.
+*)
+
+Compute plus 4 2.
+
+(**
+In this example, we directly called the induction constant "nat_rect".
+This is one way to do induction in Coq.  The other way is similar to
+the "pattern matching" describing in the HoTT book.
+*)
+
+(** *** Match Expressions *)
+(**
+Addition can also be defined using a "match" expression.
+*)
+
+Fixpoint plus_using_match (m n: nat) :  nat :=
+  match m with
+      | 0 => n
+      | S m' => S (plus_using_match m' n)
+  end.
+
+(** 
+The [match] expression represents case analysis on an element of an
+inductive type.  Since every canonial element of an inductive type
+must have been made with a constructor, the [match] expression gives a
+value that depends on which constructor was used.  The [match]
+expression is very expressive, but a simplified understanding is:
+[[
+  match <element> with
+    | <constructor_pattern> => <value>
+    | <constructor_pattern> => <value>
+    ...
+  end
+]]
+NOTE: In HoTT, not every element of the identity type is made with a
+constructor.  Nonetheless, this case analysis still works.  See the
+HoTT book for an explanation.
+
+In our example, "m" is treated as a canonical [nat].  If "m" was made
+with the constructor constant [O] (capital-oh), the value of the
+[match] expression is "n".  If "m" was made with the constructor
+function [S] called with some other [nat], called "m"-prime here, then
+the value of the match expression is the successor of "m"-prime plus
+"n".
+
+Notice that the function is defined in terms of itself.  In order to
+allow that, we had to use command [Fixpoint] instead of the usual
+[Definition].  
+
+Coq will transform the match expression into a call to "nat_rect".  If
+it cannot, Coq will print an error message.
+*)
+(** *** Notations *)
+(**
+We could always represent addition with "plus 4 2", but it is more
+natural to read and write "4 + 2".  We tell Coq to use this format
+through [Notation] command.
+*)
+
+Notation "n + m" := (plus n m) : nat_scope.
+Open Scope nat_scope.
+
+(**
+Now we can write.
+*)
+
+Compute 4 + 2.
+
+(**
+We've actually already been using a notation.  The "->" operator is
+defined as: 
+*)
+
+Reserved Notation "x -> y" (at level 99, right associativity, y at level 200).
+Notation "A -> B" := (forall (_ : A), B) : type_scope.
+
+(**
+Because [Notation]s could conflict, every [Notation] goes into a
+scope.  Here, the scopes are called "nat_scope" and "type_scope".
+When a scope is opened, all of its notations become available to be
+used.  If two notations in open scopes conflict, the one opened more
+recently is used.  Here, "nat_scope" was opened by the command "Open
+Scope nat_scope".  The other, "type_scope", is special and is open
+anywhere a type is expected.
+
+If we ever wanted to stop using the plus [Notation], we could issue the
+command "Close Scope nat_scope".
+
+
+A more complex example is:
+*)
+
+Definition compose {A B C : Type} (g : B -> C) (f : A -> B) :=
+  fun x => g (f x).
+
+Notation "g 'o' f" := (compose g f) (at level 40, left associativity).
+
+(**
+The single quotes are used to turn the letter "o" (small-oh) into an
+operator. 
+
+"at level 40" indicates the precedence of the operator.  A lower
+precedence level means that an operator "binds more tightly".  That
+is, that a [Notation] is selected over another.  Thus, for natural
+numbers, multiplication is at level 40, while addition is at 50.
+(Those operators have default precedences set by a "Reserved Notation"
+command.)
+
+"left associativity" is what you would expect.
+*)
+
+(**
+That covers the basics of reading Coq theorems.  The rest of this
+document goes over the types, functions, and operators that are
+commonly used in type theory and in HoTT.
+*)
+
+(** * Common Types of Type Theory *)
+(**
+After a short discussion about universe types in Coq, we go through
+how each of the types that are commonly used in type theory are
+implemented as inductive types.
+*)
+
+(** ** Universes *)
+(**
+The HoTT book describes an infinite hierarchy of universes U_0, U_1,
+U_2, ... that are cumulative.  That is, that every type in a universe
+is also in every higher universe.
+
+Coq's universes have a similar structure, except that the lowest
+universe is split into two: "Prop" and "Set".  
+
+The "Prop" universe contains propositions - statements that can be
+proven or disproven.  In practice, that means types that are shown to
+be either inhabited or uninhabited.  Types in "Prop" must be "proof
+irrelevant": it cannot matter which term inhabits the type, just that
+it is inhabited.
+
+The "Set" universe contains all other "small types".  (Small types are
+ones that do not contain references to a universe.)  Since in homotopy
+type theory every equality proof is relevant, all of our inductive
+types will reside in the "Set" universe.
+
+The infinite number of universes above "Prop" and "Set" are known as
+"Type(1)", "Type(2)", "Type(3)", etc.  However, the user only ever has
+to enter "Type".  Coq will, behind the scenes, assigned a numbered
+universe to every usage of "Type", as long as there is no
+impedicativity.  (If you implicitly cause impredicativity, you'll see
+an error message.)
+*)
+
+(** ** Dependent Function Types *)
+(**
+The most commonly used type in type theory is the function.  This type
+in Coq was covered in detail earlier.  A summary of its usage is:
+
+The dependent type:
+-   Book: #\Pi#$\Pi$ (<params>)    <type>
+-   Coq:  forall <params> , <type>
+
+The non-dependent type:
+-   Book: <type> #->#$\to$ <type>
+-   Coq:  <type> -> <type>
+
+An unnamed function:
+-   Book: <param> #\mapsto#$\mapsto$ <term>
+-   Book: #\lambda#$\lambda$ <param> .   <term>
+-   Coq:  fun <params> =>  <term>
+
+A function call (or "function application"):
+-   Book:   <fun>(<arg1>, <arg2>)
+-   Coq:    <fun> <arg1> <arg2>
+
+Function composition:
+-   Book:  <fun> #o#$\circ$ <fun>
+-   Coq:   <fun> o <fun>
+
+*)
+(** ** Non-Dependent Pair Types *)
+(**
+In the HoTT book, the non-dependent pair type can be considered a
+special case of a dependent pair.  For example, the projection
+functions work the same on both the non-dependent and dependent types.
+In Coq, however, it is more convenient to have two separate types.
+
+In the book, the non-dependent pair type, or cartesian product, requires
+-   a type A : U, and
+-   a type B : U
+and is written
+-   A #\times# $\times$ B  
+
+In Coq, the inductive type is written:
+*)
+
+Inductive prod {A B:Type} : Type :=
+  pair : A -> B -> @prod A B.
+
+(**
+Here, "pair" is a constructor that takes two arguments, an element
+of type "A" and an element of type "B", and produces an element of
+type "prod A B".  So, "prod A B" is the type of non-dependent pairs
+and "pair a b" creates a pair.
+
+This inductive type definition uses a shortcut.  The types "A" and "B"
+are used in the constructor "pair", but are not listed as parameters.
+This is because any parameters listed immediately after the type name
+("prod") are treated as parameters to both the type of "prod" and to
+all constructors.
+
+
+An equivalent (but longer) definition of "prod" would be
+*)
+
+Inductive prod_long : Type -> Type -> Type :=
+  pair_long : forall {A B: Type}, A -> B -> prod_long A B.
+
+(** 
+When Coq creates "prod", it also creates the induction function
+"prod_rect".  This is the inductive constant, similar to "nat_rect" we
+mentioned earlier.  What we didn't say earlier is that there are _two_
+other induction functions: "prod_rec" and "prod_ind" (as well as
+"nat_rec" and "nat_ind").
+
+The reason for three induction constants is that there are three kinds
+of universes: "Prop", "Set", and "Type".  The function "prod_rect" and
+"nat_rect" puts the types they create in the "Type" universe.
+Likewise, "prod_rec" and "nat_rec" put the resulting type in "Set" and
+"prod_ind" and "nat_ind" put it in "Prop".  When doing HoTT, it is
+usually safe to just use the "rect" function.
+
+When we use a [match] expression for induction, Coq uses type
+inferencing to chose the correct induction function.  
+
+Speaking of duplication, Coq has a second non-dependent pair type
+called "and".  This type takes arguments from the "Prop" universe and
+puts the resulting type in "Prop".  But, since we're not using "Prop",
+we won't cover it here.
+*)
+
+
+(** *** Pair Notation *)
+(**
+From the definition of "pair_long", it is clear that the constructor
+takes 4 parameters: two types and an element of each type.  But given
+the two elements, Coq can always infer their types.  Thus, we can
+create a pair using just the two elements.  For example:
+*)
+
+Check (pair 4 2).
+
+(** 
+In the book, we use "A #\times# $\times$ B" to denote the type and
+"(a,b)" to denote a pair.  Coq allows us to use a similar syntax by
+using the [Notation] command.
+*)
+
+Notation "x * y" := (@prod x y) : type_scope.
+Notation "( x , y , .. , z )" := (pair .. (pair x y) .. z) : core_scope.
+
+(**
+Now when Coq sees "nat * nat", it will translate it into "(prod nat
+nat)" and, likewise, translate "(4, 2)" into "(pair 4 2)".  The second
+[Notation] command will also convert tuples of any length into
+pairs-within-pairs.
+
+Now, we can write the type and elements of dependent pairs like we're
+accustomed.
+*)
+
+Check (nat * nat)%type.
+Check (4,2).
+
+(**
+The "%%type" forces Coq to use the "type_scope" to interpret the
+expression.  It is needed because [Check] does not expecting a type.
+*)
+
+(** *** Projection functions *)
+(**
+The projection functions extract the first or second part of a pair.
+For non-dependent pairs in Coq, these are called "fst" and "snd".
+*)
+
+Section projections.
+  Context {A : Type} {B : Type}.
+
+  Definition fst (p:A * B) := 
+    match p with
+      | (x, y) => x
+    end.
+
+  Definition snd (p:A * B) := 
+    match p with
+      | (x, y) => y
+    end.
+
+End projections.
+
+(**
+The section feature is used here to simplify the list of parameters.
+The section starts with "Section projections" and ends at "End
+projections".  The statement "Context ..." signals that "A" and "B"
+are parameters to every subsequent definition that uses them inside
+the section.  Thus, both "fst" and "snd" have two type parameters and,
+because curly braces ("{", "}") were used, those parameters are
+implicit.
+
+In the [match] expressions, the constructor function "pair" is written
+using the notation "(x, y)".
+*)
+
+Compute fst (4,2).
+Compute snd (4,2).
+
+
+(** ** Dependent Pair Types *)
+(**
+In the HoTT book, the dependent pair type, also called #Sigma#$\Sigma$-type,
+requires
+-   a type A : U, and
+-   a type family P : A -> U
+and is written
+-   #\Sigma#$\Sigma$ (x:A) P(x)
+
+In Coq, it is defined by:
+*)
+
+Inductive sigT {A:Type} (P:A -> Type) : Type :=
+    existT : forall x:A, P x -> sigT P.
+
+(**
+Here, "existT" is the constructor that takes two arguments, an element
+"x" of type "A" and an element (unnamed) of type "P x", and produces
+an element of "sigT A P".  So, "sigT A P" is the type of pairs and
+"existT x p" creates a pair (when "p" has type "P x").
+
+If you read closely, you'll see that the type produced by "existT" is
+"sigT P" not "sigT A P".  The "A" can always be inferred from "P".
+
+To repeat (for the last time), every time Coq creates a new inductive
+type, like "sigT" here, Coq also creates three induction functions,
+"sigT_ind", "sigT_rec" and "sigT_rect".  These functions put their
+results into the "Prop", "Set", and "Type" universes (respectively).
+Most of the time, we don't care, since we'll use a [match] expression
+that infers which induction function to use.
+
+Like "prod" with "and", Coq has dependent pair types besides "sigT".
+The types "ex" (short for "there exists") and "sig" both act as
+dependent pairs, but use the "Prop" universe.  Again, we're not using
+"Prop", we won't cover them here.
+*)
+
+(** *** Pair Notation *)
+(**
+To create a dependent pair, we must supply a function taking an
+element of the first type to a type for the second element.  Since we
+haven't defined propositional equality, we can't do much that is
+interesting here. For now, we can create a pair of [nat]s by supplying
+a function that always returns [nat].
+*)
+
+Check (existT (fun _:nat => nat) 4 2).
+
+(** 
+Obviously, that expression is long to write and difficult to read and
+we want to use a [Notation] for it.  Since Coq already uses "(a,b)"
+for non-dependent pairs, the HoTT Coq library uses the semicolon here.
+*)
+
+Notation "{ x : A  & P }" := (sigT (fun x:A => P)) : type_scope.
+Notation "( x ; y )" := (existT _ x y) : fibration_scope.
+Open Scope fibration_scope.
+
+(**
+When Coq sees "(4;2)", it will translate that into "(existT _ 4 2)".
+The underscore ("_") in a function application indicates that Coq
+should try to infer the argument or ask for help from the user.
+
+Here the dependent-pair [Notation] goes into the "fibration_scope".
+Since that is a new scope, we must "Open" it to make the [Notation]
+available.
+*)
+
+(**
+Below is an example using the dependent pair "(4;2)".  It is necessary
+to say what its type is, so that Coq can infer the hidden argument to
+"existT".
+*)
+
+Definition dep_pair_example_type := 
+  { x:nat & nat }.
+Definition dep_pair_example : dep_pair_example_type := 
+  (4;2).
+Check dep_pair_example.
+
+(** *** Projection functions *)
+(**
+The projection functions extract the first or second part of a pair.
+For dependent pairs in Coq, these are called "projT1" and "projT2".
+*)
+
+Section Projections.
+
+  Context {A : Type}.
+  Context {P : A -> Type}.
+
+  Definition projT1 (x:sigT P) : A := 
+    match x with
+      | (a; _) => a
+    end.
+
+  Definition projT2 (x:sigT P) : P (projT1 x) :=
+    match x return P (projT1 x) with
+      | (_; h) => h
+    end.
+
+End Projections.
+
+(** 
+These are pretty much as you'd expect.  There are two items worth
+commenting on.
+
+The underscore ("_") in the constructor pattern is used to indicate an
+unused parameter in the [match] expression.  We've seen this before in
+parameters to [fun] and [forall].
+
+The other feature worth commenting on is the "return <type>" in the
+[match] expression of "projT2".  This syntax is used when the [match]
+expression has a type that depends on the element of the inductive
+type being matched on.
+
+We will not go into all the details on the variations of the [match]
+expression, because this document is about reading what has been
+proven - that is, the _type_ of an expression - and not about
+understanding the proof - which is the value of the expression.
+
+
+The [Notation]s for the projectors are:
+*)
+
+Notation "x .1" := (projT1 x) (at level 3) : fibration_scope.
+Notation "x .2" := (projT2 x) (at level 3) : fibration_scope.
+
+(**
+And some examples of it are:
+*)
+
+Check (dep_pair_example .1).
+Check (dep_pair_example .2).
+
+
+(** ** Disjoint Union Type*)
+(**
+In the HoTT book, the disjoint union type, also called coproduct,
+requires
+-   a type A : U, and
+-   a type B : U
+and is written
+-   A + B.
+
+In Coq, it is defined by:
+*)
+
+Inductive sum (A B:Type) : Type :=
+  | inl : A -> sum A B
+  | inr : B -> sum A B.
+
+Arguments inl {A B} _ , [A] B _.
+Arguments inr {A B} _ , A [B] _.
+
+Notation "x + y" := (sum x y) : type_scope.
+
+(** 
+Ignoring the "Arguments" command, which we aren't covering in this
+document, the rest should be familiar by now.
+
+Since the type "sum" has two constructors, "inl" and "inr", we can
+have two examples that build an element of a type.
+*)
+
+Definition dijoint_union_example_type := 
+  (nat + (nat * nat))%type.
+Definition dijoint_union_example1 : dijoint_union_example_type := 
+  inl 4.
+Definition dijoint_union_example2 : dijoint_union_example_type := 
+  inr (4,2).
+
+(**
+Likewise, any [match] expression needs to handle both constructors.
+*)
+
+Definition left_or_first (a : dijoint_union_example_type) : nat :=
+  match a with
+      | inl x => x
+      | inr p => fst p
+  end.
+
+(** ** Zero, One, and Two Types *)
+(**
+The finite types with 0, 1, and 2 elements play special roles in type
+theory.  In standard Coq those types are:
+*)
+
+Inductive Empty_set : Set :=.
+
+Inductive unit : Set :=
+    tt : unit.
+
+Inductive bool : Set :=
+  | true : bool
+  | false : bool.
+
+(**
+The HoTT Coq library uses slightly different names for the types.
+(Although the constructors have the same names.)
+*)
+
+Definition Empty := Empty_set.
+Definition Unit  := unit.
+Definition Bool  := bool.
+
+(**
+Standard Coq also has finite types that live in the "Prop" universe.
+The type "True" has one constructor and the type "False" has zero.
+*)
+(** *** Not operator *)
+(**
+In HoTT, the not operator indicates that elements of a type can be
+mapped to the elements of the empty (zero) type.
+*)
+
+Definition not (A:Type) : Type := A -> Empty.
+Notation "~ x" := (not x) : type_scope.
+
+(**
+In Standard Coq, logic is usually done in the "Prop" universe, so this
+operator maps to the type "False" that lives there (instead of "Empty"
+which lives in "Set").
+*)
+
+(** *** Absurdity Implies Anything *)
+(**
+Obviously, a [match] expression for the [Unit] type handles one
+constructor and the match expression for the [Bool] type handles two
+constructors.  But what about the [Empty] type?  It has no
+constructors, so its [match] expression is empty.  In logic, this is the
+equivalent of "ex falso quodlibet" or "from contradiction, anything". 
+*)
+
+Definition contradiction_implies_anything (a:Empty) (C:Type) : C :=
+  match a with
+      end.
+
+(**
+The induction constant for Empty is
+[[
+  Empty_rect : forall (P : Empty -> Type) (e : Empty), P e
+]]
+*)
+
+
+(** ** Identity Type *)
+(**
+The identity type is defined as:
+*) 
+
+Inductive paths {A : Type} (a : A) : A -> Type :=
+  idpath : paths a a.
+
+(**
+Where "paths" equates to "Id" in the HoTT book and "idpath" to "refl".
+
+The standard Coq library defines equality using a type "eq" with
+constructor "refl".  This type is different from "paths" because "eq"
+is in the "Prop" universe and its elements are _not_ proof-relevant.
+To do homotopy type theory, we need an equality that is proof-relevant
+and exists in the "Type" universe.
+
+The operator for the identity type is the equal sign.  There is also a
+[Notation] that allows the user to explicitly state the type.
+*)
+
+Notation "x = y :> A" := (@paths A x y) : type_scope.
+Notation "x = y" := (x = y :>_) : type_scope.
+
+Arguments idpath {A a} , [A] a.
+Arguments paths_ind [A] a P f y p.
+Arguments paths_rec [A] a P f y p.
+Arguments paths_rect [A] a P f y p.
+
+Notation "1" := idpath : path_scope.
+Local Open Scope path_scope.
+
+
+(** * Homotopy Type Theory *)
+(**
+Now that we have seen the common types of type theory, we can use them
+to do homotopy type theory.  This section will demonstrate some
+theorems of HoTT and introduce the types used to do HoTT in Coq.
+Because this file is using "standard" Coq, we cannot demonstrate
+higher inductive types.
+*)
+
+(** ** Properties of Paths *)
+(**
+For every element of a type, there is a constant path.  This is the
+same notion as equality being reflexive.  This property is witnessed
+by "idpath", which has type:
+[[
+  @idpath
+     : forall {A : Type} (a : A), a = a
+]]
+
+The "theorem" of reflexivity can be stated "for every type and for
+every element of that type, there is an equality with that element
+equal to itself".  In Coq, that theorem is "proven" by function that
+takes a type, an element of that type, and returns an element
+witnessing the equality.
+
+For example, if we wanted to demonstrate that "4=4", we could do:
+*)
+
+Check @idpath nat 4.
+
+(**
+which is an element that has type "4=4".  Obviously, with implicit
+arguments, we do not need "nat" and can use just "idpath 4".  Not so
+obviously, we can go a step further.  If type inferencing can determine
+the type returned by "idpath", such as "4=4" in our example, then
+implicit arguments can fill in the "4" as well!  So most of the time
+you will just see "idpath" or its [Notation], "1" (in the "path_scope"
+scope).
+*)
+
+Check idpath : 4 = 4.
+Check 1 : 4 = 4.
+
+(**
+Next, we prove that every path has an inverse.  (Or, "equality is
+symmetric".)  In Coq, this proof looks like a function that takes any
+path and returns its inverse.
+*)
+
+Definition inverse {A : Type} {x y : A} (p : x = y) : y = x
+  := match p with 
+       | idpath => idpath
+     end.
+
+Arguments inverse {A x y} p : simpl nomatch.
+
+Notation "p ^" := (inverse p) (at level 3) : path_scope.
+
+(** 
+This [match] expression hides a number of type inferences and implicit
+arguments.  The type of "p" is "paths A x y", which had to be
+constructed using "idpath A x" with "y" being the same as "x".  The
+value returned by the match has type "paths A y x", so Coq can infer
+that the arguments to "idpath" are "A" and "x" and, because "y" is the
+same as "x", intrepret the resulting "A x x" as "A y x".
+
+Notice how this proof is similar to the HoTT book's proof where "y"
+is assumed to be the same as "x" and "refl_x" is mapped to "refl_x".
+
+
+Next, we prove that paths concatenate.  (Equality is transitive.)
+Like before, this is a function that takes any path from "x" to "y"
+and any path from "y" to "z" and returns a path from "x" to "z".
+*)
+
+Definition concat {A : Type} {x y z : A} (p : x = y) (q : y = z) : x = z :=
+  match p, q with 
+     | idpath, idpath => idpath 
+  end.
+
+Arguments concat {A x y z} p q : simpl nomatch.
+
+Notation "p @ q" := (concat p q) (at level 20) : path_scope.
+
+(**
+The comma in the [match] expression is part of the [match] syntax.  It
+is _not_ a non-dependent pair.  It is a shortcut that allows two
+inductions to be done using a single [match] expression.  When the
+[match] gets translated into two calls to "paths_rect", we don't care
+in which order the calls happen; the results are the same.  As the
+HoTT book explains, this proof could be done with just one call to
+"path_rect", but the result from a single induction would not behave
+symmetrically.
+
+The following proofs show the relationship of "idpath", "inverse" and
+"concat". 
+*)
+
+Definition concat_p1 {A : Type} {x y : A} (p : x = y) : p @ 1 = p :=
+  match p with idpath => 1 end.
+Definition concat_1p {A : Type} {x y : A} (p : x = y) : 1 @ p = p :=
+  match p with idpath => 1 end.
+
+Definition concat_pV {A : Type} {x y : A} (p : x = y) : p @ p^ = 1 :=
+  match p with idpath => 1 end.
+Definition concat_Vp {A : Type} {x y : A} (p : x = y) : p^ @ p = 1 :=
+  match p with idpath => 1 end.
+
+Definition inv_V {A : Type} {x y : A} (p : x = y) : p^^ = p :=
+  match p with idpath => 1 end.
+
+Definition concat_p_pp {A : Type} {x y z t : A} (p : x = y) (q : y = z) (r : z = t) :
+  p @ (q @ r) = (p @ q) @ r :=
+  match r with idpath =>
+    match q with idpath =>
+      match p with idpath => 1
+      end end end.
+Definition concat_pp_p {A : Type} {x y z t : A} (p : x = y) (q : y = z) (r : z = t) :
+  (p @ q) @ r = p @ (q @ r) :=
+  match r with idpath =>
+    match q with idpath =>
+      match p with idpath => 1
+      end end end.
+
+(**
+All of those should be understandable.  Some may have alternate
+proofs.  It is worth noting that many of these proofs are shorter than
+even the "second proofs" of the HoTT book.
+
+The names seem unusual at first, but they follow the naming scheme of
+the HoTT Coq library:
+- [1] means the identity path
+- [p] means 'the path'
+- [V] means 'the inverse path'
+- [A] means '[ap]'
+- [M] means the thing we are moving across equality
+- [x] means 'the point' which is not a path, e.g. in [transport p x]
+- [2] means relating to 2-dimensional paths
+- [3] means relating to 3-dimensional paths, and so on
+
+We'll see more functions named in this style as we proceed.
+*)
+
+(** ** Functions are functors *)
+(**
+Next, we define the function "transport" with its [Notation].
+*)
+
+Definition transport {A : Type} (P : A -> Type) {x y : A} (p : x = y) (u : P x) : P y :=
+  match p with idpath => u end.
+
+Notation "p # x" := (transport _ p x) (right associativity, at level 65, only parsing) : path_scope.
+
+(**
+Next comes the non-dependent and dependent versions of "ap".
+("application of a function to a path" or "action across paths").  The
+HoTT Coq library calls the dependent version "apD" rather than "apd".
+*)
+
+Definition ap {A B:Type} (f:A -> B) {x y:A} (p:x = y) : f x = f y
+  := match p with idpath => idpath end.
+
+Arguments ap {A B} f {x y} p : simpl nomatch.
+
+Definition apD {A:Type} {B:A->Type} (f:forall a:A, B a) {x y:A} (p:x=y):
+  p # (f x) = f y
+  :=
+  match p with idpath => idpath end.
+
+Arguments apD {A B} f {x y} p : simpl nomatch.
+
+(**
+In the HoTT book, the use of "ap" and "apd" is often implicit.  The
+reader can determine when "f(p)" means "ap(f,p)" because "p" is a path
+and "f" called on a path just doesn't "fit" in the proof.  In Coq, we
+have to be explicit about the use of "ap" and "apD".
+*)
+
+(** ** Homotopy *)
+(**
+So far, we've been covering types and functions in the same sequence
+as the HoTT book.  At this point in the book there is the definition
+of "homotopy".  But, if you've read further in the book, you know that
+homotopy and identity are equivalent.  Thus, the HoTT Coq library has
+no need to define "homotopy" and neither do we.
+
+We go straight to equivalences.  
+*)
+
+(** ** Equivalences *)
+(**
+For equivalences, we need a definition of a "section" or the one-sided
+inverse to a function.
+*)
+
+Definition Sect {A B : Type} (s : A -> B) (r : B -> A) :=
+  forall x : A, r (s x) = x.
+
+(**
+The actual definition of equivalence requires some new commands.
+*)
+
+Class IsEquiv {A B : Type} (f : A -> B) := BuildIsEquiv {
+  equiv_inv : B -> A ;
+  eisretr : Sect equiv_inv f;
+  eissect : Sect f equiv_inv;
+  eisadj : forall x : A, eisretr (f x) = ap f (eissect x)
+}.
+
+Arguments eisretr {A B} f {_} _.
+Arguments eissect {A B} f {_} _.
+Arguments eisadj {A B} f {_} _.
+
+Record Equiv A B := BuildEquiv {
+  equiv_fun :> A -> B ;
+  equiv_isequiv :> IsEquiv equiv_fun
+}.
+
+(** 
+I'm going to address these commands from easiest to hardest, not first
+to last.
+
+The easiest is the "Arguments" commands.  Ignore them.  They just
+define implicit arguments and we aren't covering the "Arguments"
+command in this tutorial.
+
+Next, the [Record] command creates an inductive type with a single
+constructor.  So, the type "Equiv" is very close to the dependent pair
+type "sigT".  The constructor for the new type is "BuildEquiv".  The
+[Record] command also creates projection functions for extracting the
+two elements stored in an "Equiv".  These are called "equiv_fun" and
+"equiv_isequiv" (and are very similar to "projT1" and "projT2").
+
+Lastly, we come to the [Class] command.  [Class] operates similar to a
+[Record], but it has special implicit argument rules.  Thus, when Coq
+searches for an argument of type "IsEquiv f", it will look at all
+elements of that type declared with the "Instance" command.  As a
+result, the second argument to "BuildEquiv" can often be left
+implicit.
+
+The HoTT Coq library declares one default [Instance], which is the
+second part of the "Equiv" record.  
+*)
+
+Existing Instance equiv_isequiv.
+
+(**
+And, of course, there is a [Notation] for equivalence.  There is also
+one for the inverse function inside it.
+*)
+
+Notation "A <~> B" := (Equiv A B) (at level 85) : equiv_scope.
+Notation "f ^-1" := (@equiv_inv _ _ f _) (at level 3) : equiv_scope.
+Local Open Scope equiv_scope.
+
+(**
+The definition used by "Equiv" is the "Half Adjoint Equivalence" of
+the HoTT book.  
+
+In the book, the parts of "ishae(f)" are (using Coq's notation):
+- f : A -> B
+- g : B -> A
+- #\eta#$\eta$ : f o g ~~ idmap A
+- #\epsilon#$\epsilon$ : g o f ~~ idmap B
+- #\tau#$\tau$ : forall x:A, f (eta x) = epsilon (f x)
+where "~~" represents homotopy, which is never defined in Coq.  (We
+used two tildes since the single tilde ("~") in Coq is the "not"
+operator.)
+
+In Coq, if we have a variable "e" of type "A <~> B", the parts are:
+- equiv_fun e : A -> B
+- equiv_inv (equiv_isequiv e) : B -> A
+  - Also written: (equiv_fun e) ^-1 : B -> A
+- eisretr (equiv_isequiv e): Sect equiv_inv f
+- eissect (equiv_isequiv e): Sect f equiv_inv
+- eisadj (equiv_isequiv e): forall x : A, eisretr (f x) = ap f (eissect x)
+
+Notice that the final expression contains a call to "ap" that is
+implicit in the HoTT book's notation.
+
+Now that we have a definition for equivalence, let's try to prove that
+it is an equivalence relation.
+*)
+
+
+(** *** Properties of Equivalences *)
+
+(**
+Our first example is proving reflexivity: that for all types "A",
+"ismap A" creates an equivalence between "A" and itself. Creating an
+equivalence usually takes three parts:
+-  creating an element of type Class "IsEquiv", 
+-  registering it as an Instance (for implicit arguments), and 
+-  creating the Record "Equiv".
+
+The following command does the first two parts for reflexivity.
+"@BuildIsEquiv" creates the element of "IsEquiv" and the "Instance"
+command registers the element.
+*)
+
+Instance isequiv_idmap (A : Type) : IsEquiv (idmap A) :=
+  @BuildIsEquiv A A (idmap A) (idmap A) (fun _ => 1) (fun _ => 1) (fun _ => 1).
+
+(**
+This next command creates the element of "Equiv" (written "A <~> A")
+by calling the constructor "BuildEquiv".  As you can see, the final
+argument is inferred using the Instance registered by the previous
+command.
+*)
+
+Definition equiv_idmap (A : Type) : A <~> A := @BuildEquiv A A (idmap A) _.
+
+(**
+This looks like a lot of work to prove something that is obvious.  And
+it is.  However, the library is designed for proving more complex
+instances of equivalence.  One aspect of that is once an "Instance" of
+"IsEquiv" is registered, it can be used as an inferred argument in
+many places.  That won't happen for "isequiv_idmap", which is only use
+in a few places, but does happen.
+
+
+After proving that equivalences are reflexive, we should prove that
+every equivalence has an inverse.  However, that proof is rather long
+and complicated.  (That has to do with the choice of half-adjoint
+equivalences; the proof for bi-invertible maps is just 8 lines.)
+Since this document is about reading what has been proven, and not the
+proofs themselves, we will cheat.  We'll skip the proof and use the
+"admit" command so that you can read what has been proven.
+*)
+
+Definition equiv_inverse : forall {A B : Type} (e : A <~> B), (B <~> A).
+Admitted.
+
+(**
+And here is what transitivity ("composition") looks like.
+*)
+
+Definition equiv_compose' : forall {A B C : Type} (g : B <~> C) (f : A <~> B)
+                            , A <~> C.
+Admitted.
+(**
+It is called "equiv_compose"-prime, because there is a second function
+that instead takes functions from "A" to "B" and from "B" to "C" and
+uses the implicit arguments provided by [Instance] to build the
+equivalence.
+*)
+(** ** Univalence *)
+(**
+
+Since we've decided to cheat and add theorems without proof, it seems
+like the opportune time to add an axiom.  Homotopy type theory's
+univalence axiom states that there exists an equivalence between two
+types being equivalent and those same two types being equal.
+
+*)
+
+Definition equiv_path (A B : Type) (p : A = B) :  A <~> B :=
+  match p with
+    | idpath => equiv_idmap A
+  end.
+(*??? Why is my version of this so short compared to the library's?! *)
+
+Class Univalence := {
+  isequiv_equiv_path :> forall (A B : Type), IsEquiv (equiv_path A B)
+}.
+
+Instance univalence_axiom : Univalence.
+Admitted.
+
+(**
+The function "equiv_path" says that for every equality between types,
+there is an equivalence between them.  
+
+The [Class] "Univalence" says that for any two types, "equiv_path"
+determines an equivalence between the types.  So, not only you can get
+a function that maps an equivalence to an equality, you know that that
+function is the inverse (with some qualifications) of "equiv_path".
+*)
+(* ??? How is "Class" functioning in this usage?  It's not the usual one.*)
+(** *** Univalence Example *)
+(**
+To end this document, we'll do a small proof.  We'll declare a type
+that is the duplicate of "nat", prove they're equivalent, and then use
+the Univalence Axiom to conclude that they are equal.
+
+First, we define our new type of [nat]s.
+*)
+
+Inductive nat2 : Set :=
+  | O2 : nat2
+  | S2 : nat2 -> nat2.
+
+(**
+Next, we define invertible maps between them.  This is easy: we match
+zero to zero and successor to successor.
+*)
+
+Fixpoint nat_to_nat2 (n : nat) : nat2 :=
+  match n with
+      | O => O2
+      | S n' => S2 (nat_to_nat2 n')
+  end.
+
+Fixpoint nat2_to_nat (n2 : nat2) : nat :=
+  match n2 with
+      | O2 => O
+      | S2 n2' => S (nat2_to_nat n2')
+  end.
+
+(**
+Next, we must prove that are maps are left- and right- inverses of
+each other.  We could have done each in a single function, if we used
+"nat_rect" and "nat2_rect", but it is easier to read with the [match]
+expression.
+*)
+
+Fixpoint sect_nat2_helper (x : nat2) : (nat_to_nat2 (nat2_to_nat x)) = x :=
+  match x return (nat_to_nat2 (nat2_to_nat x)) = x with 
+    | O2 => idpath O2
+    | S2 x' => ap S2 (sect_nat2_helper x')
+  end.
+Definition sect_nat2 : Sect nat2_to_nat nat_to_nat2 := sect_nat2_helper.
+
+Fixpoint retr_nat2_helper (x : nat) : (nat2_to_nat (nat_to_nat2 x)) = x :=
+  match x return (nat2_to_nat (nat_to_nat2 x)) = x with 
+    | O => idpath O
+    | S x' => ap S (retr_nat2_helper x')
+  end.
+Definition retr_nat2 : Sect nat_to_nat2 nat2_to_nat := retr_nat2_helper.
+
+(**
+Then, since we're using the half-adjoint equivalence, we need one of
+the coherences.
+
+Although this document is not trying to teach you how to prove, it is
+worth pointing out that the following theorem is proved differently
+than the other ones.  It uses Coq's "tactic language".  The tactic
+language a large vocabulary of commands and multiple forms of
+automation to help prove theorems.
+*)
+
+Theorem adj_nat2 (x : nat) :  sect_nat2 (nat_to_nat2 x) = ap nat_to_nat2 (retr_nat2 x).
+Proof.
+  elim x.
+    exact idpath.
+    
+    intros x' inductive_hyp.
+    simpl.
+    rewrite inductive_hyp.
+    case (retr_nat2 x').
+    exact idpath.
+Qed.
+
+(**
+Now that we have all 5 pieces needed for the equivalence, we make the
+"IsEquiv" element, register it as an [Instance], and then make the
+"Equiv" element that witness that "nat" and "nat2" are equivalent.
+*)
+
+Instance isequiv_nat_nat2 : IsEquiv nat_to_nat2 :=
+  BuildIsEquiv nat nat2 nat_to_nat2 nat2_to_nat sect_nat2 retr_nat2 adj_nat2.
+
+Definition equiv_nat_nat2 : nat <~> nat2 := BuildEquiv nat nat2 nat_to_nat2 _.
+
+(**
+Next, we use the univalence axiom to build an equivalence between the
+equality of [nat] and [nat2] and the equivalence of [nat] and [nat2].
+*)
+
+Definition big_equiv : (nat = nat2 :> Type) <~> (nat <~> nat2) :=
+  BuildEquiv (nat = nat2 :> Type) (nat <~> nat2) (equiv_path nat nat2) _.
+
+(**
+With that equivalence, we can extract the inverse map, which takes the
+equivalence to the equality.  Applying that function to the
+equivalence, gives us the equality.  Thus, [nat] is equal to [nat2]!
+*)
+
+Definition nat2_is_nat : (nat = nat2 :> Type) := 
+  (big_equiv ^-1) equiv_nat_nat2.
+
+(**
+With that type equality, we can take any theorem we've proved on [nat]
+and convert it into a theorem on [nat2].  In our final example, we'll
+convert the identity function on [nat]s into one on [nat2].
+*)
+
+Definition idmap_nat2 : nat2 -> nat2 :=
+  match nat2_is_nat in (_ = y) return (y -> y) with
+    | 1 => idmap_nat
+  end.
+
+(** * Going Further *)
+(** ** Homotopy Type Theory in Coq *)
+(**
+The reference for HoTT in Coq is:
+-   http://homotopytypetheory.org/coq/
+
+It contains links to the HoTT Coq library and proofs that use it.
+Thanks to this document, you should now be able to read what has been
+proven.
+
+Also, the site contains links to the version of Coq that supports
+higher inductive types and is necessary to use the HoTT Coq library
+and to write new proofs using it.
+*)
+(** ** General Coq references *)
+(**
+The website for Coq is:
+-   http://coq.inria.fr/
+*)
+(** *** Installation *)
+(**
+The Coq website has links to compiled versions of standard Coq for
+Windows and OSX.  If you're running Linux, many distributions have Coq
+available.  Under Ubuntu and Debian, the command to install Coq and
+CoqIDE is "sudo apt-get install coq coqide".
+
+CoqIDE is a graphical user interface for Coq.  We strongly recommend
+using either CoqIDE or "Proof General", which lets you use Coq inside
+of the Emacs editor.  (Available at http://proofgeneral.inf.ed.ac.uk/)
+
+"ProofWeb" is a website that lets you interface to Coq by using a web
+browser.  You will not need to install anything.  It is available at
+http://prover.cs.ru.nl/
+n*)
+(** *** Documentation *)
+(**
+A good introduction to Coq is "Software Foundations".  It is, however,
+aimed at students studying programming languages.  It does not get
+quickly to "how to prove".
+
+-   http://www.cis.upenn.edu/~bcpierce/sf/
+
+The following is a good cheatsheet.  Most importantly, it has a list
+of "Basic Tactics" that guides new users on what command to use when
+working with the powerful tactics language.  Additionally, it has many
+of the book-to-Coq translations that are in this document.
+
+-   http://andrej.com/coq/cheatsheet.pdf
+
+The Coq Reference Manual, with its explanations of every feature in
+standard Coq, is available at:
+
+-   http://coq.inria.fr/documentation
+*)
+
+
+(* TODO:
+- "Require Import/Export"
+- "Contractibility"
+-  Martin-Lof Rule vs. Paulin-Mohring Rule
+*)
+
+
+
+

cover-a4.tex

@@ -0,0 +1,61 @@
+% Cover for home-made copies. Print this with a color printer.
+\input{opt-a4}
+\input{opt-color}
+
+\documentclass[\OPTfontsize]{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[dvips]{xcolor}
+\usepackage{wallpaper}
+
+\definecolor{covercolor}{cmyk}{\OPTcovercolor}
+\definecolor{covertext}{cmyk}{\OPTcovertextcolor}
+\pagecolor{covercolor}
+
+%%% Set the fonts
+\usepackage{mathpazo}
+\usepackage[scaled=0.95]{helvet}
+\usepackage{courier}
+\linespread{1.05} % Palatino looks better with this
+
+\usepackage{graphicx}
+\DeclareGraphicsExtensions{.png}
+\input{bmpsize-hack} % for bounding boxes in dvi mode
+
+\newlength{\coverheight}
+\setlength{\coverheight}{297mm} % Reported as total cover height
+
+\newlength{\coverwidth}
+\setlength{\coverwidth}{210mm} % Reported as "spine begins at"
+
+\usepackage[margin=0pt,
+            papersize={\OPTpagesize},
+            noheadfoot]{geometry}
+%\usepackage{layout}
+\newcommand{\coverpage}[1]{\vbox to \coverheight{\hbox to \coverwidth{#1}}}
+
+\parindent=0pt
+\parskip=0pt
+
+\input{frontpage}
+
+\newcommand{\backpage}{
+\begin{minipage}[b][\coverheight][t]{\coverwidth}
+\begin{center}
+\begin{minipage}[t]{0.80\coverwidth}
+  \color{covertext}
+  \vspace{\OPTtopskip}
+  \input{blurb.tex}
+\end{minipage}
+\end{center}
+\end{minipage}
+}
+
+\begin{document}
+%\layout
+\ThisLRCornerWallPaper{1.1}{\OPThifrontimage}
+\coverpage{\frontpage}
+\newpage
+\ThisLRCornerWallPaper{0.7}{\OPThibackimage}
+\coverpage{\backpage}
+\end{document}

cover-letter.tex

@@ -0,0 +1,61 @@
+% Cover for home-made copies. Print this with a color printer.
+\input{opt-letter}
+\input{opt-color}
+
+\documentclass[\OPTfontsize]{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[dvips]{xcolor}
+\usepackage{wallpaper}
+
+\definecolor{covercolor}{cmyk}{\OPTcovercolor}
+\definecolor{covertext}{cmyk}{\OPTcovertextcolor}
+\pagecolor{covercolor}
+
+%%% Set the fonts
+\usepackage{mathpazo}
+\usepackage[scaled=0.95]{helvet}
+\usepackage{courier}
+\linespread{1.05} % Palatino looks better with this
+
+\usepackage{graphicx}
+\DeclareGraphicsExtensions{.png}
+\input{bmpsize-hack} % for bounding boxes in dvi mode
+
+\newlength{\coverheight}
+\setlength{\coverheight}{11in} % Reported as total cover height
+
+\newlength{\coverwidth}
+\setlength{\coverwidth}{8.5in} % Reported as "spine begins at"
+
+\usepackage[margin=0pt,
+            papersize={\OPTpagesize},
+            noheadfoot]{geometry}
+%\usepackage{layout}
+\newcommand{\coverpage}[1]{\vbox to \coverheight{\hbox to \coverwidth{#1}}}
+
+\parindent=0pt
+\parskip=0pt
+
+\input{frontpage}
+
+\newcommand{\backpage}{
+\begin{minipage}[b][\coverheight][t]{\coverwidth}
+\begin{center}
+\begin{minipage}[t]{0.80\coverwidth}
+  \color{covertext}
+  \vspace{\OPTtopskip}
+  \input{blurb.tex}
+\end{minipage}
+\end{center}
+\end{minipage}
+}
+
+\begin{document}
+%\layout
+\ThisLRCornerWallPaper{1.1}{\OPThifrontimage}
+\coverpage{\frontpage}
+\newpage
+\ThisLRCornerWallPaper{0.7}{\OPThibackimage}
+\coverpage{\backpage}
+\end{document}

cover-lulu-hardcover.tex

@@ -0,0 +1,101 @@
+% Cover for Lulu.com
+\input{opt-ustrade}
+
+\documentclass[\OPTfontsize]{article}
+\input{opt-color}
+
+\usepackage[utf8]{inputenc}
+\usepackage{rotating}
+\usepackage{xcolor}
+\usepackage{wallpaper}
+
+\definecolor{covercolor}{cmyk}{\OPTcovercolor}
+\definecolor{covertext}{cmyk}{\OPTcovertextcolor}
+\pagecolor{covercolor}
+
+\usepackage{soul} % Inter-letter spacing
+\sodef\ugg{}{0pt plus 1fill}{1em plus 1fill}{0pt}
+
+%%% Set the fonts
+\usepackage{mathpazo}
+\usepackage[scaled=0.95]{helvet}
+\usepackage{courier}
+\linespread{1.05} % Palatino looks better with this
+
+\usepackage{graphicx}
+\DeclareGraphicsExtensions{.png}
+\input{bmpsize-hack} % for bounding boxes in dvi mode
+
+% Some of these dimensions are reported by Lulu.com *after* you
+% upload the inner PDF file.
+% For casewrap hardcover see http://static.lulu.com/static/images/help_casewrap_6x9.gif
+
+% Dimensions as reported by Lulu.com (download cover template to see)
+
+% Total document size
+\newlength{\totalwidth}
+\setlength{\totalwidth}{392.112mm} % width
+
+\newlength{\totalheight}
+\setlength{\totalheight}{273.05mm} % height
+
+% Spine width
+\newlength{\spinewidth}
+\setlength{\spinewidth}{42.862mm}
+
+% Book trim size (trade)
+\newlength{\coverwidth}
+\setlength{\coverwidth}{155.575mm} % width
+
+\newlength{\coverheight}
+\setlength{\coverheight}{234.95mm} % height
+
+\usepackage[margin=0pt,
+            papersize={\totalwidth,\totalheight},
+            noheadfoot]{geometry}
+%\usepackage{layout}
+\newcommand{\coverpage}[1]{\vbox to \coverheight{\hbox to \coverwidth{#1}}}
+\newcommand{\spine}[1]{\vbox to \coverheight{\hbox to \spinewidth{#1}}}
+
+\parindent=0pt
+\parskip=0pt
+
+\input{frontpage}
+
+\newcommand{\spinetext}{
+\begin{minipage}[b][\coverheight][t]{\spinewidth}
+\begin{center}
+  \begin{rotate}{270}
+    \color{covertext}
+    \hspace{\OPTtopskip}
+    \begin{minipage}{\coverheight}
+      {\fontsize{\OPTcoverspinefont}{\OPTcoverspinefont}\fontseries{b}\selectfont%
+        Homotopy Type Theory}
+    \end{minipage}
+  \end{rotate}
+\end{center}
+\end{minipage}
+}
+
+\newcommand{\backpage}{
+\begin{minipage}[b][\coverheight][t]{\coverwidth}
+\begin{center}
+\begin{minipage}[t]{0.80\coverwidth}
+  \color{covertext}
+  \vspace{\OPTtopskip}
+  \input{blurb.tex}
+\end{minipage}
+\end{center}
+\end{minipage}
+}
+
+\begin{document}
+%\layout
+\LRCornerWallPaper{1.0}{cover-lulu-hardcover}
+\begin{center}
+  \vbox{}
+  \vfill
+  \mbox{\coverpage{\backpage}\spine{\spinetext}\coverpage{\frontpage}}
+  \vfill
+\end{center}
+\end{document}

cover-lulu-paperback.tex

@@ -0,0 +1,97 @@
+% Cover for Lulu.com
+\input{opt-ustrade}
+
+\documentclass[\OPTfontsize]{article}
+\input{opt-color}
+
+\usepackage[utf8]{inputenc}
+\usepackage{rotating}
+\usepackage{xcolor}
+\usepackage{wallpaper}
+
+\definecolor{covercolor}{cmyk}{\OPTcovercolor}
+\definecolor{covertext}{cmyk}{\OPTcovertextcolor}
+\pagecolor{covercolor}
+
+\usepackage{soul} % Inter-letter spacing
+\sodef\ugg{}{0pt plus 1fill}{1em plus 1fill}{0pt}
+
+%%% Set the fonts
+\usepackage{mathpazo}
+\usepackage[scaled=0.95]{helvet}
+\usepackage{courier}
+\linespread{1.05} % Palatino looks better with this
+
+\usepackage{graphicx}
+\DeclareGraphicsExtensions{.png}
+\input{bmpsize-hack} % for bounding boxes in dvi mode
+
+% Some of these dimensions are reported by Lulu.com *after* you
+% upload the inner PDF file.
+% For casewrap hardcover see http://static.lulu.com/static/images/help_casewrap_6x9.gif
+
+% Dimensions as reported by Lulu.com (download cover template to see)
+
+% Total document size
+\newlength{\totalwidth}
+\setlength{\totalwidth}{348.085mm} % width
+
+\newlength{\totalheight}
+\setlength{\totalheight}{234.95mm} % height
+
+% Spine width
+\newlength{\spinewidth}
+\setlength{\spinewidth}{36.935mm}
+
+% Book trim size (trade)
+\newlength{\coverwidth}
+\setlength{\coverwidth}{152.4mm} % width
+
+\newlength{\coverheight}
+\setlength{\coverheight}{228.6mm} % height
+
+
+\usepackage[margin=0pt,
+            papersize={\totalwidth,\totalheight},
+            noheadfoot]{geometry}
+%\usepackage{layout}
+\newcommand{\coverpage}[1]{\vbox to \coverheight{\hbox to \coverwidth{#1}}}
+\newcommand{\spine}[1]{\vbox to \coverheight{\hbox to \spinewidth{#1}}}
+
+\parindent=0pt
+\parskip=0pt
+
+\input{frontpage}
+
+\newcommand{\spinetext}{
+\begin{minipage}[b][\coverheight][t]{\spinewidth}
+\begin{center}
+  \begin{rotate}{270}
+    \color{covertext}
+    \hspace{\OPTtopskip}
+    \begin{minipage}{\coverheight}
+      {\fontsize{\OPTcoverspinefont}{\OPTcoverspinefont}\fontseries{b}\selectfont%
+        Homotopy Type Theory}
+    \end{minipage}
+  \end{rotate}
+\end{center}
+\end{minipage}
+}
+
+\newcommand{\backpage}{
+\begin{minipage}[b][\coverheight][t]{\coverwidth}
+\begin{center}
+\begin{minipage}[t]{0.80\coverwidth}
+  \color{covertext}
+  \vspace{\OPTtopskip}
+  \input{blurb.tex}
+\end{minipage}
+\end{center}
+\end{minipage}
+}
+
+\begin{document}
+%\layout
+\LRCornerWallPaper{1.0}{cover-lulu-paperback}%
+\mbox{\coverpage{\backpage}\spine{\spinetext}\coverpage{\frontpage}}%
+\end{document}

cover/torus/README.md

@@ -0,0 +1,11 @@
+The torus image on the front cover was generated with
+scripts from this directory. Here is how:
+
+1. An image `torus.jpg` of torus is generated with Mathematica, see `Torus.nb`.
+2. Images of symbols are generated with `symbols.py`.
+3. Metapixel is used to create the torus image, maybe like this:
+
+       rm -rf srcimg/* dstimg/* && metapixel-prepare srcimg dstimg
+       metapixel -d 1 -s 3 -w 128 -h 128 -l dstimg --metapixel torus.jpg mosaic-torus.png
+
+4. The resulting mosaic-torus.png is then cropped and given color with Gimp.

cover/torus/Torus.nb

@@ -0,0 +1,354 @@
+(*CacheID: 234*)
+(* Internal cache information:
+NotebookFileLineBreakTest
+NotebookFileLineBreakTest
+NotebookDataPosition[         0,          0]
+NotebookDataLength[     13170,        353]
+NotebookOptionsPosition[     12041,        310]
+NotebookOutlinePosition[     12475,        327]
+CellTagsIndexPosition[     12432,        324]
+WindowFrame->Normal*)
+
+(* Beginning of Notebook Content *)
+Notebook[{
+Cell[BoxData[{
+ RowBox[{"ClearAll", "[", "torus", "]"}], "\[IndentingNewLine]", 
+ RowBox[{
+  RowBox[{"torus", "[", 
+   RowBox[{"m_", ",", "t_", ",", "r_", ",", "q_"}], "]"}], ":=", 
+  "\[IndentingNewLine]", 
+  RowBox[{"Function", "[", 
+   RowBox[{
+    RowBox[{"{", 
+     RowBox[{"u", ",", "v"}], "}"}], ",", 
+    RowBox[{"t", "+", 
+     RowBox[{"m", ".", 
+      RowBox[{"{", 
+       RowBox[{
+        RowBox[{
+         RowBox[{"Cos", "[", "u", "]"}], 
+         RowBox[{"(", 
+          RowBox[{"r", "+", 
+           RowBox[{"q", "*", 
+            RowBox[{"Cos", "[", "v", "]"}]}]}], ")"}]}], ",", 
+        RowBox[{
+         RowBox[{"Sin", "[", "u", "]"}], "*", 
+         RowBox[{"(", 
+          RowBox[{"r", "+", 
+           RowBox[{"q", "*", 
+            RowBox[{"Cos", "[", "v", "]"}]}]}], ")"}]}], ",", 
+        RowBox[{"q", "*", 
+         RowBox[{"Sin", "[", "v", "]"}]}]}], "}"}]}]}]}], "]"}]}]}], "Input",
+ CellChangeTimes->{{3.575007497914714*^9, 3.575007513979257*^9}, {
+  3.5750075520216627`*^9, 3.575007597035688*^9}, {3.575007629355833*^9, 
+  3.575007658325391*^9}, {3.5750077008755217`*^9, 3.575007731479414*^9}, {
+  3.5750077855906487`*^9, 3.5750077861611347`*^9}, {3.575007994438464*^9, 
+  3.575007998817588*^9}, {3.5750080778742123`*^9, 3.575008103454809*^9}, {
+  3.575008174228361*^9, 3.5750081851282454`*^9}}],
+
+Cell[BoxData[
+ RowBox[{"pic", "=", 
+  RowBox[{"ParametricPlot3D", "[", "\[IndentingNewLine]", 
+   RowBox[{
+    RowBox[{"{", "\[IndentingNewLine]", 
+     RowBox[{
+      RowBox[{
+       RowBox[{"torus", "[", 
+        RowBox[{
+         RowBox[{"RotationMatrix", "[", 
+          RowBox[{"0", ",", 
+           RowBox[{"{", 
+            RowBox[{"0", ",", "0", ",", "1"}], "}"}]}], "]"}], ",", 
+         RowBox[{"{", 
+          RowBox[{"0", ",", "0", ",", "0"}], "}"}], ",", "3", ",", "1"}], 
+        "]"}], "[", 
+       RowBox[{"u", ",", "v"}], "]"}], ",", "\[IndentingNewLine]", 
+      RowBox[{
+       RowBox[{"torus", "[", 
+        RowBox[{
+         RowBox[{"RotationMatrix", "[", 
+          RowBox[{
+           RowBox[{"Pi", "/", "2"}], ",", 
+           RowBox[{"{", 
+            RowBox[{"1", ",", "1", ",", "0"}], "}"}]}], "]"}], ",", 
+         RowBox[{"{", 
+          RowBox[{
+           RowBox[{"Sqrt", "[", "3", "]"}], ",", 
+           RowBox[{"Sqrt", "[", "3", "]"}], ",", "0"}], "}"}], ",", "3", ",", 
+         "1"}], "]"}], "[", 
+       RowBox[{"u", ",", "v"}], "]"}]}], "\[IndentingNewLine]", "}"}], ",", 
+    "\[IndentingNewLine]", 
+    RowBox[{"{", 
+     RowBox[{"u", ",", "0", ",", 
+      RowBox[{"2", "Pi"}]}], "}"}], ",", 
+    RowBox[{"{", 
+     RowBox[{"v", ",", "0", ",", 
+      RowBox[{"2", "Pi"}]}], "}"}], ",", "\[IndentingNewLine]", 
+    RowBox[{"Boxed", "\[Rule]", "False"}], ",", 
+    RowBox[{"Axes", "\[Rule]", "False"}], ",", 
+    RowBox[{"Mesh", "\[Rule]", "False"}], ",", 
+    RowBox[{"Lighting", "\[Rule]", 
+     RowBox[{"{", 
+      RowBox[{
+       RowBox[{"{", 
+        RowBox[{"\"\<Point\>\"", ",", 
+         RowBox[{"GrayLevel", "[", "0.8", "]"}], ",", 
+         RowBox[{"{", 
+          RowBox[{"5", ",", "5", ",", "5"}], "}"}]}], "}"}], ",", 
+       "\[IndentingNewLine]", 
+       RowBox[{"{", 
+        RowBox[{"\"\<Point\>\"", ",", 
+         RowBox[{"GrayLevel", "[", "0.5", "]"}], ",", 
+         RowBox[{"{", 
+          RowBox[{"5", ",", 
+           RowBox[{"-", "5"}], ",", "5"}], "}"}]}], "}"}]}], "}"}]}]}], 
+   "]"}]}]], "Input",
+ CellChangeTimes->{{3.5750074603736773`*^9, 3.5750074766898947`*^9}, {
+  3.575007734777616*^9, 3.575007759592752*^9}, {3.57500779709807*^9, 
+  3.57500784079035*^9}, {3.575007876454563*^9, 3.575008048438395*^9}, {
+  3.5750081293708982`*^9, 3.5750081588892612`*^9}, {3.57500821320293*^9, 
+  3.575008270497423*^9}, {3.575008301621005*^9, 3.575008408265143*^9}, {
+  3.5750084601523647`*^9, 3.575008463607183*^9}, {3.575008525986937*^9, 
+  3.575008733406006*^9}, {3.575008774951048*^9, 3.575008777059445*^9}, {
+  3.575008828312248*^9, 3.575008828654634*^9}}],
+
+Cell[CellGroupData[{
+
+Cell[BoxData[
+ RowBox[{"Export", "[", 
+  RowBox[{"\"\<tori.jpg\>\"", ",", "pic", ",", 
+   RowBox[{"ImageResolution", "\[Rule]", "300"}]}], "]"}]], "Input",
+ CellChangeTimes->{{3.5750088552959757`*^9, 3.575008856332591*^9}, {
+  3.5750101012422523`*^9, 3.575010109343607*^9}, {3.575010142918709*^9, 
+  3.575010144023197*^9}, {3.575024999760702*^9, 3.575025006137784*^9}}],
+
+Cell[BoxData["\<\"tori.jpg\"\>"], "Output",
+ CellChangeTimes->{{3.575010110907318*^9, 3.57501014569147*^9}, 
+   3.575024904160636*^9, 3.575049070535226*^9}]
+}, Open  ]],
+
+Cell[BoxData[
+ RowBox[{"pic", "=", 
+  RowBox[{"ParametricPlot3D", "[", "\[IndentingNewLine]", 
+   RowBox[{
+    RowBox[{"{", "\[IndentingNewLine]", 
+     RowBox[{
+      RowBox[{"torus", "[", 
+       RowBox[{
+        RowBox[{"RotationMatrix", "[", 
+         RowBox[{"0", ",", 
+          RowBox[{"{", 
+           RowBox[{"0", ",", "0", ",", "1"}], "}"}]}], "]"}], ",", 
+        RowBox[{"{", 
+         RowBox[{"0", ",", "0", ",", "0"}], "}"}], ",", "3", ",", "1"}], 
+       "]"}], "[", 
+      RowBox[{"u", ",", "v"}], "]"}], "\[IndentingNewLine]", "}"}], ",", 
+    "\[IndentingNewLine]", 
+    RowBox[{"{", 
+     RowBox[{"u", ",", "0", ",", 
+      RowBox[{"2", "Pi"}]}], "}"}], ",", 
+    RowBox[{"{", 
+     RowBox[{"v", ",", "0", ",", 
+      RowBox[{"2", "Pi"}]}], "}"}], ",", "\[IndentingNewLine]", 
+    RowBox[{"Boxed", "\[Rule]", "False"}], ",", 
+    RowBox[{"Axes", "\[Rule]", "False"}], ",", 
+    RowBox[{"Mesh", "\[Rule]", "False"}], ",", 
+    RowBox[{"Background", "\[Rule]", 
+     RowBox[{"GrayLevel", "[", "0.98", "]"}]}], ",", 
+    RowBox[{"Lighting", "\[Rule]", "\[IndentingNewLine]", 
+     RowBox[{"{", 
+      RowBox[{
+       RowBox[{"{", 
+        RowBox[{"\"\<Point\>\"", ",", 
+         RowBox[{"GrayLevel", "[", "0.6", "]"}], ",", 
+         RowBox[{"{", 
+          RowBox[{"5", ",", "5", ",", "5"}], "}"}]}], "}"}], ",", 
+       "\[IndentingNewLine]", 
+       RowBox[{"{", 
+        RowBox[{"\"\<Ambient\>\"", ",", 
+         RowBox[{"GrayLevel", "[", "0.3", "]"}]}], "}"}]}], "}"}]}]}], 
+   "]"}]}]], "Input",
+ CellChangeTimes->{{3.575025285038136*^9, 3.5750252861185703`*^9}, {
+  3.5750253543096848`*^9, 3.575025490287694*^9}, {3.575025559882556*^9, 
+  3.5750256024958982`*^9}, {3.575025649196397*^9, 3.575025684027916*^9}, {
+  3.575025832499338*^9, 3.575025864236339*^9}, {3.5750266396533318`*^9, 
+  3.575026642525339*^9}, {3.5750267210806217`*^9, 3.575026751234239*^9}, {
+  3.575026926171913*^9, 3.575026941428458*^9}, {3.575026979154292*^9, 
+  3.575027011530059*^9}, {3.575027069164358*^9, 3.575027070858553*^9}, {
+  3.575027108620347*^9, 3.575027109296626*^9}, {3.575027948340992*^9, 
+  3.5750279702321167`*^9}}],
+
+Cell[BoxData[""], "Input",
+ CellChangeTimes->{{3.575025437034926*^9, 3.575025438002881*^9}}],
+
+Cell[CellGroupData[{
+
+Cell[BoxData[
+ RowBox[{"Export", "[", 
+  RowBox[{"\"\<torus.jpg\>\"", ",", " ", "pic", ",", " ", 
+   RowBox[{"ImageResolution", "\[Rule]", "300"}]}], "]"}]], "Input",
+ CellChangeTimes->{{3.575025296296578*^9, 3.575025305455855*^9}, {
+  3.575027986751356*^9, 3.5750279880097303`*^9}}],
+
+Cell[BoxData["\<\"torus.jpg\"\>"], "Output",
+ CellChangeTimes->{
+  3.5750253064427834`*^9, 3.5750255010662518`*^9, 3.57502560902934*^9, 
+   3.5750256926724033`*^9, 3.575025871884837*^9, 3.575026756781699*^9, 
+   3.575026947337076*^9, {3.5750270475830803`*^9, 3.5750270762412357`*^9}, 
+   3.5750271178765087`*^9, 3.575027989420265*^9, 3.575049073357514*^9}]
+}, Open  ]],
+
+Cell[BoxData[
+ RowBox[{"pic", "=", 
+  RowBox[{"Graphics3D", "[", 
+   RowBox[{
+    RowBox[{"Sphere", "[", "]"}], ",", "\[IndentingNewLine]", 
+    RowBox[{"Boxed", "\[Rule]", "False"}], ",", 
+    RowBox[{"Background", "\[Rule]", 
+     RowBox[{"GrayLevel", "[", "0.98", "]"}]}], ",", 
+    RowBox[{"Lighting", "\[Rule]", "\[IndentingNewLine]", 
+     RowBox[{"{", 
+      RowBox[{
+       RowBox[{"{", 
+        RowBox[{"\"\<Point\>\"", ",", 
+         RowBox[{"GrayLevel", "[", "0.6", "]"}], ",", 
+         RowBox[{"{", 
+          RowBox[{"0", ",", 
+           RowBox[{"-", "2"}], ",", "2"}], "}"}]}], "}"}], ",", 
+       "\[IndentingNewLine]", "\[IndentingNewLine]", 
+       RowBox[{"{", 
+        RowBox[{"\"\<Ambient\>\"", ",", 
+         RowBox[{"GrayLevel", "[", "0.3", "]"}]}], "}"}]}], "}"}]}]}], 
+   "]"}]}]], "Input",
+ CellChangeTimes->{{3.5750273586505203`*^9, 3.575027553672594*^9}, {
+  3.575027601822229*^9, 3.575027617537323*^9}, {3.575027695761964*^9, 
+  3.575027695945859*^9}}],
+
+Cell[CellGroupData[{
+
+Cell[BoxData[
+ RowBox[{"Export", "[", 
+  RowBox[{"\"\<sphere.jpg\>\"", ",", " ", "pic", ",", 
+   RowBox[{"ImageResolution", "\[Rule]", "300"}]}], "]"}]], "Input",
+ CellChangeTimes->{{3.5750275448969307`*^9, 3.5750275604751*^9}}],
+
+Cell[BoxData["\<\"sphere.jpg\"\>"], "Output",
+ CellChangeTimes->{3.57502756152036*^9, 3.5750276239271603`*^9, 
+  3.575027700190448*^9, 3.575049074683049*^9}]
+}, Open  ]],
+
+Cell[BoxData[
+ RowBox[{"pic", "=", 
+  RowBox[{"ParametricPlot3D", "[", "\[IndentingNewLine]", 
+   RowBox[{
+    RowBox[{"{", 
+     RowBox[{
+      RowBox[{"torus", "[", 
+       RowBox[{
+        RowBox[{"RotationMatrix", "[", 
+         RowBox[{"0", ",", 
+          RowBox[{"{", 
+           RowBox[{"0", ",", "0", ",", "1"}], "}"}]}], "]"}], ",", 
+        RowBox[{"{", 
+         RowBox[{"0", ",", "0", ",", "0"}], "}"}], ",", "9", ",", "4"}], 
+       "]"}], "[", 
+      RowBox[{"u", ",", "v"}], "]"}], "\[IndentingNewLine]", "}"}], ",", 
+    "\[IndentingNewLine]", 
+    RowBox[{"{", 
+     RowBox[{"u", ",", "0", ",", 
+      RowBox[{"2", "Pi"}]}], "}"}], ",", 
+    RowBox[{"{", 
+     RowBox[{"v", ",", "0", ",", 
+      RowBox[{"2", "Pi"}]}], "}"}], ",", "\[IndentingNewLine]", 
+    RowBox[{"Boxed", "\[Rule]", "False"}], ",", 
+    RowBox[{"Axes", "\[Rule]", "False"}], ",", 
+    RowBox[{"Mesh", "\[Rule]", 
+     RowBox[{"{", 
+      RowBox[{"20", ",", "20"}], "}"}]}], ",", 
+    RowBox[{"MeshStyle", "\[Rule]", 
+     RowBox[{"Thickness", "[", "0.006", "]"}]}], ",", 
+    RowBox[{"Lighting", "\[Rule]", "\[IndentingNewLine]", 
+     RowBox[{"{", 
+      RowBox[{
+       RowBox[{"{", 
+        RowBox[{"\"\<Point\>\"", ",", 
+         RowBox[{"GrayLevel", "[", "0.6", "]"}], ",", 
+         RowBox[{"{", 
+          RowBox[{"5", ",", "5", ",", "5"}], "}"}]}], "}"}], ",", 
+       "\[IndentingNewLine]", 
+       RowBox[{"{", 
+        RowBox[{"\"\<Ambient\>\"", ",", 
+         RowBox[{"GrayLevel", "[", "1.0", "]"}]}], "}"}]}], "}"}]}]}], 
+   "]"}]}]], "Input",
+ CellChangeTimes->{{3.5750280287621403`*^9, 3.5750280399278927`*^9}, {
+  3.5750281206545887`*^9, 3.575028140262444*^9}, {3.5750282095211277`*^9, 
+  3.575028411340498*^9}, {3.575028513746626*^9, 3.5750285149808273`*^9}, {
+  3.575028565153102*^9, 3.575028576435603*^9}, {3.575028614268888*^9, 
+  3.57502861663518*^9}, {3.5750286502604856`*^9, 3.575028667957321*^9}, {
+  3.575028702423554*^9, 3.575028738837942*^9}, {3.575028775720426*^9, 
+  3.575028776057373*^9}, {3.575028869874096*^9, 3.575028873948093*^9}, {
+  3.575049051550745*^9, 3.575049053326434*^9}, {3.575049095852672*^9, 
+  3.575049104580035*^9}}],
+
+Cell[CellGroupData[{
+
+Cell[BoxData[
+ RowBox[{"Export", "[", 
+  RowBox[{"\"\<torus.png\>\"", ",", "pic", ",", 
+   RowBox[{"ImageResolution", "\[Rule]", "900"}]}], "]"}]], "Input",
+ CellChangeTimes->{{3.5750284389216022`*^9, 3.575028451068201*^9}, {
+  3.575028890584002*^9, 3.575028893093935*^9}, {3.575049114609*^9, 
+  3.575049115913175*^9}}],
+
+Cell[BoxData["\<\"torus.png\"\>"], "Output",
+ CellChangeTimes->{
+  3.575028453439415*^9, 3.575028526269167*^9, 3.575028584785966*^9, 
+   3.575028622186308*^9, 3.575028677156248*^9, 3.575028785220005*^9, {
+   3.575028880042776*^9, 3.575028897213284*^9}, 3.5750490811049767`*^9, 
+   3.575049130061048*^9}]
+}, Open  ]]
+},
+WindowSize->{740, 855},
+WindowMargins->{{170, Automatic}, {Automatic, 6}},
+PrivateNotebookOptions->{"VersionedStylesheet"->{"Default.nb"[8.] -> False}},
+FrontEndVersion->"9.0 for Mac OS X x86 (32-bit, 64-bit Kernel) (January 25, \
+2013)",
+StyleDefinitions->"Default.nb"
+]
+(* End of Notebook Content *)
+
+(* Internal cache information *)
+(*CellTagsOutline
+CellTagsIndex->{}
+*)
+(*CellTagsIndex
+CellTagsIndex->{}
+*)
+(*NotebookFileOutline
+Notebook[{
+Cell[400, 13, 1324, 33, 63, "Input"],
+Cell[1727, 48, 2616, 64, 165, "Input"],
+Cell[CellGroupData[{
+Cell[4368, 116, 369, 6, 28, "Input"],
+Cell[4740, 124, 156, 2, 28, "Output"]
+}, Open  ]],
+Cell[4911, 129, 2125, 49, 165, "Input"],
+Cell[7039, 180, 92, 1, 28, "Input"],
+Cell[CellGroupData[{
+Cell[7156, 185, 283, 5, 28, "Input"],
+Cell[7442, 192, 356, 5, 28, "Output"]
+}, Open  ]],
+Cell[7813, 200, 982, 24, 97, "Input"],
+Cell[CellGroupData[{
+Cell[8820, 228, 228, 4, 28, "Input"],
+Cell[9051, 234, 157, 2, 28, "Output"]
+}, Open  ]],
+Cell[9223, 239, 2152, 51, 148, "Input"],
+Cell[CellGroupData[{
+Cell[11400, 294, 319, 6, 28, "Input"],
+Cell[11722, 302, 303, 5, 28, "Output"]
+}, Open  ]]
+}
+]
+*)
+

cover/torus/symbols.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+# This script generates symbol images from which the
+# torus picture is then assembled.
+
+import subprocess
+import os
+import os.path
+
+symbols = [
+  r"$$\sum$$",
+  r"$$\prod$$",
+  r"$$\lambda$$",
+  r"$$\times$$",
+  r"$$\simeq$$"
+]
+
+ncols = 1
+
+colors = [("gray", str(float(i)/ncols)) for i in range(0, ncols+1)]
+
+## Generate LaTeX
+
+template = r"""
+\documentclass{article}
+\usepackage{palatino}
+\usepackage{amsmath,amssymb,amsfonts}
+\usepackage{xcolor}
+\pagestyle{empty}
+\begin{document}
+%s
+\end{document}"""
+
+tex = ""
+for (i, s) in enumerate(symbols):
+    for (j, (m,c)) in enumerate(colors):
+        tex = tex + (r"\definecolor{mycolor}{%s}{%s}\textcolor{mycolor}{%s}\newpage" % (m, c, s)) + "\n"
+
+# Write LaTeX to file
+
+with open("temp.tex", "w") as f:
+    f.write(template % tex)
+
+# Process LaTeX and generate png files
+
+subprocess.call(["latex", "temp.tex"])
+subprocess.call(["dvipng", "-D", "1200", "-o", "preimg/image_%02d.png", "-T", "tight", "temp.dvi"])
+
+# Convert png files to jpg
+
+filelist = [f for f in os.listdir('preimg') if f.endswith(".png")]
+for f in filelist:
+    fin = os.path.join("preimg", f)
+    fout = os.path.join("srcimg", os.path.splitext(f)[0] + ".jpg")
+    subprocess.call(["convert", "-bordercolor", "white", "-border", "20x20", "-quality", "100", fin, fout])
+
+# Remove auxiliary files
+
+for f in filelist:
+    os.remove(os.path.join("preimg", f))
+
+for f in [f for f in os.listdir('.') if f.startswith("temp.")]:
+    os.remove(f)

cover/torus/torus-clipped.xcf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af227261cd1a7295a2e4f6daea5cdc0f7fd61a41144785001205f53ad1157139
+size 49466994

equivalences.tex

@@ -0,0 +1,1118 @@
+\chapter{Equivalences}
+\label{cha:equivalences}
+
+We now study in more detail the notion of \emph{equivalence of types} that was introduced briefly in \cref{sec:basics-equivalences}.
+Specifically, we will give several different ways to define a type $\isequiv(f)$ having the properties mentioned there.
+Recall that we wanted $\isequiv(f)$ to have the following properties, which we restate here:
+\begin{enumerate}
+\item $\qinv(f) \to \isequiv (f)$.\label{item:beb1}
+\item $\isequiv (f) \to \qinv(f)$.\label{item:beb2}
+\item $\isequiv(f)$ is a mere proposition.\label{item:beb3}
+\end{enumerate}
+Here $\qinv(f)$ denotes the type of quasi-inverses to $f$:
+\begin{equation*}
+  \sm{g:B\to A} \big((f \circ g \htpy \idfunc[B]) \times (g\circ f \htpy \idfunc[A])\big).
+\end{equation*}
+By function extensionality, it follows that $\qinv(f)$ is equivalent to the type
+\begin{equation*}
+  \sm{g:B\to A} \big((f \circ g = \idfunc[B]) \times (g\circ f = \idfunc[A])\big).
+\end{equation*}
+We will define three different types having properties~\ref{item:beb1}--\ref{item:beb3}, which we call
+\begin{itemize}
+\item half adjoint equivalences,
+\item bi-invertible maps,
+  \index{function!bi-invertible}
+  and
+\item contractible functions.
+\end{itemize}
+We will also show that all these types are equivalent.
+These names are intentionally somewhat cumbersome, because after we know that they are all equivalent and have properties~\ref{item:beb1}--\ref{item:beb3}, we will revert to saying simply ``equivalence'' without needing to specify which particular definition we choose.
+But for purposes of the comparisons in this chapter, we need different names for each definition.
+
+Before we examine the different notions of equivalence, however, we give a little more explanation of why a different concept than quasi-invertibility is needed.
+
+\section{Quasi-inverses}
+\label{sec:quasi-inverses}
+
+\index{quasi-inverse|(}%
+We have said that $\qinv(f)$ is unsatisfactory because it is not a mere proposition, whereas we would rather that a given function could ``be an equivalence'' in at most one way.
+However, we have given no evidence that $\qinv(f)$ is not a mere proposition.
+In this section we exhibit a specific counterexample.
+
+\begin{lem}\label{lem:qinv-autohtpy}
+  If $f:A\to B$ is such that $\qinv (f)$ is inhabited, then
+  \[\eqv{\qinv(f)}{\Parens{\prd{x:A}(x=x)}}.\]
+\end{lem}
+\begin{proof}
+  By assumption, $f$ is an equivalence; that is, we have $e:\isequiv(f)$ and so $(f,e):\eqv A B$.
+  By univalence, $\idtoeqv:(A=B) \to (\eqv A B)$ is an equivalence, so we may assume that $(f,e)$ is of the form $\idtoeqv(p)$ for some $p:A=B$.
+  Then by path induction, we may assume $p$ is $\refl{A}$, in which case $f$ is $\idfunc[A]$.
+  Thus we are reduced to proving $\eqv{\qinv(\idfunc[A])}{(\prd{x:A}(x=x))}$.
+  Now by definition we have
+  \[ \qinv(\idfunc[A]) \jdeq
+  \sm{g:A\to A} \big((g \htpy \idfunc[A]) \times (g \htpy \idfunc[A])\big).
+  \]
+  By function extensionality, this is equivalent to
+  \[ \sm{g:A\to A} \big((g = \idfunc[A]) \times (g = \idfunc[A])\big).
+  \]
+  And by \cref{ex:sigma-assoc}, this is equivalent to
+  \[ \sm{h:\sm{g:A\to A} (g = \idfunc[A])} (\proj1(h) = \idfunc[A])
+  \]
+  However, by \cref{thm:contr-paths}, $\sm{g:A\to A} (g = \idfunc[A])$ is contractible with center $(\idfunc[A],\refl{\idfunc[A]})$; therefore by \cref{thm:omit-contr} this type is equivalent to $\idfunc[A] = \idfunc[A]$.
+  And by function extensionality, $\idfunc[A] = \idfunc[A]$ is equivalent to $\prd{x:A} x=x$.
+\end{proof}
+
+\noindent
+We remark that \cref{ex:qinv-autohtpy-no-univalence} asks for a proof of the above lemma which avoids univalence.
+
+Thus, what we need is some $A$ which admits a nontrivial element of $\prd{x:A}(x=x)$.
+Thinking of $A$ as a higher groupoid, an inhabitant of $\prd{x:A}(x=x)$ is a natural transformation\index{natural!transformation} from the identity functor of $A$ to itself.
+Such transformations are said to form the \define{center of a category},
+\index{center!of a category}%
+\index{category!center of}%
+since the naturality axiom requires that they commute with all morphisms.
+Classically, if $A$ is simply a group regarded as a one-object groupoid, then this yields precisely its center in the usual group-theoretic sense.
+This provides some motivation for the following.
+
+\begin{lem}\label{lem:autohtpy}
+  Suppose we have a type $A$ with $a:A$ and $q:a=a$ such that
+  \begin{enumerate}
+  \item The type $a=a$ is a set.\label{item:autohtpy1}
+  \item For all $x:A$ we have $\brck{a=x}$.\label{item:autohtpy2}
+  \item For all $p:a=a$ we have $p\ct q = q \ct p$.\label{item:autohtpy3}
+  \end{enumerate}
+  Then there exists $f:\prd{x:A} (x=x)$ with $f(a)=q$.
+\end{lem}
+\begin{proof}
+  Let $g:\prd{x:A} \brck{a=x}$ be as given by~\ref{item:autohtpy2}.  First we
+  observe that each type $\id[A]xy$ is a set.  For since being a set is a mere
+  proposition, we may apply the induction principle of propositional truncation, and assume that $g(x)=\bproj
+  p$ and $g(y)=\bproj{p'}$ for $p:a=x$ and $p':a=y$.  In this case, composing with
+  $p$ and $\opp{p'}$ yields an equivalence $\eqv{(x=y)}{(a=a)}$.  But $(a=a)$ is
+  a set by~\ref{item:autohtpy1}, so $(x=y)$ is also a set.
+
+  Now, we would like to define $f$ by assigning to each $x$ the path $\opp{g(x)}
+  \ct q \ct g(x)$, but this does not work because $g(x)$ does not inhabit $a=x$
+  but rather $\brck{a=x}$, and the type $(x=x)$ may not be a mere proposition,
+  so we cannot use induction on propositional truncation.  Instead we can apply
+  the technique mentioned in \cref{sec:unique-choice}: we characterize
+  uniquely the object we wish to construct.  Let us define, for each $x:A$, the
+  type
+  \[ B(x) \defeq \sm{r:x=x} \prd{s:a=x} (r = \opp s \ct q\ct s).\]
+  We claim that $B(x)$ is a mere proposition for each $x:A$.
+  Since this claim is itself a mere proposition, we may again apply induction on
+  truncation and assume that $g(x) = \bproj p$ for some $p:a=x$.
+  Now suppose given $(r,h)$ and $(r',h')$ in $B(x)$; then we have
+  \[ h(p) \ct \opp{h'(p)} : r = r'. \]
+  It remains to show that $h$ is identified with $h'$ when transported along this equality, which by transport in identity types and function types (\cref{sec:compute-paths,sec:compute-pi}), reduces to showing
+  \[ h(s) = h(p) \ct \opp{h'(p)} \ct h'(s) \]
+  for any $s:a=x$.
+  But each side of this is an equality between elements of $(x=x)$, so it follows from our above observation that $(x=x)$ is a set.
+
+  Thus, each $B(x)$ is a mere proposition; we claim that $\prd{x:A} B(x)$.
+  Given $x:A$, we may now invoke the induction principle of propositional truncation to assume that $g(x) = \bproj p$ for $p:a=x$.
+  We define $r \defeq \opp p \ct q \ct p$; to inhabit $B(x)$ it remains to show that for any $s:a=x$ we have
+  $r = \opp s \ct q \ct s$.
+  Manipulating paths, this reduces to showing that $q\ct (p\ct \opp s) = (p\ct \opp s) \ct q$.
+  But this is just an instance of~\ref{item:autohtpy3}.
+\end{proof}
+
+\begin{thm}\label{thm:qinv-notprop}
+  There exist types $A$ and $B$ and a function $f:A\to B$ such that $\qinv(f)$ is not a mere proposition.
+\end{thm}
+\begin{proof}
+  It suffices to exhibit a type $X$ such that $\prd{x:X} (x=x)$ is not a mere proposition.
+  Define $X\defeq \sm{A:\type} \brck{\bool=A}$, as in the proof of \cref{thm:no-higher-ac}.
+  It will suffice to exhibit an $f:\prd{x:X} (x=x)$ which is unequal to $\lam{x} \refl{x}$.
+
+  Let $a \defeq (\bool,\bproj{\refl{\bool}}) : X$, and let $q:a=a$ be the path corresponding to the nonidentity equivalence $e:\eqv\bool\bool$ defined by $e(\bfalse)\defeq\btrue$ and $e(\btrue)\defeq\bfalse$.
+  We would like to apply \cref{lem:autohtpy} to build an $f$.
+  By definition of $X$, equalities in subset types (\cref{subsec:prop-subsets}), and univalence, we have $\eqv{(a=a)}{(\eqv{\bool}{\bool})}$, which is a set, so~\ref{item:autohtpy1} holds.
+  Similarly, by definition of $X$ and equalities in subset types we have~\ref{item:autohtpy2}.
+  Finally, \cref{ex:eqvboolbool} implies that every equivalence $\eqv\bool\bool$ is equal to either $\idfunc[\bool]$ or $e$, so we can show~\ref{item:autohtpy3} by a four-way case analysis.
+
+  Thus, we have $f:\prd{x:X} (x=x)$ such that $f(a) = q$.
+  Since $e$ is not equal to $\idfunc[\bool]$, $q$ is not equal to $\refl{a}$, and thus $f$ is not equal to $\lam{x} \refl{x}$.
+  Therefore, $\prd{x:X} (x=x)$ is not a mere proposition.
+\end{proof}
+
+More generally, \cref{lem:autohtpy} implies that any ``Eilenberg--Mac Lane space'' $K(G,1)$, where $G$ is a nontrivial abelian\index{group!abelian} group, will provide a counterexample; see \cref{cha:homotopy}.
+The type $X$ we used turns out to be equivalent to $K(\mathbb{Z}_2,1)$.
+In \cref{cha:hits} we will see that the circle $\Sn^1 = K(\mathbb{Z},1)$ is another easy-to-describe example.
+
+We now move on to describing better notions of equivalence.
+
+\index{quasi-inverse|)}%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{Half adjoint equivalences}
+\label{sec:hae}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\index{equivalence!half adjoint|(defstyle}%
+\index{half adjoint equivalence|(defstyle}%
+\index{adjoint!equivalence!of types, half|(defstyle}%
+
+In \cref{sec:quasi-inverses} we concluded that $\qinv(f)$ is equivalent to $\prd{x:A} (x=x)$ by discarding a contractible type.
+Roughly, the type $\qinv(f)$ contains three data $g$, $\eta$, and $\epsilon$, of which two ($g$ and $\eta$) could together be seen to be contractible when $f$ is an equivalence.
+The problem is that removing these data left one remaining ($\epsilon$).
+In order to solve this problem, the idea is to add one \emph{additional} datum which, together with $\epsilon$, forms a contractible type.
+
+\begin{defn}\label{defn:ishae}
+  A function $f:A\to B$ is a \define{half adjoint equivalence}
+  if there are $g:B\to A$ and homotopies $\eta: g \circ f \htpy \idfunc[A]$ and $\epsilon:f \circ g \htpy \idfunc[B]$ such that there exists a homotopy
+  \[\tau : \prd{x:A} \map{f}{\eta x} = \epsilon(fx).\]
+\end{defn}
+
+Thus we have a type $\ishae(f)$, defined to be
+\begin{equation*}
+  \sm{g:B\to A}{\eta: g \circ f \htpy \idfunc[A]}{\epsilon:f \circ g \htpy \idfunc[B]} \prd{x:A} \map{f}{\eta x} = \epsilon(fx).
+\end{equation*}
+Note that in the above definition, the coherence\index{coherence} condition relating $\eta$ and $\epsilon$ only involves $f$.
+We might consider instead an analogous coherence condition involving $g$:
+\[\upsilon : \prd{y:B} \map{g}{\epsilon y} = \eta(gy)\]
+and a resulting analogous definition $\ishae'(f)$.
+
+Fortunately, it turns out each of the conditions implies the other one:
+
+\begin{lem}\label{lem:coh-equiv}
+For functions $f : A \to B$ and $g:B\to A$ and homotopies $\eta: g \circ f \htpy \idfunc[A]$ and $\epsilon:f \circ g \htpy \idfunc[B]$, the following conditions are logically equivalent:
+\begin{itemize}
+\item $\prd{x:A} \map{f}{\eta x} = \epsilon(fx)$
+\item $\prd{y:B} \map{g}{\epsilon y} = \eta(gy)$
+\end{itemize}
+\end{lem}
+\begin{proof}
+  It suffices to show one direction; the other one is obtained by replacing $A$, $f$, and $\eta$ by $B$, $g$, and $\epsilon$ respectively.
+  Let $\tau : \prd{x:A}\;\map{f}{\eta x} = \epsilon(fx)$.
+  Fix $y : B$.
+  Using naturality of $\epsilon$ and applying $g$, we get the following commuting diagram of paths:
+\[\uppercurveobject{{ }}\lowercurveobject{{ }}\twocellhead{{ }}
+  \xymatrix@C=3pc{gfgfgy \ar@{=}^-{gfg(\epsilon y)}[r] \ar@{=}_{g(\epsilon (fgy))}[d] & gfgy \ar@{=}^{g(\epsilon y)}[d] \\ gfgy \ar@{=}_{g(\epsilon y)}[r] & gy
+  }\]
+Using $\tau(gy)$ on the left side of the diagram gives us
+\[\uppercurveobject{{ }}\lowercurveobject{{ }}\twocellhead{{ }}
+  \xymatrix@C=3pc{gfgfgy \ar@{=}^-{gfg(\epsilon y)}[r] \ar@{=}_{gf(\eta (gy))}[d] & gfgy \ar@{=}^{g(\epsilon y)}[d] \\ gfgy \ar@{=}_{g(\epsilon y)}[r] & gy
+  }\]
+Using the commutativity of $\eta$ with $g \circ f$ (\cref{cor:hom-fg}), we have
+\[\uppercurveobject{{ }}\lowercurveobject{{ }}\twocellhead{{ }}
+  \xymatrix@C=3pc{gfgfgy \ar@{=}^-{gfg(\epsilon y)}[r] \ar@{=}_{\eta (gfgy)}[d] & gfgy \ar@{=}^{g(\epsilon y)}[d] \\ gfgy \ar@{=}_{g(\epsilon y)}[r] & gy
+  }\]
+However, by naturality of $\eta$ we also have
+\[\uppercurveobject{{ }}\lowercurveobject{{ }}\twocellhead{{ }}
+  \xymatrix@C=3pc{gfgfgy \ar@{=}^-{gfg(\epsilon y)}[r] \ar@{=}_{\eta (gfgy)}[d] & gfgy \ar@{=}^{\eta(gy)}[d] \\ gfgy \ar@{=}_{g(\epsilon y)}[r] & gy
+  }\]
+Thus, canceling all but the right-hand homotopy, we have $g(\epsilon y) = \eta(g y)$ as desired.
+\end{proof}
+
+However, it is important that we do not include \emph{both} $\tau$ and $\upsilon$ in the definition of $\ishae (f)$ (whence the name ``\emph{half} adjoint equivalence'').
+If we did, then after canceling contractible types we would still have one remaining datum --- unless we added another higher coherence condition.
+In general, we expect to get a well-behaved type if we cut off after an odd number of coherences.
+
+Of course, it is obvious that $\ishae(f) \to\qinv(f)$: simply forget the coherence datum.
+The other direction is a version of a standard argument from homotopy theory and category theory.
+
+\begin{thm}\label{thm:equiv-iso-adj}
+  For any $f:A\to B$ we have $\qinv(f)\to\ishae(f)$.
+\end{thm}
+\begin{proof}
+Suppose that $(g,\eta,\epsilon)$ is a quasi-inverse for $f$. We have to provide
+a quadruple $(g',\eta',\epsilon',\tau)$ witnessing that $f$ is a half adjoint equivalence. To
+define $g'$ and $\eta'$, we can just make the obvious choice by setting $g'
+\defeq g$ and $\eta'\defeq \eta$. However, in the definition of $\epsilon'$ we
+need start worrying about the construction of $\tau$, so we cannot just follow our nose
+and take $\epsilon'$ to be $\epsilon$. Instead, we take
+\begin{equation*}
+\epsilon'(b) \defeq \opp{\epsilon(f(g(b)))}\ct (\ap{f}{\eta(g(b))}\ct \epsilon(b)).
+\end{equation*}
+Now we need to find
+\begin{equation*}
+\tau(a): \ap{f}{\eta(a)}=\opp{\epsilon(f(g(f(a))))}\ct (\ap{f}{\eta(g(f(a)))}\ct \epsilon(f(a))).
+\end{equation*}
+Note first that by \cref{cor:hom-fg}, we have
+%$\eta(g(f(a)))\ct\eta(a)=\ap{g}{\ap{f}{\eta(a)}}\ct\eta(a)$ and hence it follows that
+$\eta(g(f(a)))=\ap{g}{\ap{f}{\eta(a)}}$. Therefore, we can apply
+\cref{lem:htpy-natural} to compute
+\begin{align*}
+\ap{f}{\eta(g(f(a)))}\ct \epsilon(f(a))
+& = \ap{f}{\ap{g}{\ap{f}{\eta(a)}}}\ct \epsilon(f(a))\\
+& = \epsilon(f(g(f(a))))\ct \ap{f}{\eta(a)}
+\end{align*}
+from which we get the desired path $\tau(a)$.
+\end{proof}
+
+Combining this with \cref{lem:coh-equiv} (or symmetrizing the proof), we also have $\qinv(f)\to\ishae'(f)$.
+
+It remains to show that $\ishae(f)$ is a mere proposition.
+For this, we will need to know that the fibers of an equivalence are contractible.
+
+\begin{defn}\label{defn:homotopy-fiber}
+  The \define{fiber}
+  \indexdef{fiber}%
+  \indexsee{function!fiber of}{fiber}%
+  of a map $f:A\to B$ over a point $y:B$ is
+  \[ \hfib f y \defeq \sm{x:A} (f(x) = y).\]
+\end{defn}
+
+In homotopy theory, this is what would be called the \emph{homotopy fiber} of $f$.
+The path lemmas in \cref{sec:computational} yield the following characterization of paths in fibers:
+
+\begin{lem}\label{lem:hfib}
+  For any $f : A \to B$, $y : B$, and $(x,p),(x',p') : \hfib{f}{y}$, we have
+  \[ \big((x,p) = (x',p')\big) \eqvsym \Parens{\sm{\gamma : x = x'} f(\gamma) \ct p' = p} \qedhere\]
+\end{lem}
+
+\begin{thm}\label{thm:contr-hae}
+  If $f:A\to B$ is a half adjoint equivalence, then for any $y:B$ the fiber $\hfib f y$ is contractible.
+\end{thm}
+\begin{proof}
+  Let $(g,\eta,\epsilon,\tau) : \ishae(f)$, and fix $y : B$.
+  As our center of contraction for $\hfib{f}{y}$ we choose $(gy, \epsilon y)$.
+  Now take any $(x,p) : \hfib{f}{y}$; we want to construct a path from $(gy, \epsilon y)$ to $(x,p)$.
+  By \cref{lem:hfib}, it suffices to give a path $\gamma : \id{gy}{x}$ such that $\ap f\gamma \ct p = \epsilon y$.
+  We put $\gamma \defeq \opp{g(p)} \ct \eta x$.
+  Then we have
+  \begin{align*}
+    f(\gamma) \ct p & = \opp{fg(p)} \ct f (\eta x) \ct p \\
+    & = \opp{fg(p)} \ct \epsilon(fx) \ct p \\
+    & = \epsilon y
+  \end{align*}
+  where the second equality follows by $\tau x$ and the third equality is naturality of $\epsilon$.
+\end{proof}
+
+We now define the types which encapsulate contractible pairs of data.
+The following types put together the quasi-inverse $g$ with one of the homotopies.
+
+\begin{defn}\label{defn:linv-rinv}
+  Given a function $f:A\to B$, we define the types
+    \begin{align*}
+      \linv(f) &\defeq \sm{g:B\to A} (g\circ f\htpy \idfunc[A])\\
+      \rinv(f) &\defeq \sm{g:B\to A} (f\circ g\htpy \idfunc[B])
+    \end{align*}
+  of \define{left inverses}
+  \indexdef{left!inverse}%
+  \indexdef{inverse!left}%
+  and \define{right inverses}
+  \indexdef{right!inverse}%
+  \indexdef{inverse!right}%
+  to $f$, respectively.
+  We call $f$ \define{left invertible}
+  \indexdef{function!left invertible}%
+  \indexdef{function!right invertible}%
+  if $\linv(f)$ is inhabited, and similarly \define{right invertible}
+  \indexdef{left!invertible function}%
+  \indexdef{right!invertible function}%
+  if $\rinv(f)$ is inhabited.
+\end{defn}
+
+\begin{lem}\label{thm:equiv-compose-equiv}
+  If $f:A\to B$ has a quasi-inverse, then so do
+  \begin{align*}
+    (f\circ \blank) &: (C\to A) \to (C\to B)\\
+    (\blank\circ f) &: (B\to C) \to (A\to C).
+  \end{align*}
+\end{lem}
+\begin{proof}
+  If $g$ is a quasi-inverse of $f$, then $(g\circ \blank)$ and $(\blank\circ g)$ are quasi-inverses of $(f\circ \blank)$ and $(\blank\circ f)$ respectively.
+\end{proof}
+
+\begin{lem}\label{lem:inv-hprop}
+  If $f : A \to B$ has a quasi-inverse, then the types $\rinv(f)$ and $\linv(f)$ are contractible.
+\end{lem}
+\begin{proof}
+  By function extensionality, we have
+  \[\eqv{\linv(f)}{\sm{g:B\to A} (g\circ f = \idfunc[A])}.\]
+  But this is the fiber of $(\blank\circ f)$ over $\idfunc[A]$, and so
+  by \cref{thm:equiv-compose-equiv,thm:equiv-iso-adj,thm:contr-hae}, it is contractible.
+  Similarly, $\rinv(f)$ is equivalent to the fiber of $(f\circ \blank)$ over $\idfunc[B]$ and hence contractible.
+\end{proof}
+
+Next we define the types which put together the other homotopy with the additional coherence datum.\index{coherence}%
+
+\begin{defn}\label{defn:lcoh-rcoh}
+For $f : A \to B$, a left inverse $(g,\eta) : \linv(f)$, and a right inverse $(g,\epsilon) : \rinv(f)$, we denote
+\begin{align*}
+\lcoh{f}{g}{\eta} & \defeq \sm{\epsilon : f\circ g \htpy \idfunc[B]} \prd{y:B} g(\epsilon y) = \eta (gy), \\
+\rcoh{f}{g}{\epsilon} & \defeq \sm{\eta : g\circ f \htpy \idfunc[A]} \prd{x:A} f(\eta x) = \epsilon (fx).
+\end{align*}
+\end{defn}
+
+\begin{lem}\label{lem:coh-hfib}
+For any $f,g,\epsilon,\eta$, we have
+\begin{align*}
+\lcoh{f}{g}{\eta} & \eqvsym {\prd{y:B} \id[\hfib{g}{gy}]{(fgy,\eta(gy))}{(y,\refl{gy})}}, \\
+\rcoh{f}{g}{\epsilon} & \eqvsym {\prd{x:A} \id[\hfib{f}{fx}]{(gfx,\epsilon(fx))}{(x,\refl{fx})}}.
+\end{align*}
+\end{lem}
+\begin{proof}
+Using \cref{lem:hfib}.
+\end{proof}
+
+\begin{lem}\label{lem:coh-hprop}
+  If $f$ is a half adjoint equivalence, then for any $(g,\epsilon) : \rinv(f)$, the type $\rcoh{f}{g}{\epsilon}$ is contractible.
+\end{lem}
+\begin{proof}
+  By \cref{lem:coh-hfib} and the fact that dependent function types preserve contractible spaces, it suffices to show that for each $x:A$, the type $\id[\hfib{f}{fx}]{(gfx,\epsilon(fx))}{(x,\refl{fx})}$ is contractible.
+  But by \cref{thm:contr-hae}, $\hfib{f}{fx}$ is contractible, and any path space of a contractible space is itself contractible.
+\end{proof}
+
+\begin{thm}\label{thm:hae-hprop}
+  For any $f : A \to B$, the type $\ishae(f)$ is a mere proposition.
+\end{thm}
+\begin{proof}
+  By \cref{ex:prop-inhabcontr} it suffices to assume $f$ to be a half adjoint equivalence and show that $\ishae(f)$ is contractible.
+  Now by associativity of $\Sigma$ (\cref{ex:sigma-assoc}), the type $\ishae(f)$ is equivalent to
+  \[\sm{u : \rinv(f)} \rcoh{f}{\proj{1}(u)}{\proj{2}(u)}.\]
+  But by \cref{lem:inv-hprop,lem:coh-hprop} and the fact that $\Sigma$ preserves contractibility, the latter type is also contractible.
+\end{proof}
+
+Thus, we have shown that $\ishae(f)$ has all three desiderata for the type $\isequiv(f)$.
+In the next two sections we consider a couple of other possibilities.
+
+\index{equivalence!half adjoint|)}%
+\index{half adjoint equivalence|)}%
+\index{adjoint!equivalence!of types, half|)}%
+
+\section{Bi-invertible maps}
+\label{sec:biinv}
+
+\index{function!bi-invertible|(defstyle}%
+\index{bi-invertible function|(defstyle}%
+\index{equivalence!as bi-invertible function|(defstyle}%
+
+Using the language introduced in \cref{sec:hae}, we can restate the definition proposed in \cref{sec:basics-equivalences} as follows.
+
+\begin{defn}\label{defn:biinv}
+  We say $f:A\to B$ is \define{bi-invertible}
+  if it has both a left inverse and a right inverse:
+  \[ \biinv (f) \defeq \linv(f) \times \rinv(f). \]
+\end{defn}
+
+In \cref{sec:basics-equivalences} we proved that $\qinv(f)\to\biinv(f)$ and $\biinv(f)\to\qinv(f)$.
+What remains is the following.
+
+\begin{thm}\label{thm:isprop-biinv}
+  For any $f:A\to B$, the type $\biinv(f)$ is a mere proposition.
+\end{thm}
+\begin{proof}
+  We may suppose $f$ to be bi-invertible and show that $\biinv(f)$ is contractible.
+  But since $\biinv(f)\to\qinv(f)$, by \cref{lem:inv-hprop} in this case both $\linv(f)$ and $\rinv(f)$ are contractible, and the product of contractible types is contractible.
+\end{proof}
+
+Note that this also fits the proposal made at the beginning of \cref{sec:hae}: we combine $g$ and $\eta$ into a contractible type and add an additional datum which combines with $\epsilon$ into a contractible type.
+The difference is that instead of adding a \emph{higher} datum (a 2-dimensional path) to combine with $\epsilon$, we add a \emph{lower} one (a right inverse that is separate from the left inverse).
+
+\begin{cor}\label{thm:equiv-biinv-isequiv}
+  For any $f:A\to B$ we have $\eqv{\biinv(f)}{\ishae(f)}$.
+\end{cor}
+\begin{proof}
+  We have $\biinv(f) \to \qinv(f) \to \ishae(f)$ and $\ishae(f) \to \qinv(f) \to \biinv(f)$.
+  Since both $\ishae(f)$ and $\biinv(f)$ are mere propositions, the equivalence follows from \cref{lem:equiv-iff-hprop}.
+\end{proof}
+
+\index{function!bi-invertible|)}%
+\index{bi-invertible function|)}%
+\index{equivalence!as bi-invertible function|)}%
+
+\section{Contractible fibers}
+\label{sec:contrf}
+
+\index{function!contractible|(defstyle}%
+\index{contractible!function|(defstyle}%
+\index{equivalence!as contractible function|(defstyle}%
+
+Note that our proofs about $\ishae(f)$ and $\biinv(f)$ made essential use of the fact that the fibers of an equivalence are contractible.
+In fact, it turns out that this property is itself a sufficient definition of equivalence.
+
+\begin{defn}[Contractible maps] \label{defn:equivalence}
+  A map $f:A\to B$ is \define{contractible}
+  if for all $y:B$, the fiber $\hfib f y$ is contractible.
+\end{defn}
+
+Thus, the type $\iscontr(f)$ is defined to be
+\begin{align}
+  \iscontr(f) &\defeq \prd{y:B} \iscontr(\hfib f y)\label{eq:iscontrf}
+  % \\
+  % &\defeq \prd{y:B} \iscontr (\setof{x:A | f(x) = y}).
+\end{align}
+Note that in \cref{sec:contractibility} we defined what it means for a \emph{type} to be contractible.
+Here we are defining what it means for a \emph{map} to be contractible.
+Our terminology follows the general homotopy-theoretic practice of saying that a map has a certain property if all of its (homotopy) fibers have that property.
+Thus, a type $A$ is contractible just when the map $A\to\unit$ is contractible.
+From \cref{cha:hlevels} onwards we will also call contractible maps and types \emph{$(-2)$-truncated}.
+
+We have already shown in \cref{thm:contr-hae} that $\ishae(f) \to \iscontr(f)$.
+Conversely:
+
+\begin{thm}\label{thm:lequiv-contr-hae}
+For any $f:A\to B$ we have ${\iscontr(f)} \to {\ishae(f)}$.
+\end{thm}
+\begin{proof}
+Let $P : \iscontr(f)$. We define an inverse mapping $g : B \to A$ by sending each $y : B$ to the center of contraction of the fiber at $y$:
+\[ g(y) \defeq \proj{1}(\proj{1}(Py)). \]
+We can thus define the homotopy $\epsilon$ by mapping $y$ to the witness that $g(y)$ indeed belongs to the fiber at $y$:
+\[ \epsilon(y) \defeq \proj{2}(\proj{1}(P y)). \]
+It remains to define $\eta$ and $\tau$. This of course amounts to giving an element of $\rcoh{f}{g}{\epsilon}$. By \cref{lem:coh-hfib}, this is the same as giving for each $x:A$ a path from $(gfx,\epsilon(fx))$ to $(x,\refl{fx})$ in the fiber of $f$ over $fx$. But this is easy: for any $x : A$, the type $\hfib{f}{fx}$
+is contractible by assumption, hence such a path must exist. We can construct it explicitly as
+\[\opp{\big(\proj{2}(P(fx))(gfx,\epsilon(fx))\big)} \ct \big(\proj{2}(P(fx)) (x,\refl{fx})\big). \qedhere \]
+\end{proof}
+
+It is also easy to see:
+
+\begin{lem}\label{thm:contr-hprop}
+  For any $f$, the type $\iscontr(f)$ is a mere proposition.
+\end{lem}
+\begin{proof}
+  By \cref{thm:isprop-iscontr}, each type $\iscontr (\hfib f y)$ is a mere proposition.
+  Thus, by \cref{thm:isprop-forall}, so is~\eqref{eq:iscontrf}.
+\end{proof}
+
+\begin{thm}\label{thm:equiv-contr-hae}
+  For any $f:A\to B$ we have $\eqv{\iscontr(f)}{\ishae(f)}$.
+\end{thm}
+\begin{proof}
+  We have already established a logical equivalence ${\iscontr(f)} \Leftrightarrow {\ishae(f)}$, and both are mere propositions (\cref{thm:contr-hprop,thm:hae-hprop}).
+  Thus, \cref{lem:equiv-iff-hprop} applies.
+\end{proof}
+
+Usually, we prove that a function is an equivalence by exhibiting a quasi-inverse, but sometimes this definition is more convenient.
+For instance, it implies that when proving a function to be an equivalence, we are free to assume that its codomain is inhabited.
+
+\begin{cor}\label{thm:equiv-inhabcod}
+  If $f:A\to B$ is such that $B\to \isequiv(f)$, then $f$ is an equivalence.
+\end{cor}
+\begin{proof}
+  To show $f$ is an equivalence, it suffices to show that $\hfib f y$ is contractible for any $y:B$.
+  But if $e:B\to \isequiv(f)$, then given any such $y$ we have $e(y):\isequiv(f)$, so that $f$ is an equivalence and hence $\hfib f y$ is contractible, as desired.
+\end{proof}
+
+\index{function!contractible|)}%
+\index{contractible!function|)}%
+\index{equivalence!as contractible function|)}%
+
+\section{On the definition of equivalences}
+\label{sec:concluding-remarks}
+
+\indexdef{equivalence}
+We have shown that all three definitions of equivalence satisfy the three desirable properties and are pairwise equivalent:
+\[ \iscontr(f) \eqvsym \ishae(f) \eqvsym \biinv(f). \]
+(There are yet more possible definitions of equivalence, but we will stop with these three.
+See \cref{ex:brck-qinv} and the exercises in this chapter for some more.)
+Thus, we may choose any one of them as ``the'' definition of $\isequiv (f)$.
+For definiteness, we choose to define
+\[ \isequiv(f) \defeq \ishae(f).\]
+\index{mathematics!formalized}%
+This choice is advantageous for formalization, since $\ishae(f)$ contains the most directly useful data.
+On the other hand, for other purposes, $\biinv(f)$ is often easier to deal with, since it contains no 2-dimensional paths and its two symmetrical halves can be treated independently.
+However, for purposes of this book, the specific choice will make little difference.
+
+In the rest of this chapter, we study some other properties and characterizations of equivalences.
+\index{equivalence!properties of}%
+
+
+\section{Surjections and embeddings}
+\label{sec:mono-surj}
+
+\index{set}
+When $A$ and $B$ are sets and $f:A\to B$ is an equivalence, we also call it as \define{isomorphism}
+\indexdef{isomorphism!of sets}%
+or a \define{bijection}.
+\indexdef{bijection}%
+\indexsee{function!bijective}{bijection}%
+(We avoid these words for types that are not sets, since in homotopy theory and higher category theory they often denote a stricter notion of ``sameness'' than homotopy equivalence.)
+In set theory, a function is a bijection just when it is both injective and surjective.
+The same is true in type theory, if we formulate these conditions appropriately.
+For clarity, when dealing with types that are not sets, we will speak of \emph{embeddings} instead of injections.
+
+\begin{defn}\label{defn:surj-emb}
+  Let $f:A\to B$.
+  \begin{enumerate}
+  \item We say $f$ is \define{surjective}
+    \indexsee{surjective!function}{function, surjective}%
+    \indexdef{function!surjective}%
+    (or a \define{surjection})
+    \indexsee{surjection}{function, surjective}%
+    if for every $b:B$ we have $\brck{\hfib f b}$.
+  \item We say $f$ is an \define{embedding}
+    \indexdef{function!embedding}%
+    \indexsee{embedding}{function, embedding}%
+    if for every $x,y:A$ the function $\apfunc f : (\id[A]xy) \to (\id[B]{f(x)}{f(y)})$ is an equivalence.
+  \end{enumerate}
+\end{defn}
+
+In other words, $f$ is surjective if every fiber of $f$ is merely inhabited, or equivalently if for all $b:B$ there merely exists an $a:A$ such that $f(a)=b$.
+In traditional logical notation, $f$ is surjective if $\fall{b:B}\exis{a:A} (f(a)=b)$.
+This must be distinguished from the stronger assertion that $\prd{b:B}\sm{a:A} (f(a)=b)$; if this holds we say that $f$ is a \define{split surjection}.
+\indexsee{split!surjection}{function, split surjective}%
+\indexsee{surjection!split}{function, split surjective}%
+\indexsee{surjective!function!split}{function, split surjective}%
+\indexdef{function!split surjective}%
+(Since this latter type is equivalent to $\sm{g:B\to A}\prd{b:B} (f(g(b))=b)$, being a split surjection is the same as being a \emph{retraction} as defined in \cref{sec:contractibility}.)
+\index{retraction}%
+\index{function!retraction}%
+
+The axiom of choice from \cref{sec:axiom-choice} says exactly that every surjection \emph{between sets} is split.
+However, in the presence of the univalence axiom, it is simply false that \emph{all} surjections are split.
+In \cref{thm:no-higher-ac} we constructed a type family $Y:X\to \type$ such that $\prd{x:X} \brck{Y(x)}$ but $\neg \prd{x:X} Y(x)$;
+for any such family, the first projection $(\sm{x:X} Y(x)) \to X$ is a surjection that is not split.
+
+If $A$ and $B$ are sets, then by \cref{lem:equiv-iff-hprop}, $f$ is an embedding just when
+\begin{equation}
+  \prd{x,y:A} (\id[B]{f(x)}{f(y)}) \to (\id[A]xy).\label{eq:injective}
+\end{equation}
+In this case we say that $f$ is \define{injective},
+\indexsee{injective function}{function, injective}%
+\indexdef{function!injective}%
+or an \define{injection}.
+\indexsee{injection}{function, injective}%
+We avoid these word for types that are not sets, because they might be interpreted as~\eqref{eq:injective}, which is an ill-behaved notion for non-sets.
+It is also true that any function between sets is surjective if and only if it is an \emph{epimorphism} in a suitable sense, but this also fails for more general types, and surjectivity is generally the more important notion.
+
+\begin{thm}\label{thm:mono-surj-equiv}
+  A function $f:A\to B$ is an equivalence if and only if it is both surjective and an embedding.
+\end{thm}
+\begin{proof}
+  If $f$ is an equivalence, then each $\hfib f b$ is contractible, hence so is $\brck{\hfib f b}$, so $f$ is surjective.
+  And we showed in \cref{thm:paths-respects-equiv} that any equivalence is an embedding.
+
+  Conversely, suppose $f$ is a surjective embedding.
+  Let $b:B$; we show that $\sm{x:A}(f(x)=b)$ is contractible.
+  Since $f$ is surjective, there merely exists an $a:A$ such that $f(a)=b$.
+  Thus, the fiber of $f$ over $b$ is inhabited; it remains to show it is a mere proposition.
+  For this, suppose given $x,y:A$ with $p:f(x)=b$ and $q:f(y)=b$.
+  Then since $\apfunc f$ is an equivalence, there exists $r:x=y$ with $\apfunc f (r) = p \ct \opp q$.
+  However, using the characterization of paths in $\Sigma$-types, the latter equality rearranges to $\trans{r}{p} = q$.
+  Thus, together with $r$ it exhibits $(x,p) = (y,q)$ in the fiber of $f$ over $b$.
+\end{proof}
+
+\begin{cor}
+  For any $f:A\to B$ we have
+  \[ \isequiv(f) \eqvsym (\mathsf{isEmbedding}(f) \times \mathsf{isSurjective}(f)).\]
+\end{cor}
+\begin{proof}
+  Being a surjection and an embedding are both mere propositions; now apply \cref{lem:equiv-iff-hprop}.
+\end{proof}
+
+Of course, this cannot be used as a definition of ``equivalence'', since the definition of embeddings refers to equivalences.
+However, this characterization can still be useful; see \cref{sec:whitehead}.
+We will generalize it in \cref{cha:hlevels}.
+
+
+% \section{Fiberwise equivalences}
+\section{Closure properties of equivalences}
+\label{sec:equiv-closures}
+\label{sec:fiberwise-equivalences}
+\index{equivalence!properties of}%
+
+
+% We end this chapter by observing some important closure properties of equivalences.
+We have already seen in \cref{thm:equiv-eqrel} that equivalences are closed under composition.
+Furthermore, we have:
+
+\begin{thm}[The 2-out-of-3 property]\label{thm:two-out-of-three}
+  \index{2-out-of-3 property}%
+  Suppose $f:A\to B$ and $g:B\to C$.
+  If any two of $f$, $g$, and $g\circ f$ are equivalences, so is the third.
+\end{thm}
+\begin{proof}
+  If $g\circ f$ and $g$ are equivalences, then $\opp{(g\circ f)} \circ g$ is a quasi-inverse to $f$.
+  On the one hand, we have $\opp{(g\circ f)} \circ g \circ f \htpy \idfunc[A]$, while on the other we have
+  \begin{align*}
+    f \circ \opp{(g\circ f)} \circ g
+    &\htpy \opp g \circ g \circ f \circ \opp{(g\circ f)} \circ g\\
+    &\htpy \opp g \circ g\\
+    &\htpy \idfunc[B].
+  \end{align*}
+  Similarly, if $g\circ f$ and $f$ are equivalences, then $f\circ \opp{(g\circ f)}$ is a quasi-inverse to $g$.
+\end{proof}
+
+This is a standard closure condition on equivalences from homotopy theory.
+Also well-known is that they are closed under retracts, in the following sense.
+
+\index{retract!of a function|(defstyle}%
+
+\begin{defn}\label{defn:retract}
+A function $g:A\to B$ is said to be a \define{retract}
+of a function $f:X\to Y$ if there is a diagram
+\begin{equation*}
+  \xymatrix{
+    {A} \ar[r]^{s} \ar[d]_{g}
+    &
+    {X} \ar[r]^{r} \ar[d]_{f}
+    &
+    {A} \ar[d]^{g}
+    \\
+    {B} \ar[r]_{s'}
+    &
+    {Y} \ar[r]_{r'}
+    &
+    {B}
+  }
+\end{equation*}
+for which there are
+\begin{enumerate}
+\item a homotopy $R:r\circ s \htpy \idfunc[A]$.
+\item a homotopy $R':r'\circ s' \htpy\idfunc[B]$.
+\item a homotopy $L:f\circ s\htpy s'\circ g$.
+\item a homotopy $K:g\circ r\htpy r'\circ f$.
+\item for every $a:A$, a path $H(a)$ witnessing the commutativity of the square
+\begin{equation*}
+  \xymatrix@C=3pc{
+    {g(r(s(a)))} \ar@{=}[r]^-{K(s(a))} \ar@{=}[d]_{\ap g{R(a)}}
+    &
+    {r'(f(s(a)))} \ar@{=}[d]^{\ap{r'}{L(a)}}
+    \\
+    {g(a)} \ar@{=}[r]_-{\opp{R'(g(a))}}
+    &
+    {r'(s'(g(a)))}
+  }
+\end{equation*}
+\end{enumerate}
+\end{defn}
+
+Recall that in \cref{sec:contractibility} we defined what it means for a type to be a retract of another.
+This is a special case of the above definition where $B$ and $Y$ are $\unit$.
+Conversely, just as with contractibility, retractions of maps induce retractions of their fibers.
+
+\begin{lem}\label{lem:func_retract_to_fiber_retract}
+If a function $g:A\to B$ is a retract of a function $f:X\to Y$, then $\hfib{g}b$ is a retract of $\hfib{f}{s'(b)}$
+for every $b:B$, where $s':B\to Y$ is as in \cref{defn:retract}.
+\end{lem}
+
+\begin{proof}
+Suppose that $g:A\to B$ is a retract of $f:X\to Y$. Then for any $b:B$ we have the functions
+\begin{align*}
+\varphi_b &:\hfiber{g}b\to\hfib{f}{s'(b)}, &
+\varphi_b(a,p) & \defeq \pairr{s(a),L(a)\ct s'(p)},\\
+\psi_b &:\hfib{f}{s'(b)}\to\hfib{g}b, &
+\psi_b(x,q) &\defeq \pairr{r(x),K(x)\ct r'(q)\ct R'(b)}.
+\end{align*}
+Then we have $\psi_b(\varphi_b({a,p}))\equiv\pairr{r(s(a)),K(s(a))\ct r'(L(a)\ct s'(p))\ct R'(b)}$.
+We claim $\psi_b$ is a retraction with section $\varphi_b$ for all $b:B$, which is to say that for all $(a,p):\hfib g b$ we have $\psi_b(\varphi_b({a,p}))= \pairr{a,p}$.
+In other words, we want to show
+\begin{equation*}
+\prd{b:B}{a:A}{p:g(a)=b} \psi_b(\varphi_b({a,p}))= \pairr{a,p}.
+\end{equation*}
+By reordering the first two $\Pi$s and applying a version of \cref{thm:omit-contr}, this is equivalent to
+\begin{equation*}
+\prd{a:A}\psi_{g(a)}(\varphi_{g(a)}({a,\refl{g(a)}}))=\pairr{a,\refl{g(a)}}.
+\end{equation*}
+For any $a$, by \cref{thm:path-sigma}, this equality of pairs is equivalent to a pair of equalities. The first components are equal by $R(a):r(s(a))= a$, so we need only show
+\begin{equation*}
+\trans{R(a)}{K(s(a))\ct r'(L(a))\ct R'(g(a))} = \refl{g(a)}.
+\end{equation*}
+But this transportation computes as $\opp{g(R(a))}\ct K(s(a))\ct r'(L(a))\ct R'(g(a))$, so the required path is given by $H(a)$.
+\end{proof}
+
+\begin{thm}\label{thm:retract-equiv}
+  If $g$ is a retract of an equivalence $f$, then $g$ is also an equivalence.
+\end{thm}
+\begin{proof}
+  By \cref{lem:func_retract_to_fiber_retract}, every fiber of $g$ is a retract of a fiber of $f$.
+  Thus, by \cref{thm:retract-contr}, if the latter are all contractible, so are the former.
+\end{proof}
+
+\index{retract!of a function|)}%
+
+\index{fibration}%
+\index{total!space}%
+Finally, we show that fiberwise equivalences can be characterized in terms of equivalences of total spaces.
+To explain the terminology, recall from \cref{sec:fibrations} that a type family $P:A\to\type$ can be viewed as a fibration over $A$ with total space $\sm{x:A} P(x)$, the fibration being the projection $\proj1:\sm{x:A} P(x) \to A$.
+From this point of view, given two type families $P,Q:A\to\type$, we may refer to a function $f:\prd{x:A} (P(x)\to Q(x))$ as a \define{fiberwise map} or a \define{fiberwise transformation}.
+\indexsee{transformation!fiberwise}{fiberwise transformation}%
+\indexsee{function!fiberwise}{fiberwise transformation}%
+\index{fiberwise!transformation|(defstyle}%
+\indexsee{fiberwise!map}{fiberwise transformation}%
+\indexsee{map!fiberwise}{fiberwise transformation}
+Such a map induces a function on total spaces:
+
+\begin{defn}\label{defn:total-map}
+  Given type families $P,Q:A\to\type$ and a map $f:\prd{x:A} P(x)\to Q(x)$, we define
+  \begin{equation*}
+    \total f  \defeq \lam{w}\pairr{\proj{1}w,f(\proj{1}w,\proj{2}w)} : \sm{x:A}P(x)\to\sm{x:A}Q(x).
+  \end{equation*}
+\end{defn}
+
+\begin{thm}\label{fibwise-fiber-total-fiber-equiv}
+Suppose that $f$ is a fiberwise transformation between families $P$ and
+$Q$ over a type $A$ and let $x:A$ and $v:Q(x)$. Then we have an equivalence
+\begin{equation*}
+\eqv{\hfib{\total{f}}{\pairr{x,v}}}{\hfib{f(x)}{v}}.
+\end{equation*}
+\end{thm}
+\begin{proof}
+  We calculate:
+\begin{align}
+  \hfib{\total{f}}{\pairr{x,v}}
+  & \jdeq \sm{w:\sm{x:A}P(x)}\pairr{\proj{1}w,f(\proj{1}w,\proj{2}w)}=\pairr{x,v}
+  \notag \\
+  & \eqv{}{} \sm{a:A}{u:P(a)}\pairr{a,f(a,u)}=\pairr{x,v}
+  \tag{by~\cref{ex:sigma-assoc}} \\
+  & \eqv{}{} \sm{a:A}{u:P(a)}{p:a=x}\trans{p}{f(a,u)}=v
+  \tag{by \cref{thm:path-sigma}} \\
+  & \eqv{}{} \sm{a:A}{p:a=x}{u:P(a)}\trans{p}{f(a,u)}=v
+  \notag \\
+  & \eqv{}{} \sm{u:P(x)}f(x,u)=v
+  \tag{$*$}\label{eq:uses-sum-over-paths} \\
+  & \jdeq \hfib{f(x)}{v}. \notag
+\end{align}
+The equivalence~\eqref{eq:uses-sum-over-paths} follows from \cref{thm:omit-contr,thm:contr-paths,ex:sigma-assoc}.
+\end{proof}
+
+We say that a fiberwise transformation $f:\prd{x:A} P(x)\to Q(x)$ is a \define{fiberwise equivalence}%
+\indexdef{fiberwise!equivalence}%
+\indexdef{equivalence!fiberwise}
+if each $f(x):P(x) \to Q(x)$ is an equivalence.
+
+\begin{thm}\label{thm:total-fiber-equiv}
+Suppose that $f$ is a fiberwise transformation between families
+$P$ and $Q$ over a type $A$.
+Then $f$ is a fiberwise equivalence if and only if $\total{f}$ is an equivalence.
+\end{thm}
+
+\begin{proof}
+Let $f$, $P$, $Q$ and $A$ be as in the statement of the theorem.
+By \cref{fibwise-fiber-total-fiber-equiv} it follows for all
+$x:A$ and $v:Q(x)$ that
+$\hfib{\total{f}}{\pairr{x,v}}$ is contractible if and only if
+$\hfib{f(x)}{v}$ is contractible.
+Thus, $\hfib{\total{f}}{w}$ is contractible for all $w:\sm{x:A}Q(x)$ if and only if $\hfib{f(x)}{v}$ is contractible for all $x:A$ and $v:Q(x)$.
+\end{proof}
+
+\index{fiberwise!transformation|)}%
+
+
+\section{The object classifier}
+\label{sec:object-classification}
+
+In type theory we have a basic notion of \emph{family of types}, namely a function $B:A\to\type$.
+We have seen that such families behave somewhat like \emph{fibrations} in homotopy theory, with the fibration being the projection $\proj1:\sm{a:A} B(a) \to A$.
+A basic fact in homotopy theory is that every map is equivalent to a fibration.
+With univalence at our disposal, we can prove the same thing in type theory.
+
+\begin{lem}\label{thm:fiber-of-a-fibration}
+  For any type family $B:A\to\type$, the fiber of $\proj1:\sm{x:A} B(x) \to A$ over $a:A$ is equivalent to $B(a)$:
+  \[ \eqv{\hfib{\proj1}{a}}{B(a)} \]
+\end{lem}
+\begin{proof}
+  We have
+  \begin{align*}
+    \hfib{\proj1}{a} &\defeq \sm{u:\sm{x:A} B(x)} \proj1(u)=a\\
+    &\eqvsym \sm{x:A}{b:B(x)} (x=a)\\
+    &\eqvsym \sm{x:A}{p:x=a} B(x)\\
+    &\eqvsym B(a)
+  \end{align*}
+  using the left universal property of identity types.
+\end{proof}
+
+\begin{lem}\label{thm:total-space-of-the-fibers}
+  For any function $f:A\to B$, we have $\eqv{A}{\sm{b:B}\hfib{f}{b}}$.
+\end{lem}
+\begin{proof}
+  We have
+  \begin{align*}
+    \sm{b:B}\hfib{f}{b} &\defeq \sm{b:B}{a:A} (f(a)=b)\\
+    &\eqvsym \sm{a:A}{b:B} (f(a)=b)\\
+    &\eqvsym A
+  \end{align*}
+  using the fact that $\sm{b:B} (f(a)=b)$ is contractible.
+\end{proof}
+
+\begin{thm}\label{thm:nobject-classifier-appetizer}
+For any type $B$ there is an equivalence
+\begin{equation*}
+\chi:\Parens{\sm{A:\type} (A\to B)}\eqvsym (B\to\type).
+\end{equation*}
+\end{thm}
+\begin{proof}
+We have to construct quasi-inverses
+\begin{align*}
+\chi & : \Parens{\sm{A:\type} (A\to B)}\to B\to\type\\
+\psi & : (B\to\type)\to\Parens{\sm{A:\type} (A\to B)}.
+\end{align*}
+We define $\chi$ by $\chi((A,f),b)\defeq\hfiber{f}b$, and $\psi$ by $\psi(P)\defeq\Pairr{(\sm{b:B} P(b)),\proj1}$.
+Now we have to verify that $\chi\circ\psi\htpy\idfunc{}$ and that $\psi\circ\chi \htpy\idfunc{}$.
+\begin{enumerate}
+\item Let $P:B\to\type$.
+  By \cref{thm:fiber-of-a-fibration},
+$\hfiber{\proj1}{b}\eqvsym P(b)$ for any $b:B$, so it follows immediately
+that $P\htpy\chi(\psi(P))$.
+\item Let $f:A\to B$ be a function. We have to find a path
+\begin{equation*}
+\Pairr{\tsm{b:B} \hfiber{f}b,\,\proj1}=\pairr{A,f}.
+\end{equation*}
+First note that by \cref{thm:total-space-of-the-fibers}, we have
+$e:\sm{b:B} \hfiber{f}b\eqvsym A$ with $e(b,a,p)\defeq a$ and $e^{-1}(a)
+\defeq(f(a),a,\refl{f(a)})$.
+By \cref{thm:path-sigma}, it remains to show $\trans{(\ua(e))}{\proj1} = f$.
+But by the computation rule for univalence and~\eqref{eq:transport-arrow}, we have $\trans{(\ua(e))}{\proj1} = \proj1\circ e^{-1}$, and the definition of $e^{-1}$ immediately yields $\proj1 \circ e^{-1} \jdeq f$.\qedhere
+\end{enumerate}
+\end{proof}
+
+\noindent
+\indexdef{object!classifier}%
+\indexdef{classifier!object}%
+\index{.infinity1-topos@$(\infty,1)$-topos}%
+In particular, this implies that we have an \emph{object classifier} in the sense of higher topos theory.
+Recall from \cref{def:pointedtype} that $\pointed\type$ denotes the type $\sm{A:\type} A$ of pointed types.
+
+\begin{thm}\label{thm:object-classifier}
+Let $f:A\to B$ be a function. Then the diagram
+\begin{equation*}
+  \vcenter{\xymatrix{
+      A\ar[r]^-{\vartheta_f} \ar[d]_{f} &
+      \pointed{\type}\ar[d]^{\proj1}\\
+      B\ar[r]_{\chi_f} &
+      \type
+      }}
+\end{equation*}
+is a pullback\index{pullback} square (see \cref{ex:pullback}).
+Here the function $\vartheta_f$ is defined by
+\begin{equation*}
+ \lam{a} \pairr{\hfiber{f}{f(a)},\pairr{a,\refl{f(a)}}}.
+\end{equation*}
+\end{thm}
+\begin{proof}
+Note that we have the equivalences
+\begin{align*}
+A & \eqvsym \sm{b:B} \hfiber{f}b\\
+& \eqvsym \sm{b:B}{X:\type}{p:\hfiber{f}b= X} X\\
+& \eqvsym \sm{b:B}{X:\type}{x:X} \hfiber{f}b= X\\
+& \eqvsym \sm{b:B}{Y:\pointed{\type}} \hfiber{f}b = \proj1 Y\\
+& \jdeq B\times_{\type}\pointed{\type}
+\end{align*}
+which gives us a composite equivalence $e:A\eqvsym B\times_\type\pointed{\type}$.
+We may display the action of this composite equivalence step by step by
+\begin{align*}
+a & \mapsto \pairr{f(a),\; \pairr{a,\refl{f(a)}}}\\
+& \mapsto \pairr{f(a), \; \hfiber{f}{f(a)}, \; \refl{\hfiber{f}{f(a)}}, \; \pairr{a,\refl{f(a)}}}\\
+& \mapsto \pairr{f(a), \; \hfiber{f}{f(a)}, \; \pairr{a,\refl{f(a)}}, \; \refl{\hfiber{f}{f(a)}}}\\
+& \mapsto \pairr{f(a), \; \pairr{\hfiber{f}{f(a)}, \; \pairr{a,\refl{f(a)}}}, \; \refl{\hfiber{f}{f(a)}}}.
+\end{align*}
+Therefore, we get homotopies $f\htpy\proj1\circ e$ and $\vartheta_f\htpy \proj2\circ e$.
+\end{proof}
+
+
+
+\section{Univalence implies function extensionality}
+\label{sec:univalence-implies-funext}
+
+\index{function extensionality!proof from univalence}%
+In the last section of this chapter we include a proof that the univalence axiom implies function
+extensionality. Thus, in this section we work \emph{without} the function extensionality axiom.
+The proof consists of two steps. First we show
+in \cref{uatowfe} that the univalence
+axiom implies a weak form of function extensionality, defined in \cref{weakfunext} below. The
+principle of weak function extensionality in turn implies the usual function extensionality,
+and it does so without the univalence axiom (\cref{wfetofe}).
+
+\index{univalence axiom}%
+Let $\type$ be a universe; we will explicitly indicate where we assume that it is univalent.
+
+\begin{defn}\label{weakfunext}
+The \define{weak function extensionality principle}
+\indexdef{function extensionality!weak}%
+asserts that there is a function
+\begin{equation*}
+\Parens{\prd{x:A}\iscontr(P(x))} \to\iscontr\Parens{\prd{x:A}P(x)}
+\end{equation*}
+for any family $P:A\to\type$ of types over any type $A$.
+\end{defn}
+
+The following lemma is easy to prove using function extensionality; the point here is that it also follows from univalence without assuming function extensionality separately.
+
+\begin{lem} \label{UA-eqv-hom-eqv}
+Assuming $\type$ is univalent, for any $A,B,X:\type$ and any $e:\eqv{A}{B}$, there is an equivalence
+\begin{equation*}
+\eqv{(X\to A)}{(X\to B)}
+\end{equation*}
+of which the underlying map is given by post-composition with the underlying function of $e$.
+\end{lem}
+
+\begin{proof}
+  % Immediate by induction on $\eqv{}{}$ (see \cref{thm:equiv-induction}).
+  As in the proof of \cref{lem:qinv-autohtpy}, we may assume that $e = \idtoeqv(p)$ for some $p:A=B$.
+  Then by path induction, we may assume $p$ is $\refl{A}$, so that $e = \idfunc[A]$.
+  But in this case, post-composition with $e$ is the identity, hence an equivalence.
+\end{proof}
+
+\begin{cor}\label{contrfamtotalpostcompequiv}
+Let $P:A\to\type$ be a family of contractible types, i.e.\ \narrowequation{\prd{x:A}\iscontr(P(x)).}
+Then the projection $\proj{1}:(\sm{x:A}P(x))\to A$ is an equivalence. Assuming $\type$ is univalent, it follows immediately that post-composition with $\proj{1}$ gives an equivalence
+\begin{equation*}
+\alpha : \eqv{\Parens{A\to\sm{x:A}P(x)}}{(A\to A)}.
+\end{equation*}
+\end{cor}
+
+\begin{proof}
+  By \cref{thm:fiber-of-a-fibration}, for $\proj{1}:(\sm{x:A}P(x))\to A$ and $x:A$ we have an equivalence
+  \begin{equation*}
+    \eqv{\hfiber{\proj{1}}{x}}{P(x)}.
+  \end{equation*}
+  Therefore $\proj{1}$ is an equivalence whenever each $P(x)$ is contractible. The assertion is now a consequence of  \cref{UA-eqv-hom-eqv}.
+\end{proof}
+
+In particular, the homotopy fiber of the above equivalence at $\idfunc[A]$ is contractible. Therefore, we can show that univalence implies weak function extensionality by showing that the dependent function type $\prd{x:A}P(x)$ is a retract of $\hfiber{\alpha}{\idfunc[A]}$.
+
+\begin{thm}\label{uatowfe}
+In a univalent universe $\type$, suppose that $P:A\to\type$ is a family of contractible types
+and let $\alpha$ be the function of \cref{contrfamtotalpostcompequiv}.
+Then $\prd{x:A}P(x)$ is a retract of $\hfiber{\alpha}{\idfunc[A]}$. As a consequence, $\prd{x:A}P(x)$ is contractible. In other words, the univalence axiom implies the weak function extensionality principle.
+\end{thm}
+
+\begin{proof}
+Define the functions
+\begin{align*}
+  \varphi &: (\tprd{x:A}P(x))\to\hfiber{\alpha}{\idfunc[A]},\\
+  \varphi(f) &\defeq (\lam{x} (x,f(x)),\refl{\idfunc[A]}),
+\intertext{and}
+  \psi &: \hfiber{\alpha}{\idfunc[A]}\to \tprd{x:A}P(x), \\
+  \psi(g,p) &\defeq \lam{x} \trans {\happly (p,x)}{\proj{2} (g(x))}.
+\end{align*}
+Then $\psi(\varphi(f))=\lam{x} f(x)$, which is $f$, by the uniqueness principle for dependent function types.
+\end{proof}
+
+We now show that weak function extensionality implies the usual function extensionality.
+Recall from~\eqref{eq:happly} the function $\happly (f,g) : (f = g)\to(f\htpy g)$ which
+converts equality of functions to homotopy. In the proof that follows, the univalence
+axiom is not used.
+
+\begin{thm}\label{wfetofe}
+  \index{function extensionality}%
+Weak function extensionality implies the function extensionality \cref{axiom:funext}.
+\end{thm}
+
+\begin{proof}
+We want to show that
+\begin{equation*}
+\prd{A:\type}{P:A\to\type}{f,g:\prd{x:A}P(x)}\isequiv(\happly (f,g)).
+\end{equation*}
+Since a fiberwise map induces an equivalence on total spaces if and only if it is fiberwise an equivalence by \cref{thm:total-fiber-equiv}, it suffices to show that the function of type
+\begin{equation*}
+\Parens{\sm{g:\prd{x:A}P(x)}(f= g)} \to \sm{g:\prd{x:A}P(x)}(f\htpy g)
+\end{equation*}
+induced by $\lam{g:\prd{x:A}P(x)} \happly (f,g)$ is an equivalence.
+Since the type on the left is contractible by \cref{thm:contr-paths}, it suffices to show that the type on the right:
+\begin{equation}\label{eq:uatofesp}
+\sm{g:\prd{x:A}P(x)}\prd{x:A}f(x)= g(x)
+\end{equation}
+is contractible.
+Now \cref{thm:ttac} says that this is equivalent to
+\begin{equation}\label{eq:uatofeps}
+\prd{x:A}\sm{u:P(x)}f(x)= u.
+\end{equation}
+The proof of \cref{thm:ttac} uses function extensionality, but only for one of the composites.
+Thus, without assuming function extensionality, we can conclude that~\eqref{eq:uatofesp} is a retract\index{retract!of a type} of~\eqref{eq:uatofeps}.
+And~\eqref{eq:uatofeps} is a product of contractible types, which is contractible by the weak function extensionality principle; hence~\eqref{eq:uatofesp} is also contractible.
+\end{proof}
+
+\sectionNotes
+
+The fact that the space of continuous maps equipped with quasi-inverses has the wrong homotopy type to be the ``space of homotopy equivalences'' is well-known in algebraic topology.
+In that context, the ``space of homotopy equivalences'' $(\eqv AB)$ is usually defined simply as the subspace of the function space $(A\to B)$ consisting of the functions that are homotopy equivalences.
+In type theory, this would correspond most closely to $\sm{f:A\to B} \brck{\qinv(f)}$; see \cref{ex:brck-qinv}.
+
+The first definition of equivalence given in homotopy type theory was the one that we have called $\iscontr(f)$, which was due to Voevodsky.
+The possibility of the other definitions was subsequently observed by various people.
+The basic theorems about adjoint equivalences\index{adjoint!equivalence} such as \cref{lem:coh-equiv,thm:equiv-iso-adj} are adaptations of standard facts in higher category theory and homotopy theory.
+Using bi-invertibility as a definition of equivalences was suggested by Andr\'e Joyal.
+
+The properties of equivalences discussed in \cref{sec:mono-surj,sec:equiv-closures} are well-known in homotopy theory.
+Most of them were first proven in type theory by Voevodsky.
+
+The fact that every function is equivalent to a fibration is a standard fact in homotopy theory.
+The notion of object classifier
+\index{object!classifier}%
+\index{classifier!object}%
+in $(\infty,1)$-category
+\index{.infinity1-category@$(\infty,1)$-category}%
+theory (the categorical analogue of \cref{thm:nobject-classifier-appetizer}) is due to Rezk (see~\cite{Rezk05,lurie:higher-topoi}).
+
+Finally, the fact that univalence implies function extensionality (\cref{sec:univalence-implies-funext}) is due to Voevodsky.
+Our proof is a simplification of his.
+\cref{ex:funext-from-nondep} is also due to Voevodsky.
+
+\sectionExercises
+
+\begin{ex}\label{ex:two-sided-adjoint-equivalences}
+  Consider the type of ``two-sided adjoint equivalence\index{adjoint!equivalence} data'' for $f:A\to B$,
+  \begin{narrowmultline*}
+    \sm{g:B\to A}{\eta: g \circ f \htpy \idfunc[A]}{\epsilon:f \circ g \htpy \idfunc[B]}
+    \narrowbreak
+    \Parens{\prd{x:A} \map{f}{\eta x} = \epsilon(fx)} \times
+    \Parens{\prd{y:B} \map{g}{\epsilon y} = \eta(gy) }.
+  \end{narrowmultline*}
+  By \cref{lem:coh-equiv}, we know that if $f$ is an equivalence, then this type is inhabited.
+  Give a characterization of this type analogous to \cref{lem:qinv-autohtpy}.
+
+  Can you give an example showing that this type is not generally a mere proposition?
+  (This will be easier after \cref{cha:hits}.)
+\end{ex}
+
+\begin{ex}\label{ex:symmetric-equiv}
+  Show that for any $A,B:\UU$, the following type is equivalent to $\eqv A B$.
+  \begin{equation*}
+    \sm{R:A\to B\to \type}
+    \Parens{\prd{a:A} \iscontr\Parens{\sm{b:B} R(a,b)}} \times
+    \Parens{\prd{b:B} \iscontr\Parens{\sm{a:A} R(a,b)}}.
+  \end{equation*}
+  Can you extract from this a definition of a type satisfying the three desiderata of $\isequiv(f)$?
+\end{ex}
+
+\begin{ex} \label{ex:qinv-autohtpy-no-univalence}
+  Reformulate the proof of \cref{lem:qinv-autohtpy} without using univalence.
+\end{ex}
+
+\begin{ex}[The unstable octahedral axiom]\label{ex:unstable-octahedron}
+  \index{axiom!unstable octahedral}%
+  \index{octahedral axiom, unstable}%
+  Suppose $f:A\to B$ and $g:B\to C$ and $b:B$.
+  \begin{enumerate}
+  \item Show that there is a natural map $\hfib{g\circ f}{g(b)} \to \hfib{g}{g(b)}$ whose fiber over $(b,\refl{g(b)})$ is equivalent to $\hfib f b$.
+  \item Show that $\eqv{\hfib{g\circ f}{c}}{\sm{w:\hfib{g}{c}} \hfib f {\proj1 w}}$.
+  \end{enumerate}
+\end{ex}
+
+\begin{ex}\label{ex:2-out-of-6}
+  \index{2-out-of-6 property}%
+  Prove that equivalences satisfy the \emph{2-out-of-6 property}: given $f:A\to B$ and $g:B\to C$ and $h:C\to D$, if $g\circ f$ and $h\circ g$ are equivalences, so are $f$, $g$, $h$, and $h\circ g\circ f$.
+  Use this to give a higher-level proof of \cref{thm:paths-respects-equiv}.
+\end{ex}
+
+\begin{ex}\label{ex:qinv-univalence}
+  For $A,B:\UU$, define
+  \[ \mathsf{idtoqinv}_{A,B} :(A=B) \to \sm{f:A\to B}\qinv(f) \]
+  by path induction in the obvious way.
+  Let \textbf{\textsf{qinv}-univalence} denote the modified form of the univalence axiom which asserts that for all $A,B:\UU$ the function $\mathsf{idtoqinv}_{A,B}$ has a quasi-inverse.
+  \begin{enumerate}
+  \item Show that \qinv-univalence can be used instead of univalence in the proof of function extensionality in \cref{sec:univalence-implies-funext}.
+  \item Show that \qinv-univalence can be used instead of univalence in the proof of \cref{thm:qinv-notprop}.
+  \item Show that \qinv-univalence is inconsistent (i.e.\ allows construction of an inhabitant of $\emptyt$).
+    Thus, the use of a ``good'' version of $\isequiv$ is essential in the statement of univalence.
+  \end{enumerate}
+\end{ex}
+
+\begin{ex}\label{ex:embedding-cancellable}
+  Show that a function $f:A\to B$ is an embedding if and only if the following two conditions hold:
+  \begin{enumerate}
+  \item $f$ is \emph{left cancellable}, i.e.\ for any $x,y:A$, if $f(x)=f(y)$ then $x=y$.\label{item:ex:ec1}
+  \item For any $x:A$, the map $\apfunc f: \Omega(A,x) \to \Omega(B,f(x))$ is an equivalence.\label{item:ex:ec2}
+  \end{enumerate}
+  (In particular, if $A$ is a set, then $f$ is an embedding if and only if it is left-cancellable and $\Omega(B,f(x))$ is contractible for all $x:A$.)
+  Give examples to show that neither of~\ref{item:ex:ec1} or~\ref{item:ex:ec2} implies the other.
+\end{ex}
+
+\begin{ex}\label{ex:cancellable-from-bool}
+  Show that the type of left-cancellable functions $\bool\to B$ (see \cref{ex:embedding-cancellable}) is equivalent to $\sm{x,y:B}(x\neq y)$.
+  Give a similar explicit characterization of the type of embeddings $\bool\to B$.
+\end{ex}
+
+\begin{ex}\label{ex:funext-from-nondep}
+  The \textbf{na\"{i}ve non-dependent function extensionality axiom} says that for $A,B:\type$ and $f,g:A\to B$ there is a function $(\prd{x:A} f(x)=g(x)) \to (f=g)$.
+  \indexdef{function extensionality!non-dependent}%
+  Modify the argument of \cref{sec:univalence-implies-funext} to show that this axiom implies the full function extensionality axiom (\cref{axiom:funext}).
+\end{ex}
+
+% Local Variables:
+% TeX-master: "hott-online"
+% End:

errata.tex

@@ -0,0 +1,987 @@
+% This is the errata document for the homotopy type theory book.
+
+% This file supports two book sizes:
+% - Letter size (8.5" x 11")
+% - US Trade size (6" x 9")
+%
+% To activate one or the other, uncomment the appropriate font size in
+% the documentclass below, and then one of the two page geometry incantations
+%
+% NOTE: The 6" x 9" format is only experimental. It will break the
+% title page, for example.
+
+\PassOptionsToPackage{table}{xcolor}
+
+% DOCUMENT CLASS
+\documentclass[
+%
+%10pt % for US Trade 6" x 9" book
+%
+11pt % for Letter size book
+]{article}
+\usepackage{etex} % We're running out of registers and dimensions, or some such
+
+\newcounter{chapter}            % So that macros.tex doesn't choke
+
+% PAGE GEOMETRY
+%
+% Uncomment one of these
+
+% We make the page 40pt taller than the standard LaTeX book.
+
+% OPTION 1: Letter
+\usepackage[papersize={8.5in,11in},
+            twoside,
+            includehead,
+            top=1in,
+            bottom=1in,
+            inner=0.75in,
+            outer=1.0in,
+            bindingoffset=0.35in]{geometry}
+
+% OPTION 2: US Trade
+% \usepackage[papersize={6in,9in},
+%             twoside,
+%             includehead,
+%             top=0.75in,
+%             bottom=0.75in,
+%             inner=0.5in,
+%             outer=0.75in,
+%             bindingoffset=0.35in]{geometry}
+
+% HYPERLINKING AND PDF METADATA
+
+\usepackage[pagebackref,
+            colorlinks,
+            citecolor=darkgreen,
+            linkcolor=darkgreen,
+            unicode,
+            pdfauthor={Univalent Foundations Program},
+            pdftitle={Homotopy Type Theory: Univalent Foundations of Mathematics},
+            pdfsubject={Mathematics},
+            pdfkeywords={type theory, homotopy theory, univalence axiom}]{hyperref}
+
+% OTHER PACKAGES
+
+% Use this package and stick \layout somewhere in the text to see
+% page margins, text size and width etc. Useful for debugging page format.
+%\usepackage{layout}
+
+%%% Because Germans have umlauts and Slavs have even stranger ways of mangling letters
+\usepackage[utf8]{inputenc}
+
+%%% For table {tab:theorems}
+\usepackage{pifont}
+
+%%% Multi-Columns for long lists of names
+\usepackage{multicol}
+
+%%% Set the fonts
+\usepackage{mathpazo}
+\usepackage[scaled=0.95]{helvet}
+\usepackage{courier}
+\linespread{1.05} % Palatino looks better with this
+
+\usepackage{graphicx}
+\DeclareGraphicsExtensions{.png}
+\input{bmpsize-hack} % for bounding boxes in dvi mode
+\usepackage{comment}
+
+\usepackage{wallpaper} % For the background image on the cover page
+
+\usepackage{fancyhdr} % To set headers and footers
+
+\usepackage{nextpage} % So we can jump to odd-numbered pages
+
+\usepackage{amssymb,amsmath,amsthm,stmaryrd,mathrsfs,wasysym}
+\usepackage{enumitem,mathtools,xspace}
+\usepackage{xcolor} % For colored cells in tables we need \cellcolor
+\usepackage{booktabs} % For nice tables
+\usepackage{array} % For nice tables
+\usepackage{supertabular} % For index of symbols
+\definecolor{darkgreen}{rgb}{0,0.45,0}
+\usepackage{aliascnt}
+\usepackage[capitalize]{cleveref}
+\usepackage[all,2cell]{xy}
+\UseAllTwocells
+\usepackage{braket} % used for \setof{ ... } macro
+\usepackage{tikz}
+\usetikzlibrary{decorations.pathmorphing}
+
+\usepackage{etoolbox}           % hacking commands for TOC
+
+\usepackage{mathpartir}         % for formal.tex appendix, section 3
+
+\usepackage[numbered]{bookmark} % add chapter/section numbers to the toc in the pdf metadata
+
+\input{macros}
+
+%%%% Indexing
+\usepackage{makeidx}
+\makeindex
+
+%%%% Header and footers
+\pagestyle{fancyplain}
+\setlength{\headheight}{15pt}
+\renewcommand{\sectionmark}[1]{\markright{\textsc{\thesection\ #1}}}
+
+\lhead[\fancyplain{}{{\thepage}}]%
+      {\fancyplain{}{\nouppercase{\rightmark}}}
+\rhead[\fancyplain{}{\nouppercase{\leftmark}}]%
+      {\fancyplain{}{\thepage}}
+\cfoot[]{}
+\lfoot[]{}
+\rfoot[]{}
+
+%%%% Chapter & part style
+\usepackage{titlesec}
+\titleformat{\part}[display]{\fontsize{40}{40}\fontseries{m}\fontshape{sc}\selectfont}{\hfil\partname\ \Roman{part}}{20pt}{\fontsize{60}{60}\fontseries{b}\fontshape{sc}\selectfont\hfil}
+\titleformat{\chapter}[display]{\fontsize{23}{25}\fontseries{m}\fontshape{it}\selectfont}{\chaptertitlename\ \thechapter}{20pt}{\fontsize{35}{35}\fontseries{b}\fontshape{n}\selectfont}
+
+\input{main.labels}
+\input{version.tex}
+
+\usepackage{longtable}
+
+\title{Errata for the HoTT Book, first edition%
+%% VERSION MARKER
+}
+
+\begin{document}
+\maketitle
+
+For the benefit of all readers, the available PDF and printed copies of the book are being updated on a rolling basis with minor corrections and clarifications as we receive them. Every copy has a version marker that can be found on the title page and is of the form "first-edition-XX-gYYYYYYY", where XX is a natural number and YYYYYYY is the git commit hash that uniquely identifies the exact version. Higher values of XX indicate more recent copies.
+
+Below is a list of corrections and clarifications that have been made
+%% BEGIN STARTPOINT
+so far
+%% END STARTPOINT
+(except for trivial formatting and spacing changes), along with the version marker in which they were first made.
+This list is current as of \today\ and version marker ``\OPTversion''.
+
+While the page numbering may differ between copies with different version markers (and indeed, already differs between the letter/A4 and printed/ebook copies with the same version marker), we promise that the numbering of chapters, sections, theorems, and equations will remain constant, and no new mathematical content will be added, unless and until there is a second edition.
+
+\noindent
+\begin{longtable}{llp{10.5cm}}
+  \textbf{Location} & \textbf{Fixed in} & \textbf{Change} \\ \hline \endhead
+%% BEGIN ERRATA
+  %
+  % Chapter 1
+  %
+  \cref{sec:types-vs-sets}
+  & 182-gb29ea2f
+  & Change notation $a\jdeq_A b$ to $a\jdeq b : A$, to match that used in \cref{cha:rules}.
+  (Neither are used anywhere else in the book.)\\
+  %
+  \cref{sec:types-vs-sets}
+  & 154-g42698c2
+  & Clarify that algorithmic decidability of judgmental equality is only meta-theoretic.\\
+  %
+  \cref{sec:types-vs-sets}
+  & 154-gac9b226
+  & Mention notation $a=b=c=d$ to mean ``$a=b$ and $b=c$ and $c=d$, hence $a=d$'', possibly including judgmental equalities.\\
+  %
+  \cref{sec:universes}
+  & 42-g4bc5cc2
+  & Cumulativity means some elements do not have unique types, the index $i$ on $\UU_i$ is not an internal natural number, and typical ambiguity must be justified by reinserting indices.\\
+  %
+  \cref{sec:universes,sec:pi-types}
+  & 42-ga34b313
+  & Explain that we can't define $\Fin$ and $\fmax$ yet where we first mention them.\\
+  %
+  \cref{sec:pi-types}
+  & 165-g0ad2aba
+  & Add $\mathsf{swap}$ as another example of a polymorphic function, and discuss the use of subscripts and implicit arguments to dependent functions.\\
+  %
+  \cref{rmk:introducing-new-concepts}
+  & 80-g8f95fa5
+  & In the discussion of formation rules, the dependent function type example should be $\prd{x:A} B(x)$.\\
+  %
+  \cref{sec:finite-product-types}
+  & 51-g67e86db
+  & Better explanation of recursion on product types, why it is justified, and how it relates to the uniqueness principle.\\
+  %
+  \cref{sec:sigma-types}
+  & 2-gbe277a8
+  & In the types of $g$ and $\ind{\sm{x:A}B(x)}$, there is a $\prd{a:A}{b:B(x)}$ in which $x$ should be $a$.\\
+  %
+  \cref{sec:sigma-types}
+  & 27-gd0bfa0d
+  & At two places in the definition of $\ac$, $R(a,\fst(g(x)))$ should be $R(x,\fst(g(x)))$.\\
+  %
+  \cref{sec:sigma-types}
+  & 125-g7fdadbf
+  & When substituting $\lam{x} \fst(g(x))$ for $f$ while verifying that $\ac$ is well-typed, the left side of the judgmental equality should be $\tprd{x:A} R(x,\fst(g(x)))$, not $\tprd{x:A} R(x,\fst(f(x)))$.\\
+  %
+  \cref{sec:coproduct-types}
+  & 30-g264d934
+  & In two displayed equations, $f(\inl(b))$ should be $f(\inr(b))$.\\
+  %
+  Theorem \ref{thm:allbool-trueorfalse} % NB: We have to write out "Theorem" instead of using \cref here, since in the (post-erratum) version this label no longer denotes a Theorem.
+  & 391-g1ce619a
+  & This should not be called a ``Theorem'', since we have not yet introduced what that means.
+  Instead it should say ``We construct an element of\dots''.\\
+  %
+  \cref{sec:type-booleans}
+  & 125-g433f87e
+  & In the definition of binary products in terms of $\bool$, the definitions of $\fst(p)$ and $\snd(p)$ should be switched to match the order of arguments to $\rec\bool$ and $\ind\bool$.\\
+  \cref{sec:pat}
+  & 111-g1e868fa
+  & When translating English to type theory, ``unnamed variables'' are unnamed in English but must be named in type theory.\\
+  %
+  \cref{sec:identity-types}
+  & 154-g4ef49f7
+  & Emphasize that path induction, like all other induction principles, defines a \emph{specified} function.\\
+  %
+  \cref{sec:identity-types}
+  & 1373-g142de42
+  & In the second proof that based path induction implies path induction, the observation should be that $f$ can be obtained as an instance of $\indid{A}$, not $\indidb{A}$.\\
+  %
+  \cref{sec:identity-types}
+  & 244-gd58529d
+  & In proof that path induction implies based path induction, $D(x,y,p)$ should be written $\prd{C : \prd{z:A} (\id[A]{x}{z}) \to \UU} \left( \cdots \right)$ so the type of $C$ matches the premise of based path induction. \\
+  %
+  \cref{rmk:the-only-path-is-refl}
+  & 563-g3286941
+  & The facts that any $(x,y,p): \sm{x,y:A}(\id{x}{y})$ is equal to $(x,x,\refl{x})$, and that any $(y,p):\sm{y:A}(\id[A]{a}{y})$ is equal to $(a,\refl{a})$, can be proven by path induction and based path induction respectively.\\
+  %
+  \cref{ex:iterator}
+  & 78-gcce4dc0
+  & The second defining equation of $\ite$ should have right-hand side $c_s(\ite(C,c_0,c_s,n))$.\\
+  %
+  \cref{ex:iterator}
+  & 293-g4663bfe
+  & The defining equations of the recursor derived from the iterator only hold propositionally, and require the induction principle to prove.\\
+  %
+  \cref{ex:prod-via-bool}
+  & 229-ged891f3
+  & This exercise requires function extensionality (\cref{sec:compute-pi}).\\
+  %
+  \cref{ex:nat-semiring}
+  & 450-g7f38c9a
+  & This exercise requires symmetry and transitivity of equality, \cref{lem:opp,lem:concat}.\\
+  %
+  \cref{ex:ackermann}
+  & 110-gfe4641b
+  & To match the usual Ackermann--P\'eter function, the second displayed equation should be $\ack(\suc(m),0) \jdeq \ack(m,1)$.\\
+  %
+  % Chapter 2
+  %
+  \cref{cha:basics}
+  & 239-gaf3d682
+  & In the chapter introduction, clarify that topological homotopies between paths must be endpoint-preserving.\\
+  %
+  \cref{lem:opp}
+  & 166-g37b78ef
+  & Add remarks before and after the proof about how a theorem's statement and proof should be interpreted as exhibiting an element of some type.\\
+  %
+  \cref{lem:concat}
+  & 374-g0bc0908
+  & In the penultimate display in the first proof, $d(x,z,q)$ should be simply $d$.\\
+  %
+  \cref{thm:omg}
+  & 750-g91b7348
+  & In the first proofs of~\ref{item:omg1}--\ref{item:omg3}, $\indid{A}(D,d,p)$ should be $\indid{A}(D,d,x,y,p)$.\\
+  %
+  \cref{sec:equality}
+  & 435-gee0b28a
+  & In the third paragraph after \cref{lem:concat}, $p\ct\refl{x}\jdeq p$ should be $p\ct\refl{y}\jdeq p$.\\
+  %
+  \cref{sec:equality}
+  & 165-g18642ca
+  & Mention that the notation $a=b=c=d$, and its displayed variant, indicate concatenation of paths.\\
+  %
+  \cref{sec:equality}
+  & 253-gdd47c75
+  & \cref{thm:omg}\ref{item:omg4} justifies writing $p\ct q \ct r$ and so on.\\
+  %
+  \cref{thm:EckmannHilton}
+  & 253-gdd47c75
+  & The induction defining $\alpha\rightwhisker r$ has defining equation $\alpha \rightwhisker \refl{b} \jdeq \opp{\mathsf{ru}_p} \ct \alpha \ct \mathsf{ru}_q$, with $\mathsf{ru}_p$ the right unit law.
+  For $\alpha\hct\beta = \alpha\ct\beta$ to be well-typed, we assume $p\jdeq q \jdeq r \jdeq s\jdeq \refl{a}$ and use $\mathsf{ru}_{\refl{a}} = \refl{\refl{a}}$ and its dual.
+  Proving $\alpha\hct\beta = \alpha\hct'\beta$ requires induction not only on $\alpha$ and $\beta$ but then on the two remaining 1-paths.
+  After the proof, remark that we trust the reader to construct such operations from now on.\\
+  %
+  \cref{def:loopspace}
+  & 233-gc3fb777
+  & The three displays should be $\defeq$'s rather than $=$'s.\\
+  %
+  \cref{sec:functors}
+  & 336-g8ff8a7f
+  & In the type of $\apfunc{f}$ towards the end of the first proof of \cref{lem:map}, $g(x)$ should be $f(y)$.\\
+  %
+  \cref{sec:fibrations}
+  & 154-g4ef49f7
+  & Emphasize that unlike fibrations in classical homotopy theory, type families come with a \emph{specified} path-lifting function.\\
+  %
+  \cref{sec:fibrations}
+  & 343-g6efd724
+  & The functions \cref{eq:ap-to-apd} and \cref{eq:apd-to-ap} are obtained by concatenating with $\transconst Bp{f(x)}$ and its inverse, respectively.\\
+  %
+  \cref{cor:hom-fg}
+  & 253-gdd47c75
+  & Canceling $H(x)$ may be done by whiskering with $\opp{(H(x))}$.\\
+  %
+  \cref{sec:basics-equivalences}
+  & 1171-gab3c0aa
+  & In the proof that $\isequiv(f) \to \qinv (f)$, the definition of $\gamma$ should be $\gamma(x) \defeq \opp{\beta(g(x))} \ct \ap{h}{\alpha(x)}$.\\
+  %
+  \cref{sec:compute-cartprod}
+  & 74-g9896e32
+  & In the type of $\pairpath$ (just after the proof of \cref{thm:path-prod}), the second factor in the domain should be $\id{\proj{2}(x)}{\proj{2}(y)}$.\\
+  %
+  \cref{sec:compute-cartprod}
+  & 895-g96db894
+  & In the displayed equation just before \cref{thm:trans-prod}, $\pairct(p\ct q, r, p'\ct q', r)$ should be $\pairct(p\ct q, r, p'\ct q', r')$ and $\pairct(p, q\ct r, p', q'\ct r)$ should be $\pairct(p, q\ct r, p', q'\ct r')$ (two primes on $r$s are missing).\\
+  %
+  \cref{thm:trans-prod}
+  & 349-gc7fd9d8
+  & The path is in $A(w)\times B(w)$, not $A(y)\times B(y)$.\\
+  %
+  \cref{thm:trans-prod}
+  & 76-ga42354c
+  & The third displayed judgmental equality in the proof should be $\transfib{B}{p}{\proj{2}x} \jdeq \proj2x$.\\
+  %
+  \cref{thm:path-sigma}
+  & 507-g8f10eda
+  & In the proof, the equation $f(g(\refl{},\refl{}))=\refl{}$ should be $f (g(\refl{w_1},\refl{w_2})) = (\refl{w_1},\refl{w_2})$.\\
+  %
+  \cref{sec:compute-pi}
+  & 269-g3880fe2
+  & The paragraph preceding the definition of $\transfib{\Pi_A(B)}{p}{f}$ (before \cref{eq:transport-arrow-families}) misstated the (already given) type of $p$.\\
+  %
+  \cref{axiom:univalence}
+  & 992-gc4a5314
+  & The axiom should read ``For any $A,B:\type$, the function~\eqref{eq:uidtoeqv} is an equivalence.  The display $\eqv{(\id[\type]{A}{B})}{(\eqv A B)}$ should be deduced afterwards, outside the axiom statement.\\
+  %
+  \cref{thm:paths-respects-equiv}
+  & 310-gd5fa240
+  & The second half of the proof is more involved than the first.
+  It follows abstractly using the 2-out-of-6 property (\cref{ex:2-out-of-6}), or more concretely by concatenating with $\opp{\alpha_{f(a)}} \ct {\alpha_{f(a)}}$ on each side and then repeatedly using naturality and functoriality.\\
+  %
+  \cref{sec:compute-paths}
+  & 236-g32be999
+  & The second display after the proof of \cref{thm:paths-respects-equiv} should be $\prd{x:A} (\id[f(x)=g(x)] {\happly(p)(x)}{\happly(q)(x)})$.\\
+  %
+  \cref{thm:transport-path}
+  & 628-g1bd8602
+  & The sentence preceding the theorem suggests that it follows from \cref{cor:transport-path-prepost,thm:transport-compose}, but actually it requires a separate path induction.\\
+  %
+  \cref{thm:transport-path}
+  & 704-g70c069e
+  & The sentence after the theorem should say that $\apfunc{(x \mapsto c)}$ is $p \mapsto\refl{c}$, not $\refl{c}$.\\
+  %
+  \cref{thm:transport-path2}
+  & 364-g3c47534
+  & The right-hand side of the displayed equality should be $\opp{(\apdfunc{f}(p))} \ct \apfunc{(\transfibf{B}{p})}(q) \ct \apdfunc{g}(p)$.\\
+  %
+  \cref{sec:compute-coprod}
+  & 101-g645f763
+  & In \cref{thm:path-coprod} and the preceding paragraph, in the equivalence $\eqv{(\inl(a)=x)}{\code(x)}$, the variable $a$ should be $a_0$. \\
+  %
+  \cref{sec:compute-coprod}
+  & 370-g114db82
+  & In the two displays after the proof of \cref{thm:path-coprod}, the terms should be $\encode(\inl(a), {\blank})$ and $\encode(\inr(b), {\blank})$.\\
+  %
+  \cref{sec:equality-semigroups}
+  & 261-g4ccda0a
+  & In the first displayed pair of equations, the type of $p_2$ should be $\transfib{\semigroupstrsym}{p_1}{(m,a)} = {(m',a')}$.\\
+  %
+  \cref{sec:equality-semigroups}
+  & 402-g2297ecb
+  & The right hand side of the last displayed equation should be $m'(e(x_1),e(x_2))$.\\
+  %
+  \cref{sec:universal-properties}
+  & 305-g64685f1
+  & In the discussion of universal properties for product types and $\Sigma$-types surrounding \cref{eq:sigma-lump}, the phrases ``left-to-right'' and ``right-to-left'' should be switched.\\
+  %
+  \cref{cha:basics} Notes
+  & 379-ga57eab2
+  & It should be mentioned that Hofmann and Streicher (1998) proposed an axiom similar to univalence, which is correct (and equivalent to univalence) for a universe of 1-types.\\
+  %
+  % Chapter 3
+  %
+  \cref{eq:english-ac}
+  & 1193-g54b20e3
+  & The domain of $g:\prd{x:A} A(x)$ should be $X$.\\
+  %
+  \cref{subsec:prop-subsets}
+  & 86-g39feab1
+  & The definition of subset containment should say $\prd{x:A}(P(x)\rightarrow Q(x))$, not $\fall{x:A}(P(x)\Rightarrow Q(x))$, as the latter notation has not been introduced yet.\\
+  %
+  \cref{subsec:logic-hprop}
+  & 37-g0bd66c8
+  & In the discussion for $\Sigma$-types in the last paragraph, $A$ is an arbitrary type.\\
+  %
+  \cref{thm:retract-contr}
+  & 95-gce0131f
+  & In the proof, $p$ should be $r$ to match the preceding definition of retraction.\\
+  %
+  \cref{ex:lem-brck}
+  & 1162-ga97cb70
+  & Should be to show that $\neg\neg A$ satisfies the recursion principle of $\brck{A}$ but with only a propositional computation rule.\\
+  %
+  % Chapter 4
+  %
+  \cref{lem:qinv-autohtpy}
+  & 87-g693e9b9
+  & At the end of the proof, \cref{thm:contr-paths} should be cited as the reason why $\sm{g:A\to A} (g = \idfunc[A])$ is contractible.\\
+  %
+  \cref{thm:equiv-iso-adj}
+  & 275-g8ea9f71
+  & In the proof, the path concatenations in the definitions of $\epsilon'$ and $\tau$ were written in reverse order.\\
+  %
+  \cref{thm:equiv-iso-adj}
+  & 1043-gcfce4d7
+  & In the proof, the type of $\tau(a)$ should be $\ap{f}{\eta(a)}=\opp{\epsilon(f(g(f(a))))}\ct (\ap{f}{\eta(g(f(a)))}\ct \epsilon(f(a)))$, instead of $\opp{\epsilon(f(g(f(a))))}\ct (\ap{f}{\eta(g(f(a)))}\ct \epsilon(f(a)))=\ap{f}{\eta(a)}$.\\
+  %
+  \cref{lem:coh-hprop}
+  & 296-ge3dc076
+  & In the proof, $\id[\hfib{f}{fx}]{(fgx,\epsilon(fx))}{(x,\refl{fx})}$ should be $\id[\hfib{f}{fx}]{(gfx,\epsilon(fx))}{(x,\refl{fx})}$.\\
+  %
+  \cref{thm:equiv-biinv-isequiv}
+  & 272-gfd47093
+  & At the end of the proof, the equivalence follows from the fact that $\ishae(f)$, not $\iscontr(f)$, is a mere proposition. \\
+  %
+  \cref{thm:lequiv-contr-hae}
+  & 299-g85b729b
+  & In the proof, $\lcoh{f}{g}{\epsilon}$ should be $\rcoh{f}{g}{\epsilon}$, and the final displayed equation should have $\proj{2}$ applied to both occurrences of $P(fx)$.\\
+  %
+  \cref{lem:func_retract_to_fiber_retract}
+  & 265-g64000fb
+  & The path concatenations in the definitions of $\varphi_b$ and $\psi_b$ (and subsequent equations) are reversed, and each $f(a)$ in the next two displayed equations should be $g(a)$.\\
+  %
+  \cref{fibwise-fiber-total-fiber-equiv}
+  & 275-g84ab032
+  & The first equivalence in the proof is not by~\eqref{eq:sigma-lump} but by \cref{ex:sigma-assoc}.\\
+  %
+  \cref{fibwise-fiber-total-fiber-equiv}
+  & 202-g775a3f0
+  & The last equivalence in the proof is not by~\eqref{eq:path-lump} but by \cref{thm:omit-contr,thm:contr-paths,ex:sigma-assoc}.\\
+  %
+  \cref{thm:nobject-classifier-appetizer}
+  & 205-gf9fe386
+  & In the proof, $e\cdot \proj1$ should be $\trans{(\ua(e))}{\proj1}$.  Also, explain its computation better.\\
+  %
+  \cref{sec:univalence-implies-funext}
+  & 114-gaba76c8
+  & The point of \cref{UA-eqv-hom-eqv} is that it follows from univalence without assuming function extensionality separately.\\
+  %
+  \cref{contrfamtotalpostcompequiv}
+  & 484-g2ce1249
+  & In the statement, ``precomposition'' should be ``post-composition''.\\
+  %
+  \cref{uatowfe}
+  & 746-g4d540d6
+  & In the definition of $\psi$ in the proof, transport has to be along $\happly(p,x)$ instead of along $p$.\\
+  %
+  \cref{ex:symmetric-equiv}
+  & 358-g9543064
+  & The text should be ``Show that for any $A,B:\UU$, the following type is equivalent to $\eqv A B$.  Can you extract from this a definition of a type satisfying the three desiderata of $\isequiv(f)$?''\\
+  %
+  \cref{thm:object-classifier}
+  & 44-g14eb86b
+  & To maintain consistency, one line was added at the end of the computation of the composite equivalence in the proof.\\
+  %
+  \cref{thm:fiber-of-a-fibration}
+  & 44-g14eb86b
+  & The type of $\proj{1}$ should be $(\sm{x:A}P(x))\to A$.\\
+  %
+  % Chapter 5
+  %
+  \cref{sec:appetizer-univalence}
+  & 706-ged2c765
+  & In the proof that $\eqv{\nat}{\natp}$, the definitions of $f$ and $g$ should be $\rec\nat(\natp, \; \zerop, \;  \lamu{n:\nat} \sucp)$ and $\rec\natp(\nat, \; 0, \;  \lamu{n:\natp} \suc)$ respectively.\\
+  %
+  \cref{sec:w-types}
+  & 125-g433f87e
+  & In the definition of $\natw$, use $\bfalse$ for $0$ and $\btrue$ for $\suc$, to match the ordering of $\bfalse$ and $\btrue$ in \cref{sec:type-booleans}.\\
+  %
+  \cref{sec:w-types}
+  & 551-g82b74bf
+  & The definitions of $\natw$ and $\lst A$ as $\w$-types should be $\wtype{b:\bool} \rec\bool(\bbU,\emptyt,\unit,b)$ and $\wtype{x: \unit + A} \rec{\unit + A}(\bbU,  \emptyt,  \lamu{a:A} \unit, x)$.\\
+  %
+  \cref{sec:w-types}
+  & 218-g42219cb
+  & In the description of the constructor $\supp$, its second argument is more clearly written as $f : B(a) \to \wtype{x:A} B(x)$.\\
+  %
+  \cref{sec:w-types}
+  & 525-gb1957b8
+  & In the computation rule, the recursive call to $\rec{}$ is missing an argument.
+  It should read $\rec{\wtype{x:A} B(x)}(E,e,\supp(a,f)) \jdeq e(a,f,\big(\lamu{b:B(a)} \rec{\wtype{x:A} B(x)}(E,e,f(b))\big))$.\\
+  %
+  \cref{sec:w-types}
+  & 570-g6ec04c3
+  & In the verification that $\dbl$ computes as expected, $e_t$ should be $e_0$ and $e_f$ should be $e_1$.\\
+  %
+  \cref{sec:initial-alg}
+  & 554-g9b2a34b
+  & The definition of the type of $\w$-homomorphisms (just before \cref{thm:w-hinit}) should read $\whom_{A,B}((C, s_C),(D,s_D)) \defeq \sm{f : C \to D} \prd{a:A}{h:B(a)\to C} \id{f(s_C(a,h))}{s_D(a, f\circ h)}$.\\
+  %
+  \cref{sec:htpy-inductive}
+  & 917-gd6960ad
+  & In the first paragraph, the definition of $\natw$ should be $\wtype{b:\bool} \rec\bool(\bbU,\emptyt,\unit,b)$.\\
+  %
+  \cref{sec:htpy-inductive}
+  & 608-g6af101f
+  & In the computation rule for homotopy $\w$-types, the left-hand side should be $\rec{\wtypeh{x:A} B(x)}(E,e,\supp(a,f))$.\\
+  %
+  \cref{sec:htpy-inductive}
+  & 1261-g4cdab82
+  & In the commutative diagram preceding the definition of $\w_s(A, B)$, all occurrences of $x$ should be replaced with $a$.\\
+  %
+  \cref{sec:htpy-inductive}
+  & 1261-g4cdab82
+  & In the definition of $\w_s(A,B)$, $\alpha(\supp(x,f))$ should be $\alpha(\supp(a,f))$, and $\prd{a,f}$ should be inserted after $\sm\alpha$.\\
+  %
+  \cref{eq:example-comp}
+  & 912-g04d3fb6
+  & In the preceding sentence, $\delta:d$ should be $\delta:D$.\\
+  %
+  \cref{sec:generalizations}
+  & 908-g4b2eb10
+  & The second two constructors of $\mathsf{paritynat}$ should be $\mathsf{esucc} : \mathsf{paritynat}(\btrue) \to \mathsf{paritynat}(\bfalse)$ and $\mathsf{osucc} : \mathsf{paritynat}(\bfalse) \to \mathsf{paritynat}(\btrue)$.\\
+  %
+  \cref{thm:identity-systems}
+  & 139-gd5c5d01
+  & In the proof of \ref{item:identity-systems4}$\Rightarrow$\ref{item:identity-systems1}, the type of $D'$ should be $(\sm{b:A} R(b)) \to \type$.\\
+  %
+  \cref{ex:same-recurrence-not-defeq}
+  & 622-ga0bd007
+  & The two functions should satisfy the same recurrence judgmentally.\\
+  %
+  \cref{ex:one-function-two-recurrences}
+  & 622-ga0bd007
+  & The function should satisfy both recurrences judgmentally.\\
+  %
+  \cref{sec:identity-systems}
+  & 171-gdc4966e
+  & The subscript of $\refl A : a=_A a$ should be $a$, i.e. $\refl a$.\\
+  %
+  % Chapter 6
+  %
+  \cref{sec:dependent-paths}
+  & 54-gd4a47c2
+  & Soon after \cref{rmk:defid}, the phrase ``An element $b:P(\base)$ in the fiber over the constructor $\base:\nat$'' should say $\base:\Sn^1$.\\
+  %
+  \cref{thm:uniqueness-for-functions-on-S1}
+  & 423-gf763ae1
+  & \cref{thm:transport-path,thm:dpath-path} are needed to put $q$ in the form required by the induction principle.\\
+  %
+  \cref{thm:interval-funext}
+  & 417-g4aa6a15
+  & Added \cref{ex:funext-from-interval}: the function constructed in \cref{thm:interval-funext} is actually an inverse to $\happly$, so that the full function extensionality axiom follows from an interval type.\\
+  %
+  \cref{thm:S1-autohtpy}
+  & 625-g950efa9
+  & In the second paragraph of the proof, the appeal to function extensionality should be omitted.\\
+  %
+  \cref{sec:circle}
+  & 327-g7cbe31c
+  & In the first sentence after the proof of \cref{thm:apd2}, ``$P:\Sn^2\to P$'' should be ``$P:\Sn^2\to\type$''.\\
+  %
+  \cref{sec:circle}
+  & 1039-g30da4c6
+  & In the sentence after the proof of \cref{thm:apd2}, the type family in which $s$ is a dependent path should be $\lam{p} \dpath P p b b$ instead of $P$.\\
+  %
+  \cref{sec:cell-complexes}
+  & 289-gdefeb8c
+  & In the induction principle for the torus, the types of $p'$ and $q'$ should be $\dpath P p {b'} {b'}$ and $\dpath P q b b$ respectively.\\
+  %
+  \cref{sec:hubs-spokes}
+  & 289-gdefeb8c
+  & In the induction principle for the torus, the types of $p'$ and $q'$ should be $\dpath P p {b'} {b'}$ and $\dpath P q b b$ respectively.\\
+  %
+  \cref{sec:hittruncations}
+  & 468-g5472874
+  & The induction principle for $\brck{A}$ should conclude $f(\bproj a)\jdeq g(a)$, not $f(\bproj a)\jdeq a$.  And in the hypotheses of the induction principle for $\trunc0 A$ and in the proof of \cref{thm:trunc0-ind}, $v:\dpath{B}{u(x,y,p,q)}{p}{q}$ should instead be $v:\dpath{B}{u(x,y,p,q)}{r}{s}$.\\
+  %
+  \cref{sec:hittruncations}
+  & 860-gc7d862c
+  & In the penultimate paragraph, the ``unobjectionable'' constructor for $\trunc0 A$ should begin ``For every $f:S\to \trunc0 A$'', not ``For every $f:S\to A$''.\\
+  %
+  \cref{thm:quotient-ump}
+  & 961-gde36592
+  & The first sentence of the second paragraph of the proof should end with $g(x) = \overline{g\circ q}(x)$.\\
+  %
+  \cref{lem:quotient-when-canonical-representatives}
+  & 514-g18ade45
+  & Instead of ``is the set-quotient of $A$ by $\eqr$'', the statement should say ``satisfies the universal property of the set-quotient of $A$ by~$\eqr$, and hence is equivalent to it''.
+  In the proof, the second displayed equation should be $e'(g, s) (x,p) \defeq g(x)$.
+  The fourth displayed equation should be $e(e'(g, s)) \jdeq e(g \circ \proj{1}) \jdeq (g \circ \proj{1} \circ q, {\nameless})$, the fifth should be $g(\proj{1}(q(x))) \jdeq g(r(x)) = g(x)$, and the proof should conclude with ``$g$ respects $\eqr$ by the assumption $s$''.\\
+  %
+  \cref{thm:sign-induction}
+  & 535-g0a9abfe
+  & The ``computation rules'' satisfied by $f$ are only propositional equalities.
+  Also, the proof requires transport across a few unmentioned equivalences.\\
+  %
+  \cref{thm:looptothe}
+  & 535-g0a9abfe
+  & The defining clauses should use $\defid$ rather than $\defeq$ (see the erratum for \cref{thm:sign-induction}).
+  Also, the first clause should say $\refl{a}$ rather than $\refl{\base}$.\\
+  %
+  \cref{thm:transport-is-given}
+  & 682-g3af5dbe
+  & Three occurrences of $P$ in the statement should be $B$.\\
+  %
+  \cref{thm:flattening-cp}
+  & 457-g411ec6d
+  & The right-hand side of the displayed equation in the proof should be $(\cc(g(b)),D(b)(y))$.\\
+  %
+  \cref{thm:flattening-cp}
+  & 961-gde36592
+  & After the display we should have $\pp(b):\cc(f(b))=\cc(g(b))$.\\
+  %
+  \cref{sec:flattening}
+  & 519-gc99a54c
+  & $f$ denotes a map $B\to A$ in this section and should not be re-used for functions defined by induction on $\sm{w:W} P(w)$; we may use $k$ instead.
+  Thus $f$ should be $k$ in the last sentence of \cref{thm:flattening-rect}; the first sentence of its proof; the second and third sentences of the paragraph after its proof; the last sentence of \cref{thm:flattening-rectnd}; the first, second, and last sentences of its proof; throughout the statement and proof of \cref{thm:ap-sigma-rect-path-pair}; the statement of \cref{thm:flattening-rectnd-beta-ppt}; and the second sentence of its proof.\\
+  %
+  \cref{thm:flattening-rect}
+  & 537-gdf3b51d
+  & In the display after the definition of $q$, the transport in the first line should be with respect to $x\mapsto Q(\cct'(g(b),x))$, and in the second line the subscript of $\apfunc{}$ should be $x\mapsto \cct'(g(b),x)$.\\
+  %
+  \cref{thm:flattening-rect}
+  & 961-gde36592
+  & The subscript of $\apfunc{}$ should also be $x\mapsto \cct'(g(b),x)$ in the third, fourth, and fifth displays.
+  In the fourth and fifth displays, the path-concatenations should be in the other order.
+  And in the fifth display, $\refl{g(b)}$ should be $\refl{\cc(g(b))}$.\\
+  %
+  \cref{thm:flattening-rectnd-beta-ppt}
+  & 961-gde36592
+  & Both occurrence of the function $f$ should be replaced with $g$ in the
+  final two steps of the calculation within the proof.\\
+  %
+  \cref{thm:ap-sigma-rect-path-pair}
+  & 501-ge895f81
+  & Both occurrences of $P$ in the statement should be $Y$, and both occurrences of $Q$ in the proof should be $Z$.\\
+  %
+  % Chapter 7
+  %
+  \cref{thm:h-level-retracts}
+  & 180-gb672a4d
+  & In the last displayed equation of the proof, $q$ should be $r$.\\
+  %
+  \cref{thm:isaprop-isofhlevel}
+  & 101-g713f48c
+  & The base case in the proof is just \cref{thm:isprop-iscontr}.\\
+  %
+  \cref{sec:truncations}
+  & 480-gdc84050
+  & The third paragraph is wrong: in contrast to \cref{rmk:spokes-no-hub}, it \emph{would} actually work to define $\trunc nA$ omitting the hub point.\\
+  %
+  \cref{thm:h-set-refrel-in-paths-sets}
+  & 1131-gc1748fa
+  & In the second paragraph of the first proof, the codomain of the function $f(x,x)$ should be $\id[X]xx$, not $\id[X]xy$.\\
+  %
+  \cref{lem:hedberg-helper}
+  & 644-g627c0a8
+  & In the proof of the lemma, ``If $x$ is $\inr(f)$'' should be ``If $x$ is $\inr(t)$''.\\
+  %
+  \cref{thm:path-truncation}
+  & 412-gb9582fc
+  & In the proof, \encode and \decode should be switched.\\
+  %
+  \cref{lem:nconnected_postcomp_variation}
+  & 801-g01922a8
+  & The converse direction is false unless $Q$ is fiberwise merely inhabited.  Also, the occurrences of $\ap f p$ and $\ap f {\proj 2 w}$ in the proof should be just $p$ and $\proj 2 w$, respectively.\\
+  %
+  \cref{lem:connected-map-equiv-truncation}
+  & 367-g1c8c07e
+  & In the proof that the first composite is the identity, all occurrences of $y$ should be $f(x)$.\\
+  %
+  \cref{thm:modal-char}
+  & 658-g016f3a4
+  & In the second paragraph of the proof, the first two occurrences of $\proj2$ (but not the third) should be $\proj1$.\\
+  %
+  \cref{ex:s2-colim-unit}
+  & 101-ga366be2
+  & ``entires'' should be ``entirely''.\\
+  %
+  \cref{ex:s2-colim-unit}
+  & 683-g8941e50
+  & This exercise needs more precise definitions of ``diagram'' and ``colimit''.\\
+  %
+  \cref{ex:acnm}
+  & 1074-gcd42187
+  & $\choice{\infty,\infty}$ is not \cref{thm:ttac}, but the identity function.\\
+  %
+  \cref{ex:acnm}
+  & 603-ge113e08
+  & The penultimate sentence should ask ``Is $\choice{n,m}$ consistent with univalence for any $m\ge 0$ and any $n$?''.\\
+  %
+  % Chapter 8
+  %
+  \cref{lem:s1-encode-decode}
+  & 535-g0a9abfe
+  & The proof by induction on $n:\Z$ is justified by \cref{thm:sign-induction}, not \cref{thm:looptothe}.\\
+  %
+  \cref{thm:iscontr-s1cover}
+  & 535-g0a9abfe
+  & The clauses defining $q_z$ should use $\defid$ rather than $\defeq$ (see the erratum for \cref{thm:sign-induction}).\\
+  %
+  \cref{thm:suspension-increases-connectedness}
+  & 1062-gf3bfeae
+  & In the proof, $E$ is not $(n + 1)$-connected but $(n + 1)$-truncated.\\
+  %
+  \cref{thm:fiber-of-the-fiber}
+  & 1181-g3e51973
+  & In the proof, $(x:A)$ should be $(x:X)$.\\
+  %
+  \cref{thm:les}
+  & 33-g628d81b
+  & In the proof, $\trunc0g\circ\trunc0f$ should be $\trunc0f\circ\trunc0g$, and similarly for $g\circ f$.
+  Also, $g(t)=w'$ should be $\tproj0{g(t)}=w'$.
+  Finally, $\tproj0{(w,p)}:\tproj0{\hfib{f}{z_0}}$ should be $\tproj0{(w,p)}:\trunc{0}{\hfib{f}{z_0}}$.\\
+  %
+  \cref{thm:conn-pik}
+  & 1023-gf188aeb
+  & The proof requires a separate argument for $k=0$.\\
+  %
+  \cref{thm:hopf-fibration}
+  & 256-g9e6fcb8
+  & The phrase ``whose fibers are $\Sn^1$'' should be ``whose fiber over the basepoint is $\Sn ^1$''.
+  The same change should be made in \cref{ex:HopfJr,ex:SuperHopf}.\\
+  %
+  \cref{lem:fibration-over-pushout}
+  & 1062-gf3bfeae
+  & In the definition of ${E^{\mathrm{tot}}}'$ in the proof, $e_C$ should be $e_X$.\\
+  %
+  \cref{thm:conn-trunc-variable-ind}
+  & 396-g868335b
+  & In the proof, the function $k$ should have type $\prd{a:A} P(f(a))$.
+  It should also be named $\ell$, to avoid confusion with the integer $k$.\\
+  %
+  \cref{thm:freudcode}
+  & 87-g3f977b2
+  & In the second displayed equation in the proof, $\merid(x_1)$ should be $\opp{\merid(x_1)}$.\\
+  %
+  \cref{thm:wedge-connectivity}
+  & 1203-g7464bf1
+  & The type family $P$ defined in the proof should instead be called $Q$, to avoid clashes with the type family $P$ assumed in the statement.\\
+  %
+  \cref{thm:wedge-connectivity}
+  & 399-g8897c94
+  & In the last sentence of the proof, ``$(n-1)$-connected'' should be ``$(n-1)$-truncated''.\\
+  %
+  \cref{thm:freudlemma}
+  & 88-g0c0be67
+  & The type of $m$ should be $a_1=a_2$, the second display should begin with $C(a_1,\transfib{B}{\opp m}{b})$, and the proof should say ``we may assume $a_2$ is $a_1$ and $m$ is $\refl{a_1}$''.\\
+  %
+  \cref{sec:freudenthal}
+  & 165-gd5584c6
+  & In~\eqref{eq:freudcompute1}, $r''$ should be $r'$, the end point of $r$ should be $\transfib{B}{\opp{\merid(x_0)}}{q}$, and obtaining $r'$ requires also identifying this with $q \ct \opp{\merid(x_0)}$.
+  Similarly, in~\eqref{eq:freudcompute2}, the end point of $r$ should be $\transfib{B}{\opp{\merid(x_1)}}{q}$.\\
+  %
+  \cref{sec:freudenthal}
+  & 474-g5289470
+  & $\pi_3(\Sn^2)=\Z$ should be stated as \cref{thm:pi3s2}, following from \cref{cor:pis2-hopf,thm:pinsn}.\\
+  %
+  \cref{thm:whiteheadn}
+  & 1092-ge3b8b71
+  & After applying the induction hypothesis, it additionally needs to be checked that for every path $p : a = a$ the map $\pi_k(\apfunc f):\pi_k(x = x,p) \to \pi_k(f(x) = f(x),\apfunc f(p))$ is a bijection. \\
+  %
+  \cref{sec:general-encode-decode}
+  & 1154-g301662b
+  & In the strengthening of condition (iii) from \cref{lem:encode-decode-loop}, the right side should read just ``$c$'' instead of ``$c.a$''.\\
+  %
+  % Chapter 9
+  %
+  \cref{ct:gaunt}
+  & 1307-gfe63517
+  & Stating that every isomorphism is an identity is not very accurate (consider the discrete category on the interval type): a more accurate statement is that every automorphism is an identity arrow. Notice that for precategories, this property must be combined with skeletality for the equivalence to hold.\\
+  %
+  \cref{ct:functor}
+  & 807-gebec78b
+  & In \cref{ct:functor:comp}, it should read ``$\hom_A(b,c)$'' instead of ``$\hom_B(b,c)$''.\\
+  %
+  \cref{sec:equivalences}
+  & 1218-gcb6ba30
+  & Just before \cref{ct:essentially-surjective}, it should say ``However, if $A$ is not a category'' instead of ``However, if $B$ is not a category''.\\
+  %
+  \cref{ct:yoneda}
+  & 971-g6096085
+  & The sequence of equations at the end of the proof should begin with $\alpha_{a'}(f) = \alpha_{a'} (\y a_{a,a'}(f)(1_a))$, and thereafter the subscripts should remain $a,a'$ rather than $a',a$.\\
+  %
+  \cref{ct:sig}
+  & 897-g94fb722
+  & In~\ref{item:sigcmp}, ``if $f:\hom_X(x,y)$'' should be ``if $f:\hom_X(x,y)$ and $g:\hom_X(y,z)$''.\\
+  %
+  \cref{sec:sip}
+  & 1111-g3332a31
+  & The type of objects $A_0$ of the precategory $A$ of $(P,H)$-structures should be defined as $\sm{x:X_0} Px$, not $\sm{x:X} Px$.\\
+  %
+  \cref{cha:category-theory}
+  & 966-g04374f5
+  & The first sentence after \cref{ct:cat-weq-eq} should begin ``Therefore, if a precategory $A$ admits a weak equivalence functor $A\to \widehat{A}$ \emph{into a category}\dots''.\\
+  %
+  \cref{thm:rezk-completion}
+  & 313-g8ee79db
+  & In the second proof, the third constructor of $\widehat A_0$ is unneeded; it follows from the fourth constructor and path induction.
+  In the fifth constructor, $j(g)\ct j(f)$ should be $j(f)\ct j(g)$, and similarly throughout the proof.
+  Finally, for consistency, the 1-truncation constructor should be included explicitly (this was intended to be implied by "higher inductive 1-type").\\
+  %
+  \cref{cha:category-theory} Notes
+  & 379-ga57eab2
+  & It should be mentioned that Hofmann and Streicher (1998) also considered this definition of category.\\
+  %
+  % Chapter 10
+  %
+  \cref{card:semiring}
+  & 1303-ga530d97
+  & The equation $\cd{B}\times\cd{A} \jdeq \cd{B\times A}$ in the proof should be $\cd{B}\cdot\cd{A} \jdeq \cd{B\times A}$.\\
+  %
+  \cref{thm:wfmin}
+  & 1290-g4101ad3
+  & In the proof, the second sentence of the second paragraph should have ``$s(a'):\acc(a')$'' rather than ``$s(a'):\acc(a)$''.\\
+  %
+  \cref{thm:ordord}
+  & 140-g55de417
+  & The second sentence of the proof should say ``By well-founded induction on $A$, suppose $\ordsl A b$ is accessible for all $b<a$''.\\
+  %
+  \cref{thm:ordunion}
+  & 140-gd7f8960
+  & The statement should say $X:\UU$ rather than $X:\UU_\UU$.\\
+  %
+  \cref{thm:wellorder}
+  & 140-gcca0bcf
+  & The penultimate sentence of the proof should say ``if $a<b$ and $b<c$'' rather than ``if $a<b$ and $a<c$''.\\
+  %
+  \cref{thm:wop}
+  & 871-g85bcd11
+  & The statement of~\ref{item:wop1} should end with $Y:\powerp X$, not $Y:\power X$.\\
+  %
+  \cref{sec:cumulative-hierarchy}
+  & 753-gc87ce23
+  & The second clause in the induction principle for $V$ should say ``Verify that if $f : A \to V$ and $g : B \to V$ satisfy~\eqref{eq:V-path}, then $\dpath{P}{q}{h(\vset(A,f))}{h(\vset(B,g))}$, where $q$ is the path arising from the second constructor of $V$ and~\eqref{eq:V-path}, assuming inductively that $\dpath{P}{p}{h(f(a))}{h(g(b))}$ whenever $p:f(a)=g(b)$.''\\
+  %
+  \cref{sec:cumulative-hierarchy}
+  & 706-ged2c765
+  & The proof that membership is well-defined should end with ``hence $x = g(b)$ and $x \in \vset(B,g)$.''\\
+  %
+  \cref{sec:cumulative-hierarchy}
+  & 1056-g4060c2b
+  & In the definition of $V$-set, the notation $v \in V$ should be $v:V$.\\
+  %
+  \cref{thm:VisCST}
+  & 708-g6f53189
+  & In the pairing axiom, the pair class should be denoted $\{u, v\}$, not $u\cup v$.\\
+  %
+  \cref{thm:VisCST}
+  & 723-g9cf5b44
+  & The replacement axiom should be given $x : V$ (not $a : V$) and the displayed class should be $\setof{ y | \exis{z : V} z \in x \land y = r(z)}$.
+  Its proof should begin ``let $C$ denote the class in question.''\\
+  %
+  \cref{thm:VisCST}
+  & 706-ged2c765
+  & In the proof of the function set axiom, ``the types of elements $[u] \mono V$ and $[u] \mono V$'' should be ``the types of members $[u] \mono V$ and $[v] \mono V$.''\\
+  %
+  \cref{ex:strong-collection}
+  & 1053-ge13dd65
+  & Extra parentheses around $\fall{x\in v}\exis{y} R(x,y)$ are needed to make the formula unambiguous.\\
+  %
+  \cref{ex:choice-cumulative-hierarchy-choice}
+  & 1053-ge13dd65
+  & Extra parentheses around $\fall{y\in x}\exis{z\in V} z\in y$ are needed to make the formula unambiguous.\\
+  %
+  \cref{ex:choice-cumulative-hierarchy-choice}
+  & 1056-g4060c2b
+  & The notation $\in V$ should be $:V$.\\
+  %
+  % Chapter 11
+  %
+  \cref{dedekind-in-cut-as-le}
+  & 165-gb002a64
+  & The statement should say ``For all $x : \RD$ and $q : \Q$, $L_x(q) \Leftrightarrow (q < x)$ and $U_x(q)
+  \Leftrightarrow (x < q)$''.\\
+  %
+  \cref{RD-inverse-apart-0}
+  & 165-g179b359
+  & In the proof, the sentence beginning ``From $0<ac$ it follows'' should be replaced by ``From $0 < a c$ and $0 < b c$ it follows
+  that $a$, $b$, and $c$ are either all positive or all negative.
+  Hence either $0 < a < x$ or $x < b < 0$, so that $x \apart 0$''.\\
+  %
+  \cref{RD-inverse-apart-0}
+  & 1384-gc9ada3f
+  & In the proof of the theorem, the definition of $x^{-1}$ should be changed as follows:
+  $L_{x^{-1}}(q) \defeq (q > 0) \Rightarrow \exis{r : \Q} U_x(r) \land (q r < 1)$ and $U_{x^{-1}}(q) \defeq (q > 0) \land \exis{r : \Q} L_x(r) \land (q r > 1)$ for positive $x$,
+  and $L_{x^{-1}}(q) \defeq (q < 0) \land \exis{r : \Q} U_x(r) \land (q r > 1)$ and $U_{x^{-1}}(q) \defeq (q < 0) \Rightarrow \exis{r : \Q} L_x(r) \land (q r < 1)$ for negative $x$. \\
+  %
+  \cref{sec:RD-cauchy-complete}
+  & 832-g0cb658e
+  & In the second paragraph, at ``From this we get'', the universal quantification should be over~$\delta$ as well.\\
+  %
+  \cref{sec:constr-cauchy-reals}
+  & 53-g7d3a5fa
+  & In the last paragraph of this section, ``$\rclim(\rcrat \circ x \circ m)$'' should be ``$\rclim(\rcrat \circ x \circ M)$''.\\
+  %
+  \cref{sec:induct-recurs-cauchy}
+  & 1209-g3e5ad94
+  & In the statement of $(\RC,\closesym)$-recursion, ``$f(x) : A$'' should be ``$f(\rclim(x)) : A$''.\\
+  %
+  \cref{defn:RC-approx}
+  & 1069-g3b333d5
+  & In the description of openness of $\approx$, ``$\exis{\epsilon : \Qp}$'' should be ``$\exis{\delta : \Qp}$''.\\
+  %
+  \cref{lem:untruncated-linearity-reals-coincide}
+  & 87-g82b27c3
+  & \eqref{eq:untruncated-linearity} should be $c:\prd{q, r : \Q} (q < r) \to (q < x) + (x < r)$, and therefore the use of $c$ in the proof should be $c(s,t)$ rather than $c(x,s,t)$.\\
+  %
+  \cref{analysis-interval-ctb}
+  & 1270-g3f17b85
+  & In the proof, $n : \N$ should be $k : \N$. And the range of $i$ should be $0 \leq i \leq k$. Also in the last equation, $r(\lim x) = \ell$ should be $\lim x = \ell$.\\
+  %
+  \cref{ctb-uniformly-continuous-sup}
+  & 61-gce4e391
+  & In the proof, $|f(x) - f(y_i) < \epsilon$ should be $|f(x) - f(y_i)| < \epsilon$.\\
+  %
+  \cref{defn:inductive-cover}
+  & 57-g671b000
+  & In (\cref{defn:inductive-cover-interval-1}), the order of $r$ and $s$ should be flipped on the right-hand side: $(r, s)$ should be $(s, r)$.\\
+  %
+  \cref{sec:surreals}
+  & 1189-ga9c35f0
+  & The inductive case of $\iota_{\Q_D}$ should be defined as $\iota_{\Q_D}(a/2^n) \defeq \surr{\iota_{\Q_D}(a/2^n - 1/2^n)}{\iota_{\Q_D}(a/2^n + 1/2^n)}$.\\
+  %
+  \cref{eg:surreal-addition}
+  & 636-g827e7ea
+  & In the first bullet point, to prove $x^L+z < x+z$ requires a $\NO$-induction on $z$, since only when $z$ is defined by a cut can we say that $x^L+z$ is a left option of $x+z$.\\
+  %
+  \cref{ex:mean-value-theorem}
+  & 222-g3453cf1
+  & This is the intermediate value theorem, not the mean value theorem.\\
+  %
+  \cref{eg:surreal-addition}
+  & 980-ge9d0398
+  & For the codomain of the outer recursion, the conditions should be $(x<y) \to (g(x)<g(y))$ and $(x\le y) \to (g(x)\le g(y))$.  In the first bullet of the verification that inequalities are preserved, the outer inductive hypotheses give non-strict inequalities $x^L+y \le x^L+z$ and $x^R+ y \le x^R+z$, and no additional $\NO$-induction on $z$ is required (it is already known to be defined by a cut).\\
+  %
+  \cref{eg:surreal-addition}
+  & 980-ge9d0398
+  & The verification that Conway's definition of $x+y$ is a surreal number (i.e.\ all its left options are $<$ all its right options) was omitted.  This requires turning the inner recursion into an inner induction with codomain a varying subset of $\NO$, as in \cref{defn:No-codes}.\\
+  %
+  % Appendix A
+  %
+  \cref{cha:rules}
+  & 165-g76db618
+  & After the introduction of the judgment ``$\wfctx{\Gamma}$'' in the Preliminaries, the sentence beginning ``Therefore, if $\oftp\Gamma aA$, \dots'' should say instead ``In particular, therefore, if $\oftp\Gamma aA$, \dots''.\\
+  %
+  \cref{subsec:contexts}
+  & 64-g7c2312e
+  & Clarify the distinction between typing judgments and context well-formedness judgments, and
+  remove the $\vdash$ from the notation for the latter.\\
+  %
+  \cref{sec:more-formal-sigma}
+  & 26-gcd691e8
+  & In $\Sigma$-\rcomp\ and the following paragraph, $y.C$ should be $z.C$, and ``we bind \dots $y$ in $C$'' should likewise say $z$.\\
+  %
+  \cref{sec:more-formal-unit}
+  & 338-g4e1c688
+  & The $c$ argument in the eliminator for $\unit$ (in the $\unit$-\relim\ and $\unit$-\rcomp\ rules) should not bind a variable of type $\unit$.\\
+  %
+  \cref{sec:more-formal-identity}
+  & 578-ga4b94a5
+  & The unbased eliminator for the identity type should be named $\indid{A}$, not $\indidb{A}$.\\
+%% END ERRATA
+\end{longtable}
+
+\end{document}

filter-errata

@@ -0,0 +1,87 @@
+#!/usr/bin/python
+
+import re
+import sys
+
+if len(sys.argv) != 2:
+    print "Usage: myerrata versionmarker"
+    exit(1)
+
+# Version number we're being asked about
+currentversion = sys.argv[1]
+currentnumber = int(currentversion.split('-')[0])
+
+print "Filtering errata for version marker " + currentversion + "..."
+
+# Some regexps
+commentre = re.compile('^\s*%')
+versionre = re.compile('^\s*&\s*([0-9]+)-g[0-9a-f]{7}')
+
+# Old and new errata files
+errata = open("errata.tex",'r')
+new = ""
+
+# Move forward until the title
+line = errata.readline()
+while line != "%% VERSION MARKER\n":
+    new += line
+    line = errata.readline()
+
+# Discard the comment
+# Insert the version marker in the title
+new += "\\\\since version " + currentversion + "\n"
+
+# Move forward to the description
+line = errata.readline()
+while line != "%% BEGIN STARTPOINT\n":
+    new += line
+    line = errata.readline()
+
+# Insert the version marker
+new += "since version marker " + currentversion + "\n"
+
+# Discard the "so far"
+line = errata.readline()
+while line != "%% END STARTPOINT\n":
+    line = errata.readline()
+
+# Now get up to the actual errata
+line = errata.readline()
+while line != "%% BEGIN ERRATA\n":
+    new += line
+    line = errata.readline()
+
+# Parse each erratum and decide whether to include it
+while line != "%% END ERRATA\n":
+    # Skip comments
+    while commentre.search(line):
+        new += line
+        line = errata.readline()
+    # Now get the erratum, parsing the version number when we see it
+    ver = float('inf')
+    erratum = ''
+    while not commentre.search(line):
+        erratum += line
+        vmatch = versionre.search(line)
+        if vmatch:
+            ver = int(vmatch.group(1))
+        line = errata.readline()
+    # If it applies to us, put it in
+    if ver > currentnumber:
+        new += erratum
+
+# Finally, put the rest in.
+while line:
+    new += line
+    line = errata.readline()
+
+errata.close()
+
+# New errata file
+newfilename = "errata-since-" + currentversion + ".tex"
+
+print "Writing filtered errata to " + newfilename + "."
+
+newfile = open(newfilename,'w')
+newfile.write(new)
+newfile.close()

formal.tex

@@ -0,0 +1,1259 @@
+% !TeX root = hott-online.tex
+
+\titleformat{\chapter}[display]{\fontsize{23}{25}\fontseries{m}\fontshape{it}\selectfont}{\chaptertitlename}{20pt}{\fontsize{35}{35}\fontseries{b}\fontshape{n}\selectfont}
+\chapter{Formal type theory}
+\label{cha:rules}
+
+\index{formal!type theory|(}%
+\index{type theory!formal|(}%
+\index{rules of type theory|(}%
+
+Just as one can develop mathematics in set theory without explicitly using the axioms of Zermelo--Fraenkel set theory, 
+in this book we have developed mathematics in univalent foundations without explicitly referring to a formal
+system of homotopy type theory. Nevertheless, it is important to \emph{have} a
+precise description of homotopy type theory as a formal system in order to, for example,
+%
+\begin{itemize}
+\item state and prove its metatheoretic properties, including logical
+consistency,
+\item construct models, e.g.\  in simplicial sets, model categories, higher toposes,
+etc., and
+\item implement it in proof assistants like \Coq or \Agda.
+  \index{proof!assistant}
+\end{itemize}
+%
+Even the logical consistency\index{consistency} of homotopy type theory, namely that in the empty context there is no term $a:\emptyt$, is not obvious: if we had erroneously
+chosen a definition of equivalence for which $\eqv{\emptyt}{\unit}$, then
+univalence would imply that $\emptyt$ has an element, since $\unit$ does.
+Nor is it obvious that, for example, our definition of $\Sn^1$ as a higher
+inductive type yields a type which behaves like the ordinary circle.
+
+There are two aspects of type theory which we must pin down before addressing
+such questions. Recall from the Introduction that type theory
+comprises a set of rules specifying when the judgments $a:A$ and $a\jdeq a':A$
+hold --- for example, products are characterized by the rule that whenever $a:A$
+and $b:B$, $(a,b):A\times B$. To make this precise, we must first define
+precisely the syntax of terms --- the objects $a,a',A,\dots$ which these judgments
+relate; then, we must define precisely the judgments and their rules of
+inference --- the manner in which judgments can be derived from other judgments.
+
+In this appendix, we present two formulations of Martin-L\"{o}f type
+theory, and of the extensions that constitute homotopy type theory.
+The first presentation (\cref{sec:syntax-informally}) describes the syntax of
+terms and the forms of judgments as an extension of the untyped
+$\lambda$-calculus, while leaving the rules of inference informal.
+The second (\cref{sec:syntax-more-formally}) defines the terms, judgments,
+and rules of inference inductively in the style of natural deduction, as
+is customary in much type-theoretic literature.
+
+\section*{Preliminaries}
+\label{sec:formal-prelim}
+
+
+In \cref{cha:typetheory}, we presented the two basic \define{judgments}
+\index{judgment}
+of type theory. The first, $a:A$, asserts that a term $a$ has type $A$. The second,
+$a\jdeq b:A$, states that the two terms $a$ and $b$ are \define{judgmentally
+equal}%
+\index{equality!judgmental}
+\index{judgmental equality}
+at type $A$. These judgments are inductively defined by a set of
+inference rules described in \cref{sec:syntax-more-formally}.
+
+To construct an element $a$ of a type $A$ is to derive $a:A$; in the book, we
+give informal arguments which describe the construction of $a$, but formally,
+one must specify a precise term $a$ and a full derivation that $a:A$.
+
+However, the main difference between the presentation of type theory in the book
+and in this appendix is that here judgments are explicitly
+formulated in an ambient \define{context},
+\index{context}
+or list of assumptions, of the form
+\[
+  x_1:A_1, x_2:A_2,\dots,x_n:A_n.
+\]
+An element $x_i : A_i$ of the context expresses the assumption that the
+variable
+\index{variable}%
+$x_i$ has type $A_i$. The variables $x_1, \ldots, x_n$ appearing in
+the context must be distinct. We abbreviate contexts with the letters $\Gamma$
+and $\Delta$.
+
+The judgment $a:A$ in context $\Gamma$ is written 
+\[ \oftp\Gamma aA \]
+and means that $a:A$ under the assumptions listed in $\Gamma$. When the list of
+assumptions is empty, we write simply
+\[ \oftp{}aA \]
+or
+\[ \oftp\emptyctx aA \]
+where $\emptyctx$ denotes the empty context. The same applies to the equality
+judgment
+\[
+  \jdeqtp\Gamma{a}{b}{A}
+\]
+
+However, such judgments are sensible only for \define{well-formed} contexts,
+\index{context!well-formed}%
+a notion captured by our third and final judgment
+\[
+  \wfctx{(x_1:A_1, x_2:A_2,\dots,x_n:A_n)}
+\]
+expressing that each $A_i$ is a type in the context $x_1:A_1,
+x_2:A_2,\dots,x_{i-1}:A_{i-1}$.  In particular, therefore, if $\oftp\Gamma aA$ and
+$\wfctx\Gamma$, then we know that each $A_i$ contains only the variables
+$x_1,\dots,x_{i-1}$, and that $a$ and $A$ contain only the variables
+$x_1,\dots,x_n$.
+\index{variable!in context}
+
+In informal mathematical presentations, the context is
+implicit. At each point in a proof, the mathematician knows which
+variables are available and what types they have, either by historical
+convention ($n$ is usually a number, $f$ is a function, etc.) or
+because variables are explicitly introduced with sentences such as
+``let $x$ be a real number''. We discuss some benefits of using explicit
+contexts in \cref{sec:more-formal-pi,sec:more-formal-sigma}.
+
+We write $B[a/x]$ for the \define{substitution}
+\index{substitution}%
+of a term $a$ for free occurrences of
+the variable~$x$ in the term $B$, with possible capture-avoiding
+renaming of bound variables,
+\index{variable!and substitution}%
+as discussed in
+\cref{sec:function-types}. The general form of substitution
+%
+\[
+   B[a_1,\dots,a_n/x_1,\dots,x_n]
+\]
+%
+substitutes expressions $a_1,\dots,a_n$ for the variables
+$x_1,\dots,x_n$ simultaneously.
+
+To \define{bind a variable $x$ in an expression $B$}
+\indexdef{variable!bound}%
+means to incorporate both of them into a larger expression, called an \define{abstraction},
+\indexdef{abstraction}%
+whose purpose is to express the fact that $x$ is ``local'' to $B$, i.e., it
+is not to be confused with other occurrences of $x$ appearing
+elsewhere. Bound variables are familiar to programmers, but less so to mathematicians.
+Various notations are used for binding, such as $x \mapsto B$,
+$\lam x B$, and $x \,.\, B$, depending on the situation. We may write $C[a]$ for the
+substitution of a term $a$ for the variable in the abstracted expression, i.e.,
+we may define $(x.B)[a]$ to be $B[a/x]$. As discussed in
+\cref{sec:function-types}, changing the name of a bound variable everywhere within an expression (``$\alpha$-conversion'')
+\index{alpha-conversion@$\alpha $-conversion}%
+does not change the expression. Thus, to be very
+precise, an expression is an equivalence class of syntactic forms
+which differ in names of bound variables.
+
+One may also regard each variable $x_i$ of a judgment
+\[
+  x_1:A_1, x_2:A_2,\dots,x_n:A_n \vdash a : A
+\]
+to be bound in its \define{scope},
+\indexdef{variable!scope of}%
+\index{scope}%
+consisting of the expressions $A_{i+1},
+\ldots, A_n$, $a$, and $A$.
+
+\section{The first presentation}
+\label{sec:syntax-informally}
+
+The objects and types of our type theory may be written as terms using
+the following syntax, which is an extension of $\lambda$-calculus with
+\emph{variables} $x, x',\dots$,
+\index{variable}%
+\emph{primitive constants}
+\index{primitive!constant}%
+\index{constant!primitive}%
+$c,c',\dots$, \emph{defined constants}\index{constant!defined} $f,f',\dots$, and term forming
+operations
+%
+\[
+  t \production x \mid \lam{x} t \mid t(t') \mid c \mid f
+\]
+%
+The notation used here means that a term $t$ is either a variable $x$, or it
+has the form $\lam{x} t$ where $x$ is a variable and $t$ is a term, or it has
+the form $t(t')$ where $t$ and $t'$ are terms, or it is a primitive constant
+$c$, or it is a defined constant $f$. The syntactic markers '$\lambda$', '(',
+')', and '.' are punctuation for guiding the human eye.
+
+We use $t(t_1,\dots,t_n)$ as an abbreviation for the repeated application
+$t(t_1)(t_2)\dots (t_n)$. We may also use \emph{infix}\index{infix notation} notation, writing $t_1\;
+\star\; t_2$ for $\star(t_1,t_2)$ when $\star$ is a primitive or defined
+constant.
+
+Each defined constant has zero, one or more \define{defining equations}.
+\index{equation, defining}%
+\index{defining equation}%
+There are two kinds of defined constant. An \emph{explicit}
+\index{constant!explicit}
+defined constant $f$ has a single defining equation
+  \[ f(x_1,\dots,x_n)\defeq t,\]
+where $t$ does not involve $f$. 
+%
+For example, we might introduce the explicit defined constant $\circ$ with defining equation
+  \[ \circ (x,y)(z) \defeq x(y(z)),\]
+and use infix notation $x\circ y$ for $\circ(x,y)$. This of course is just composition of functions.
+
+The second kind of defined constant is used to specify a (parameterized) mapping
+$f(x_1,\dots,x_n,x)$, where $x$ ranges over a type whose elements are generated
+by zero or more primitive constants.  For each such primitive constant $c$ there
+is a defining equation of the form
+\[
+  f(x_1,\dots,x_n,c(y_1,\dots,y_m)) \defeq t,
+\]
+where $f$ may occur in $t$, but only in such a way that it is clear that the
+equations determine a totally defined function. The paradigm examples of such
+defined functions are the functions defined by primitive recursion on the
+natural numbers. We may call this kind of definition of a function a \emph{total
+  recursive definition}.
+\index{total!recursive definition}%
+In computer science and logic this kind of definition
+of a function on a recursive data type has been called a \define{definition by
+  structural recursion}.
+\index{definition!by structural recursion}%
+\index{structural!recursion}%
+\index{recursion!structural}%
+
+\define{Convertibility}
+\index{convertibility of terms}%
+\index{term!convertibility of}%
+$t \conv t'$ between terms $t$
+and $t'$ is the equivalence relation generated by the defining equations for constants,
+the computation rule\index{computation rule!for function types}
+%
+\[
+  (\lam{x} t)(u) \defeq t[u/x],
+\]
+%
+and the rules which make it a \emph{congruence} with respect to application and $\lambda$-abstraction\index{lambda abstraction@$\lambda$-abstraction}:
+%
+\begin{itemize}
+\item if $t \conv t'$ and $s \conv s'$ then $t(s) \conv t'(s')$, and
+\item if $t \conv t'$ then $(\lam{x} t) \conv (\lam{x} t')$.
+\end{itemize}
+\noindent
+The equality judgment $t \jdeq u : A$ is then derived by the following single rule:
+%
+\begin{itemize}
+\item if $t:A$, $u:A$, and $t \conv u$, then $t \jdeq u : A$.
+\end{itemize}
+%
+Judgmental equality is an equivalence relation.
+
+Note that the type theory of this presentation diverges from that used in the main body of the text in not including the judgmental uniqueness principle $f \jdeq (\lam{x} f(x))$ for functions.
+Such an equality requires that judgmental equality be sensitive to the type of the terms involved, as this equality only makes sense when $f$ is known to be a function, whereas in this presentation the convertibility relation is type-independent.
+The second presentation in \cref{sec:syntax-more-formally} includes the uniqueness principle.
+
+
+\subsection{Type universes}
+
+We postulate a hierarchy of \define{universes} denoted by primitive constants
+\index{type!universe}
+%
+\begin{equation*}
+  \UU_0, \quad \UU_1, \quad  \UU_2, \quad \ldots
+\end{equation*}
+%
+The first two rules for universes say that they form a cumulative hierarchy of types:
+%
+\begin{itemize}
+\item $\UU_m : \UU_n$ for $m < n$,
+\item if $A:\UU_m$ and $m \le n$, then $A:\UU_n$,
+\end{itemize}
+%
+and the third expresses the idea that an object of a universe can serve as a type and stand to the
+right of a colon in judgments:
+%
+\begin{itemize}
+\item if $\Gamma \vdash A : \UU_n$, and $x$ is a new variable,%
+\footnote{By ``new'' we mean that it does not appear in $\Gamma$ or $A$.}
+then $\vdash (\Gamma, x:A)\; \ctx$.
+\end{itemize}
+%
+In the body of the book, an equality judgment $A \jdeq B : \UU_n$ between types
+$A$ and $B$ is usually abbreviated to $A \jdeq B$. This is an instance of
+typical ambiguity\index{typical ambiguity}, as we can always switch to a larger universe, which however does not affect the validity of the judgment.
+
+The following conversion rule allows us to replace a type by one equal to it in a typing judgment:
+%
+\begin{itemize}
+\item if $a:A$ and $A \jdeq B$ then $a:B$.
+\end{itemize}
+
+\subsection{Dependent function types (\texorpdfstring{$\Pi$}{Π}-types)}
+
+We introduce a primitive constant $c_\Pi$, but write
+$c_\Pi(A,\lam{x} B)$ as $\tprd{x:A}B$. Judgments concerning
+such expressions and expressions of the form $\lam{x} b$ are introduced by the following rules:
+%
+\begin{itemize}
+\item if $\Gamma \vdash A:\UU_n$ and $\Gamma,x:A \vdash B:\UU_n$, then $\Gamma \vdash \tprd{x:A}B : \UU_n$
+\item if $\Gamma, x:A \vdash b:B$ then $\Gamma \vdash (\lam{x} b) : (\tprd{x:A} B)$
+\item if $\Gamma\vdash g:\tprd{x:A} B$ and $\Gamma\vdash t:A$ then $\Gamma\vdash g(t):B[t/x]$
+\end{itemize}
+%
+If $x$ does not occur freely in $B$, we abbreviate $\tprd{x:A} B$ as the non-dependent function type 
+$A\rightarrow B$ and derive the following rule:
+%
+\begin{itemize}
+\item if $\Gamma\vdash g:A \rightarrow B$ and $\Gamma\vdash t:A$ then $\Gamma\vdash g(t):B$
+\end{itemize}
+Using non-dependent function types and leaving implicit the context $\Gamma$, the rules above can be written in the following alternative style that we use in the rest of this section of the appendix:
+%
+\begin{itemize}
+\item if $A:\UU_n$ and $B:A\to\UU_n$, then $\tprd{x:A}B(x) : \UU_n$
+\item if $x:A \vdash b:B(x)$ then $ \lam{x} b : \tprd{x:A} B(x)$
+\item if $g:\tprd{x:A} B(x)$ and $t:A$ then $g(t):B(t)$
+\end{itemize}
+%
+
+\subsection{Dependent pair types (\texorpdfstring{$\Sigma$}{Σ}-types)}
+
+We introduce primitive constants $c_\Sigma$ and $c_{\mathsf{pair}}$. An
+expression of the form $c_\Sigma(A,\lam{a} B)$ is written as $\sm{a:A}B$,
+and an expression of the form $c_{\mathsf{pair}}(a,b)$ is written as $\tup
+a b$. We write $A\times B$ instead of $\sm{x:A} B$ if $x$ is not free in $B$.
+
+Judgments concerning such expressions are introduced by the following
+rules:
+%
+\begin{itemize}
+\item if $A:\UU_n$ and $B: A \rightarrow \UU_n$, then $\sm{x:A}B(x) : \UU_n$
+\item if, in addition, $a:A$ and $b:B(a)$, then $\tup a b:\sm{x:A}B(x)$
+\end{itemize}
+%
+If we have $A$ and $B$ as above, $C : (\sm{x:A}B(x)) \rightarrow \UU_m$, and
+\[
+  d:\tprd{x:A}{y:B(x)} C(\tup x y)
+\]
+we can introduce a defined constant 
+\[
+  f:\tprd{p:\sm{x:A}B(x)} C(p)
+\]
+with the defining equation
+\[
+  f(\tup x y)\defeq d(x,y).
+\]
+%
+Note that $C$, $d$, $x$, and $y$ may contain extra implicit parameters $x_1,\ldots,x_n$ if they were obtained in some non-empty context; therefore, the fully explicit recursion schema is
+%
+\begin{narrowmultline*}
+ f(x_1,\dots,x_n,\tup{x(x_1,\dots,x_n)}{y(x_1,\dots,x_n)}) \defeq
+ \narrowbreak
+ d(x_1,\dots,x_n,\tup{x(x_1,\dots,x_n)}{y(x_1,\dots,x_n)}).
+\end{narrowmultline*}
+
+\subsection{Coproduct types}
+
+We introduce primitive constants $c_+$, $c_\inlsym$, and $c_\inrsym$.
+We write $A+B$ instead of $c_+(A,B)$, $\inl(a)$ instead of
+$c_\inlsym(a)$, and $\inr(a)$ instead of $c_\inrsym(a)$:
+%
+\begin{itemize}
+\item if $A,B : \UU_n$ then $A + B : \UU_n$
+\item moreover, $\inl: A \rightarrow A+B$ and $\inr: B \rightarrow A+B$
+\end{itemize}
+%
+If we have $A$ and $B$ as above, $C : A+B \rightarrow \UU_m$, 
+$d:\tprd{x:A} C(\inl(x))$, and $e:\tprd{y:B} C(\inr(y))$,
+then we can introduce a defined constant $f:\tprd{z:A+B}C(z)$ with the defining equations
+%
+\begin{equation*}
+  f(\inl(x)) \defeq d(x)
+  \qquad\text{and}\qquad
+  f(\inr(y)) \defeq e(y).
+\end{equation*}
+
+\subsection{The finite types}
+
+We introduce primitive constants $\ttt$, $\emptyt$, $\unit$, satisfying the following rules:
+%
+\begin{itemize}
+\item $\emptyt : \UU_0$, $\unit : \UU_0$
+\item $\ttt:\unit$
+\end{itemize}
+
+Given $C : \emptyt \rightarrow \UU_n$ we can introduce a defined constant $f:\tprd{x:\emptyt} C(x)$, with no defining equations.
+
+Given $C : \unit \rightarrow \UU_n$ and $d : C(\ttt)$ we can introduce a defined constant $f:\tprd{x:\unit} C(x)$, with defining equation $f(\ttt) \defeq d$.
+
+\subsection{Natural numbers}
+
+The type of natural numbers is obtained by introducing primitive constants
+$\N$, $0$, and $\suc$ with the following rules:
+%
+\begin{itemize}
+  \item $\N : \UU_0$,
+  \item $0:\N$,
+  \item $\suc:\N\rightarrow \N$.
+\end{itemize}
+%
+Furthermore, we can define functions by primitive recursion. If we have
+$C : \N \rightarrow \UU_k $ we can introduce a defined constant $f:\tprd{x:\N}C(x)$ whenever we have
+%
+\begin{align*}
+  d & : C(0) \\
+  e & : \tprd{x:\N}(C(x)\rightarrow C(\suc (x)))
+\end{align*}
+%
+with the defining equations
+%
+\begin{equation*}
+  f(0) \defeq d
+  \qquad\text{and}\qquad
+  f(\suc (x)) \defeq e(x,f(x)).
+\end{equation*}
+
+\subsection{\texorpdfstring{$W$}{W}-types}
+
+For $W$-types we introduce primitive constants $c_\wtypesym$ and $c_\suppsym$.
+An expression of the form $c_\wtypesym(A,\lam{x} B)$ is written as
+$\wtype{x:A}B$, and an expression of the form $c_\suppsym(x,u)$ is written
+as $\supp(x,u)$:
+%
+\begin{itemize}
+\item if $A:\UU_n$ and $B: A \rightarrow \UU_n$, then $\wtype{x:A}B(x) : \UU_n$
+\item if moreover, $a:A$ and $u:B(a)\rightarrow \wtype{x:A}B(x)$ then $\supp(a,u):\wtype{x:A}B(x)$.
+\end{itemize}
+% 
+Here also we can define functions by total recursion. If we have $A$ and $B$
+as above and $C : (\wtype{x:A}B(x)) \rightarrow \UU_m$, then we can introduce a defined constant
+$f:\tprd{z:\wtype{x:A}B(x)} C(z)$ whenever we have
+\[
+  d:\tprd{a:A}{u:B(a) \rightarrow \wtype{x:A}B(x)}((\tprd{y:B(a)}C(u(y))) \rightarrow C(\supp(a,u)))
+\]
+with the defining equation
+\[
+  f(\supp(a,u)) \defeq d(a,u,f\circ u).
+\]
+
+\subsection{Identity types}
+
+We introduce primitive constants $c_\idsym$ and $c_{\refl{}}$. We write
+$\id[A] a b$ for $c_\idsym(A,a,b)$ and $\refl a$ for $c_{\refl{}}(A,a)$, when
+$a:A$ is understood:
+%
+\begin{itemize}
+\item If $A : \UU_n$, $a:A$, and $b:A$ then $\id[A] a b : \UU_n$.
+\item If $a:A$ then $\refl a :\id[A] a a $.
+\end{itemize}
+%
+Given $a:A$, if $y:A, z:\id[A] a y \vdash C : \UU_m$ and 
+$\vdash d:C[a,\refl{a}/y,z]$ then we can introduce a defined constant 
+\[
+  f:\tprd{y:A}{z:\id[A] a y} C
+\]
+with defining equation
+\[
+  f(a,\refl{a})\defeq d.
+\]
+
+\section{The second presentation}
+\label{sec:syntax-more-formally}
+
+In this section, there are three kinds of judgments 
+\begin{mathpar}
+\wfctx\Gamma
+\and
+\oftp\Gamma{a}{A}
+\and
+\jdeqtp\Gamma{a}{a'}{A}
+\end{mathpar}
+which we specify by providing inference rules for deriving them. A typical \define{inference rule}
+\indexsee{inference rule}{rule}%
+\indexdef{rule}%
+has the form
+%
+\begin{equation*}
+  \inferrule*[right=\textsc{Name}]
+  {\mathcal{J}_1 \\ \cdots \\ \mathcal{J}_k}
+  {\mathcal{J}}
+\end{equation*}
+%
+It says that we may derive the \define{conclusion} $\mathcal{J}$, provided that we have
+already derived the \define{hypotheses} $\mathcal{J}_1, \ldots, \mathcal{J}_k$.
+(Note that, being judgments rather than types, these are not hypotheses \emph{internal} to the type theory in the sense of \cref{sec:types-vs-sets}; they are instead hypotheses in the deductive system, i.e.\ the metatheory.)
+On the
+right we write the \textsc{Name} of the rule, and there may be extra side conditions that
+need to be checked before the rule is applicable.
+
+A \define{derivation}
+\index{derivation}%
+of a judgment is a tree constructed from such inference
+rules, with the judgment at the root of the tree. For example, with the rules given below, the following is a derivation of
+$\oftp{\emptyctx}{\lamu{x:\unit} x}{\unit\to\unit}$.
+%
+\begin{mathpar}
+\inferrule*[right=$\Pi$-\rintro]
+  {\inferrule*[right=$\Vble$]
+    {\inferrule*[right=\ctx-\textsc{ext}]
+      {\inferrule*[right=$\unit$-\rform]
+        {\inferrule*[right=\ctx-\textsc{emp}]
+          {\ }
+          {\wfctx {\emptyctx}}}
+        {\oftp{}{\unit}{\UU_0}}}
+      {\wfctx {\tmtp x\unit}}}
+   {\oftp{\tmtp x\unit}{x}{\unit}}}
+ {\oftp{\emptyctx}{\lamu{x:\unit} x}{\unit\to\unit}}
+\end{mathpar}
+
+\subsection{Contexts}
+\label{subsec:contexts}
+
+\index{context}%
+A context is a list
+%
+\begin{equation*}
+  \tmtp{x_1}{A_1}, \tmtp{x_2}{A_2}, \ldots, \tmtp{x_n}{A_n}
+\end{equation*}
+%
+which indicates that the distinct variables
+\index{variable}%
+$x_1, \ldots, x_n$ are assumed to have types $A_1, \ldots, A_n$, respectively. The list may be empty. We abbreviate contexts with the letters $\Gamma$ and $\Delta$, and we may juxtapose them to form larger contexts.
+
+The judgment $\wfctx{\Gamma}$ formally expresses the fact that $\Gamma$ is a well-formed context, and is governed by the rules of inference
+%
+\begin{mathpar}
+  \inferrule*[right=\ctx-\textsc{emp}]
+  {\ }
+  {\wfctx\emptyctx}
+\and
+  \inferrule*[right=\ctx-\textsc{ext}]
+  {\oftp{\tmtp{x_1}{A_1}, \ldots, \tmtp{x_{n-1}}{A_{n-1}}}{A_n}{\UU_i}}
+  {\wfctx{(\tmtp{x_1}{A_1}, \ldots, \tmtp{x_n}{A_n})}}
+\end{mathpar}
+%
+with a side condition for the second rule: the variable $x_n$ must be distinct from the variables $x_1, \ldots, x_{n-1}$.
+Note that the hypothesis and conclusion of $\ctx$-\textsc{ext} are judgments of different forms: the hypothesis says that in the context of variables $x_1, \ldots, x_{n-1}$, the expression $A_n$ has type $\UU_i$; while the conclusion says that the extended context $(\tmtp{x_1}{A_1}, \ldots, \tmtp{x_n}{A_n})$ is well-formed.
+
+It is a meta-theoretic property of the system that if any judgment of the form $\oftp{\Gamma}{a}{A}$ or $\jdeqtp\Gamma{a}{a'}{A}$ is derivable, then so is the judgment $\wfctx\Gamma$ that the context $\Gamma$ is well-formed.
+The premises of all the rules are chosen to include just enough well-formedness hypotheses to make this property provable, but no more.
+For instance, it is not necessary for $\ctx$-\textsc{ext} to hypothesize well-formedness of $(\tmtp{x_1}{A_1}, \ldots, \tmtp{x_{n-1}}{A_{n-1}})$, as that will follow from the derivability of its premise; but it is necessary for the $\Vble$ rule in the next section to hypothesize well-formedness of its context.
+This choice is only one of the many possible ways to formulate a type theory precisely, but a detailed investigation of such issues is beyond the scope of this appendix.
+
+\subsection{Structural rules}
+
+\index{structural!rules|(}%
+\index{rule!structural|(}%
+
+The fact that the context holds assumptions is expressed by the rule which says that we may derive those typing judgments which are listed in the context:
+%
+\begin{mathpar}
+  \inferrule*[right=$\Vble$]
+  {\wfctx {(\tmtp{x_1}{A_1}, \ldots, \tmtp{x_n}{A_n})} }
+  {\oftp{\tmtp{x_1}{A_1}, \ldots, \tmtp{x_n}{A_n}}{x_i}{A_i}}
+\end{mathpar}
+%
+As with $\ctx$-\textsc{ext}, the hypothesis and conclusion of the rule $\Vble$ are judgments of different forms, only now they are reversed: we start with a well-formed context and derive a typing judgment.
+
+The following important principles, called \define{substitution}
+\indexdef{rule!of substitution}%
+and
+\define{weakening},
+\indexdef{rule!of weakening}%
+need not be explicitly assumed. Rather, it is possible to
+show, by induction on the structure of all possible derivations, that whenever
+the hypotheses of these rules are derivable, their conclusion is also
+derivable.\footnote{Such rules are called \define{admissible}\indexdef{rule!admissible}\indexsee{admissible!rule}{rule, admissible}.}
+For the typing judgments these principles are manifested as
+%
+\begin{mathpar}
+  \inferrule*[right=$\Subst_1$]
+  {\oftp\Gamma{a}{A} \\ \oftp{\Gamma,\tmtp xA,\Delta}{b}{B}}
+  {\oftp{\Gamma,\Delta[a/x]}{b[a/x]}{B[a/x]}}
+\and
+  \inferrule*[right=$\Weak_1$]
+  {\oftp\Gamma{A}{\UU_i} \\ \oftp{\Gamma,\Delta}{b}{B}}
+  {\oftp{\Gamma,\tmtp xA,\Delta}{b}{B}}
+\end{mathpar}
+and for judgmental equalities they become
+\begin{mathpar}
+  \inferrule*[right=$\Subst_2$]
+  {\oftp\Gamma{a}{A} \\ \jdeqtp{\Gamma,\tmtp xA,\Delta}{b}{c}{B}}
+  {\jdeqtp{\Gamma,\Delta[a/x]}{b[a/x]}{c[a/x]}{B[a/x]}}
+\and
+  \inferrule*[right=$\Subst_3$]
+  {\jdeqtp\Gamma{a}{b}{A} \\ \oftp{\Gamma,\tmtp xA,\Delta}{c}{C}}
+  {\jdeqtp{\Gamma,\Delta[a/x]}{c[a/x]}{c[b/x]}{C[a/x]}}
+\and
+  \inferrule*[right=$\Weak_2$]
+  {\oftp\Gamma{A}{\UU_i} \\ \jdeqtp{\Gamma,\Delta}{b}{c}{B}}
+  {\jdeqtp{\Gamma,\tmtp xA,\Delta}{b}{c}{B}}
+\end{mathpar}
+%
+In addition to the judgmental equality rules given for each type former, we also
+assume that judgmental equality is an equivalence relation respected by typing.
+\begin{mathparpagebreakable}
+  \inferrule*{\oftp\Gamma{a}{A}}{\jdeqtp\Gamma{a}{a}{A}}
+\and
+  \inferrule*{\jdeqtp\Gamma{a}{b}{A}}{\jdeqtp\Gamma{b}{a}{A}}
+\and
+  \inferrule*{\jdeqtp\Gamma{a}{b}{A} \\ \jdeqtp\Gamma{b}{c}{A}}{\jdeqtp\Gamma{a}{c}{A}}
+\and
+  \inferrule*{\oftp\Gamma{a}{A} \\ \jdeqtp\Gamma{A}{B}{\UU_i}}{\oftp\Gamma{a}{B}}
+\and
+  \inferrule*{\jdeqtp\Gamma{a}{b}{A} \\ \jdeqtp\Gamma{A}{B}{\UU_i}}{\jdeqtp\Gamma{a}{b}{B}}
+\end{mathparpagebreakable}
+%
+Finally, we assume that judgmental equality is a congruence respected by typing,
+i.e., that each type and term-former preserves judgmental equality in each of
+its arguments. For instance, along with the $\Pi$-\rintro\ rule, we assume the
+rule
+\[
+  \inferrule*[right=$\Pi$-\rintro-eq]
+  {\oftp\Gamma{A}{\UU_i} \\
+   \oftp{\Gamma,\tmtp xA}{B}{\UU_i} \\
+   \jdeqtp{\Gamma,\tmtp xA}{b}{b'}{B}}
+  {\jdeqtp\Gamma{\lamu{x:A} b}{\lamu{x:A'} b'}{\tprd{x:A} B}}
+\]
+Completing the case of dependent function types, two similar rules,
+$\Pi$-\textsc{form-eq}\ and $\Pi$-\textsc{elim-eq}, are assumed.
+Taken together, these local principles (at every type) imply the global congruence principles
+$\Subst_2$ and $\Subst_3$ above. We will omit these local rules for brevity.
+
+\index{rule!structural|)}%
+\index{structural!rules|)}%
+
+\subsection{Type universes}
+
+\index{type!universe}%
+
+We postulate an infinite hierarchy of type universes
+%
+\begin{equation*}
+  \UU_0, \quad \UU_1, \quad  \UU_2, \quad \ldots
+\end{equation*}
+%
+Each universe is contained in the next, and any type in $\UU_i$ is also in $\UU_{i+1}$:
+%
+\begin{mathpar}
+\inferrule*[right=\UU-\textsc{intro}]
+  {\wfctx \Gamma }
+  {\oftp\Gamma{\UU_i}{\UU_{i+1}}}
+\and
+\inferrule*[right=\UU-\textsc{cumul}]
+  {\oftp\Gamma{A}{\UU_i}}
+  {\oftp\Gamma{A}{\UU_{i+1}}}
+\end{mathpar}
+%
+We shall set up the rules of type theory in such a way that $\oftp\Gamma{a}{A}$
+implies $\oftp\Gamma{A}{\UU_i}$ for some $i$. In other words, if $A$ plays the role of a type then it is in some universe. Another property of our type system is that $\jdeqtp\Gamma{a}{b}{A}$
+implies $\oftp\Gamma{a}{A}$ and $\oftp\Gamma{b}{A}$.
+
+\subsection{Dependent function types (\texorpdfstring{$\Pi$}{Π}-types)}
+\label{sec:more-formal-pi}
+
+\index{type!dependent function}%
+\index{type!function}%
+
+In \cref{sec:function-types}, we introduced non-dependent functions $A\to B$ in
+order to define a family of types as a function $\lam{x:A} B:A\to\UU_i$, which
+then gives rise to a type of dependent functions $\tprd{x:A} B$. But with explicit contexts
+we may replace $\lam{x:A} B:A\to\UU_i$ with the judgment
+%
+\begin{equation*}
+  \oftp{\tmtp xA}{B}{\UU_i}.
+\end{equation*}
+%
+Consequently, we may define dependent functions directly, without reference to non-dependent ones. This way we follow the general principle that each type former, with its constants and rules, should be introduced independently of all other type formers.
+%
+In fact, henceforth each type former is introduced systematically by:
+\begin{itemize}
+\item a \define{formation rule}, stating when the type former can be applied;\index{formation rule}\index{rule!formation}
+\item some \define{introduction rules}, stating how to inhabit the type;\index{introduction rule}\index{rule!introduction}
+\item \define{elimination rules}, or an induction principle, stating how to use an
+  element of the type;
+  \index{induction principle}\index{eliminator}
+\item \define{computation rules}, which are judgmental equalities explaining what happens when elimination rules are applied to results of introduction rules;
+  \index{computation rule}
+  \indexsee{rule!computation}{computation rule}
+\item optional \define{uniqueness principles}, which are judgmental equalities explaining how every element of the type is uniquely determined by the results of elimination rules applied to it.
+  \index{uniqueness!principle}
+  \indexsee{principle!uniqueness}{uniqueness principle}
+\end{itemize}
+(See also \cref{rmk:introducing-new-concepts}.)
+
+For the dependent function type these rules are:
+%
+\begin{mathparpagebreakable}
+  \def\premise{\oftp{\Gamma}{A}{\UU_i} \and \oftp{\Gamma,\tmtp xA}{B}{\UU_i}}
+  \inferrule*[right=$\Pi$-\rform]
+    \premise
+    {\oftp\Gamma{\tprd{x:A}B}{\UU_i}}
+\and
+  \inferrule*[right=$\Pi$-\rintro]
+  {\oftp{\Gamma,\tmtp xA}{b}{B}}
+  {\oftp\Gamma{\lam{x:A} b}{\tprd{x:A} B}}
+\and
+  \inferrule*[right=$\Pi$-\relim]
+  {\oftp\Gamma{f}{\tprd{x:A} B} \\ \oftp\Gamma{a}{A}}
+  {\oftp\Gamma{f(a)}{B[a/x]}}
+\and
+  \inferrule*[right=$\Pi$-\rcomp]
+  {\oftp{\Gamma,\tmtp xA}{b}{B} \\ \oftp\Gamma{a}{A}}
+  {\jdeqtp\Gamma{(\lam{x:A} b)(a)}{b[a/x]}{B[a/x]}}
+\and
+  \inferrule*[right=$\Pi$-\runiq]
+  {\oftp\Gamma{f}{\tprd{x:A} B}}
+  {\jdeqtp\Gamma{f}{(\lamu{x:A}f(x))}{\tprd{x:A} B}}
+\end{mathparpagebreakable}
+
+The expression $\lam{x:A} b$ binds free occurrences of $x$ in $b$, as does $\tprd{x:A} B$ for
+$B$.
+
+When $x$ does not occur freely in $B$ so that $B$ does not depend on $A$, we obtain as a
+special case the ordinary function type $A\to B \defeq \tprd{x:A} B$. We take this as the \emph{definition} of $\to$.
+
+We may abbreviate an expression $\lam{x:A} b$ as $\lamu{x:A} b$, with the understanding
+that the omitted type $A$ should be filled in appropriately before type-checking.
+
+\subsection{Dependent pair types (\texorpdfstring{$\Sigma$}{Σ}-types)}
+\label{sec:more-formal-sigma}
+
+\index{type!dependent pair}%
+\index{type!product}%
+
+In \cref{sec:sigma-types}, we needed $\to$ and $\prdsym$ types in order to
+define the introduction and elimination rules for $\smsym$; as with $\prdsym$, contexts allow us to state the rules for $\smsym$ independently.
+Recall that the elimination rule for a positive type such as $\Sigma$ is called \emph{induction} and denoted by $\ind{}$.
+%
+\begin{mathparpagebreakable}
+  \def\premise{\oftp{\Gamma}{A}{\UU_i} \and \oftp{\Gamma,\tmtp xA}{B}{\UU_i}}
+  \inferrule*[right=$\Sigma$-\rform]
+    \premise
+    {\oftp\Gamma{\tsm{x:A} B}{\UU_i}}
+  \and
+  \inferrule*[right=$\Sigma$-\rintro]
+    {\oftp{\Gamma, \tmtp x A}{B}{\UU_i} \\
+     \oftp\Gamma{a}{A} \\ \oftp\Gamma{b}{B[a/x]}}
+    {\oftp\Gamma{\tup ab}{\tsm{x:A} B}}
+  \and
+  \inferrule*[right=$\Sigma$-\relim]
+    {\oftp{\Gamma, \tmtp z {\tsm{x:A} B}}{C}{\UU_i} \\
+     \oftp{\Gamma,\tmtp x A,\tmtp y B}{g}{C[\tup x y/z]} \\
+     \oftp\Gamma{p}{\tsm{x:A} B}}
+    {\oftp\Gamma{\ind{\tsm{x:A} B}(z.C,x.y.g,p)}{C[p/z]}}
+  \and
+  \inferrule*[right=$\Sigma$-\rcomp]
+    {\oftp{\Gamma, \tmtp z {\tsm{x:A} B}}{C}{\UU_i} \\
+     \oftp{\Gamma, \tmtp x A, \tmtp y B}{g}{C[\tup x y/z]} \\\\
+     \oftp\Gamma{a}{A} \\ \oftp\Gamma{b}{B[a/x]}}
+    {\jdeqtp\Gamma{\ind{\tsm{x:A} B}(z.C,x.y.g,\tup{a}{b})}{g[a,b/x,y]}{C[\tup {a} {b}/z]}}
+\end{mathparpagebreakable}
+%
+The expression $\tsm{x:A} B$ binds free occurrences of $x$ in $B$. Furthermore, because
+$\ind{\tsm{x:A} B}$ has some arguments with free variables beyond those in $\Gamma$,
+we bind (following the variable names above) $z$ in $C$, and $x$ and $y$ in $g$.
+These bindings are written as $z.C$ and $x.y.g$, to indicate the names of the bound
+variables.
+\index{variable!bound}%
+In particular, we treat $\ind{\tsm{x:A} B}$ as a primitive,
+two of whose arguments contain binders; this is superficially similar to, but
+different from, $\ind{\tsm{x:A} B}$ being a function that takes functions as
+arguments.
+
+When $B$ does not contain free occurrences of $x$, we obtain as a special case
+the cartesian product $A \times B \defeq \tsm{x:A} B$. We take this
+as the \emph{definition} of the cartesian product.
+
+Notice that we don't postulate a judgmental uniqueness principle for $\Sigma$-types, even
+though we could have; see \cref{thm:eta-sigma} for a proof of the corresponding
+propositional uniqueness principle.
+
+\subsection{Coproduct types}
+
+\index{type!coproduct}%
+
+\begin{mathparpagebreakable}
+  \inferrule*[right=$+$-\rform]
+  {\oftp\Gamma{A}{\UU_i} \\ \oftp\Gamma{B}{\UU_i}}
+  {\oftp\Gamma{A+B}{\UU_i}}
+\\
+  \inferrule*[right=$+$-\rintro${}_1$]
+  {\oftp\Gamma{A}{\UU_i} \\ \oftp\Gamma{B}{\UU_i} \\\\ \oftp\Gamma{a}{A}}
+  {\oftp\Gamma{\inl(a)}{A+B}}
+\and
+  \inferrule*[right=$+$-\rintro${}_2$]
+  {\oftp\Gamma{A}{\UU_i} \\ \oftp\Gamma{B}{\UU_i} \\\\ \oftp\Gamma{b}{B}}
+  {\oftp\Gamma{\inr(b)}{A+B}}
+\\
+  \inferrule*[right=$+$-\relim]
+  {\oftp{\Gamma,\tmtp z{(A+B)}}{C}{\UU_i} \\\\
+   \oftp{\Gamma,\tmtp xA}{c}{C[\inl(x)/z]} \\
+   \oftp{\Gamma,\tmtp yB}{d}{C[\inr(y)/z]} \\\\
+   \oftp\Gamma{e}{A+B}}
+  {\oftp\Gamma{\ind{A+B}(z.C,x.c,y.d,e)}{C[e/z]}}
+\and
+  \inferrule*[right=$+$-\rcomp${}_1$]
+  {\oftp{\Gamma,\tmtp z{(A+B)}}{C}{\UU_i} \\
+   \oftp{\Gamma,\tmtp xA}{c}{C[\inl(x)/z]} \\
+   \oftp{\Gamma,\tmtp yB}{d}{C[\inr(y)/z]} \\\\
+   \oftp\Gamma{a}{A}}
+  {\jdeqtp\Gamma{\ind{A+B}(z.C,x.c,y.d,\inl(a))}{c[a/x]}{C[\inl(a)/z]}}
+\and
+  \inferrule*[right=$+$-\rcomp${}_2$]
+  {\oftp{\Gamma,\tmtp z{(A+B)}}{C}{\UU_i} \\
+   \oftp{\Gamma,\tmtp xA}{c}{C[\inl(x)/z]} \\
+   \oftp{\Gamma,\tmtp yB}{d}{C[\inr(y)/z]} \\\\
+   \oftp\Gamma{b}{B}}
+  {\jdeqtp\Gamma{\ind{A+B}(z.C,x.c,y.d,\inr(b))}{d[b/y]}{C[\inr(b)/z]}}
+\end{mathparpagebreakable}
+%
+In $\ind{A+B}$, $z$ is bound in $C$, $x$ is bound in $c$, and $y$ is bound in
+$d$.
+
+\subsection{The empty type \texorpdfstring{$\emptyt$}{0}}
+
+\index{type!empty|(}%
+
+\begin{mathparpagebreakable}
+  \inferrule*[right=$\emptyt$-\rform]
+  {\wfctx\Gamma}
+  {\oftp\Gamma\emptyt{\UU_i}}
+\and
+  \inferrule*[right=$\emptyt$-\relim]
+  {\oftp{\Gamma,\tmtp x\emptyt}{C}{\UU_i} \\ \oftp\Gamma{a}{\emptyt}}
+  {\oftp\Gamma{\ind{\emptyt}(x.C,a)}{C[a/x]}}
+\end{mathparpagebreakable}
+%
+In $\ind{\emptyt}$, $x$ is bound in $C$. The empty type has no introduction rule and no computation rule.
+
+\index{type!empty|)}%
+
+\subsection{The unit type \texorpdfstring{$\unit$}{1}}
+\label{sec:more-formal-unit}
+
+\index{type!unit|(}%
+
+\begin{mathparpagebreakable}
+  \inferrule*[right=$\unit$-\rform]
+  {\wfctx\Gamma}
+  {\oftp\Gamma\unit{\UU_i}}
+\and
+  \inferrule*[right=$\unit$-\rintro]
+  {\wfctx\Gamma}
+  {\oftp\Gamma{\ttt}{\unit}}
+\and
+  \inferrule*[right=$\unit$-\relim]
+  {\oftp{\Gamma,\tmtp x\unit}{C}{\UU_i} \\
+   \oftp{\Gamma}{c}{C[\ttt/x]} \\
+   \oftp\Gamma{a}{\unit}}
+  {\oftp\Gamma{\ind{\unit}(x.C,c,a)}{C[a/x]}}
+\and
+  \inferrule*[right=$\unit$-\rcomp]
+  {\oftp{\Gamma,\tmtp x\unit}{C}{\UU_i} \\
+   \oftp{\Gamma}{c}{C[\ttt/x]}}
+  {\jdeqtp\Gamma{\ind{\unit}(x.C,c,\ttt)}{c}{C[\ttt/x]}}
+\end{mathparpagebreakable}
+%
+In $\ind{\unit}$ the variable $x$ is bound in $C$.
+
+Notice that we do not postulate a judgmental uniqueness principle for the unit
+type; see \cref{sec:finite-product-types} for a proof of the corresponding
+propositional uniqueness statement.
+
+\index{type!unit|)}%
+
+\subsection{The natural number type}
+
+\index{natural numbers|(}%
+
+We give the rules for natural numbers, following \cref{sec:inductive-types}.
+
+\begin{mathparpagebreakable}
+  \def\premise{
+     \oftp{\Gamma,\tmtp x{\N}}{C}{\UU_i} \\
+     \oftp\Gamma{c_0}{C[0/x]} \\
+     \oftp{\Gamma,\tmtp{x}\N,\tmtp y C}{c_s}{C[\suc(x)/x]}}
+  %
+  \inferrule*[right=$\N$-\rform]
+  {\wfctx\Gamma}
+  {\oftp\Gamma{\N}{\UU_i}}
+\and
+  \inferrule*[right=$\N$-\rintro${}_1$]
+  {\wfctx\Gamma}
+  {\oftp\Gamma{0}{\N}}
+\and
+  \inferrule*[right=$\N$-\rintro${}_2$]
+  {\oftp\Gamma{n}{\N}}
+  {\oftp\Gamma{\suc(n)}{\N}}
+\and
+  \inferrule*[right=$\N$-\relim]
+  {\premise \\ \oftp\Gamma{n}{\N}}
+  {\oftp\Gamma{\ind{\N}(x.C,c_0,x.y.c_s,n)}{C[n/x]}}
+\and
+  \inferrule*[right=$\N$-\rcomp${}_1$]
+  {\premise}
+  {\jdeqtp\Gamma{\ind{\N}(x.C,c_0,x.y.c_s,0)}{c_0}{C[0/x]}}
+\and
+  \inferrule*[right=$\N$-\rcomp${}_2$]
+  {\premise \\ \oftp\Gamma{n}{\N}}
+  {\Gamma\vdash
+    {\begin{aligned}[t]
+      &\ind{\N}(x.C,c_0,x.y.c_s,\suc(n)) \\
+      &\quad \jdeq c_s[n,\ind{\N}(x.C,c_0,x.y.c_s,n)/x,y] : C[\suc(n)/x]
+    \end{aligned}}}
+\end{mathparpagebreakable}
+%
+In $\ind{\N}$, $x$ is bound in $C$, and $x$ and $y$ are bound in $c_s$.
+
+Other inductively defined types follow the same general scheme.
+
+\index{natural numbers|)}%
+
+\subsection{Identity types}
+
+\label{sec:more-formal-identity}
+
+\index{type!identity|(}%
+
+The presentation here corresponds to the (unbased) path induction principle for identity types in
+\cref{sec:identity-types}.
+
+\begin{mathparpagebreakable}
+  \inferrule*[right=$\idsym$-\rform]
+  {\oftp\Gamma{A}{\UU_i} \\ \oftp\Gamma{a}{A} \\ \oftp\Gamma{b}{A}}
+  {\oftp\Gamma{\id[A]{a}{b}}{\UU_i}}
+\and
+  \inferrule*[right=$\idsym$-\rintro]
+  {\oftp\Gamma{A}{\UU_i} \\ \oftp\Gamma{a}{A}}
+  {\oftp\Gamma{\refl a}{\id[A]aa}}
+\and
+  \inferrule*[right=$\idsym$-\relim]
+  {\oftp{\Gamma,\tmtp xA,\tmtp yA,\tmtp p{\id[A]xy}}{C}{\UU_i} \\
+   \oftp{\Gamma,\tmtp zA}{c}{C[z,z,\refl z/x,y,p]} \\
+   \oftp\Gamma{a}{A} \\ \oftp\Gamma{b}{A} \\ \oftp\Gamma{p'}{\id[A]ab}}
+  {\oftp\Gamma{\indid{A}(x.y.p.C,z.c,a,b,p')}{C[a,b,p'/x,y,p]}}
+\and
+  \inferrule*[right=$\idsym$-\rcomp]
+  {\oftp{\Gamma,\tmtp xA,\tmtp yA,\tmtp p{\id[A]xy}}{C}{\UU_i} \\
+   \oftp{\Gamma,\tmtp zA}{c}{C[z,z,\refl z/x,y,p]} \\
+   \oftp\Gamma{a}{A}}
+  {\jdeqtp\Gamma{\indid{A}(x.y.p.C,z.c,a,a,\refl a)}{c[a/z]}{C[a,a,\refl a/x,y,p]}}
+\end{mathparpagebreakable}
+%
+In $\indid{A}$, $x$, $y$, and $p$ are bound in $C$, and $z$ is bound in
+$c$.
+
+\index{type!identity|)}%
+
+\subsection{Definitions}
+
+\index{definition}%
+
+Although the rules we have listed so far allow us to construct everything we need directly, we
+would still like to be able to use named constants, such as $\isequiv$, as a matter of
+convenience. Informally, we can think of these constants simply as
+abbreviations, but the situation is a bit subtler in the formalization.
+
+For example, consider function composition, which takes $f:A\to B$ and
+$g:B\to C$ to $g\circ f:A\to C$. Somewhat unexpectedly, to make this work formally, $\circ$ must take as arguments not only $f$ and $g$, but also their types $A$, $B$, $C$:
+%
+\begin{narrowmultline*}
+  {\circ} \defeq \lam{A:\UU_i}{B:\UU_i}{C:\UU_i}
+  \narrowbreak
+  \lam{g:B\to C}{f:A\to B}{x:A} g(f(x)).
+\end{narrowmultline*}
+%
+From a practical perspective, we do not want to annotate each application of
+$\circ$ with $A$, $B$ and $C$, as they are usually quite easily guessed from surrounding information. We would like to simply write $g\circ f$.
+Then, strictly speaking, $g \circ f$ is not an abbreviation for $\lam{x : A} g(f(x))$,
+because it involves additional \define{implicit arguments} which we want to suppress.
+\index{implicit argument}
+
+Inference of implicit arguments, typical ambiguity\index{typical ambiguity} (\cref{sec:universes}),
+ensuring that symbols are only defined once, etc., are collectively called
+\define{elaboration}. \index{elaboration, in type theory}
+Elaboration must take place prior to checking a derivation, and is
+thus not usually presented as part of the core type theory. However, it is
+essentially impossible to use any implementation of type theory which does not
+perform elaboration; see \cite{Coq,norell2007towards} for further discussion.
+
+\section{Homotopy type theory}
+\label{sec:hott-features}
+
+In this section we state the additional axioms of homotopy type theory which distinguish it from standard Martin-L\"{o}f type theory: function extensionality, the
+univalence axiom, and higher inductive types. We state them in the style
+of the second presentation \cref{sec:syntax-more-formally}, although the first presentation \cref{sec:syntax-informally} could be used just as well.
+
+\subsection{Function extensionality and univalence}
+
+There are two basic ways of introducing axioms which do not introduce new syntax or judgmental equalities (function extensionality and univalence are of this form):
+either add a primitive constant to inhabit the axiom, or prove all theorems which depend on the axiom by hypothesizing a variable that inhabits the axiom, cf.\ \cref{sec:axioms}.
+While these are essentially equivalent, we opt for the former approach because we feel that the axioms of homotopy type theory are an essential part of the core theory.
+
+\index{function extensionality}%
+\cref{axiom:funext} is formalized by introduction of a constant $\funext$ which
+asserts that $\happly$ is an equivalence:
+%
+\begin{mathparpagebreakable}
+  \inferrule*[right=$\Pi$-\textsc{ext}]
+  {\oftp\Gamma{f}{\tprd{x:A} B} \\
+   \oftp\Gamma{g}{\tprd{x:A} B}}
+  {\oftp\Gamma{\funext(f,g)}{\isequiv(\happly_{f,g})}}
+\end{mathparpagebreakable}
+%
+The definitions of $\happly$ and $\isequiv$ can be found in~\eqref{eq:happly} and
+\cref{sec:concluding-remarks}, respectively.
+
+\index{univalence axiom}%
+\cref{axiom:univalence} is formalized in a similar fashion, too:
+%
+\begin{mathparpagebreakable}
+  \inferrule*[right=$\UU_i$-\textsc{univ}]
+  {\oftp\Gamma{A}{\UU_i} \\
+   \oftp\Gamma{B}{\UU_i}}
+  {\oftp\Gamma{\univalence(A,B)}{\isequiv(\idtoeqv_{A,B})}}
+\end{mathparpagebreakable}
+%
+The definition of $\idtoeqv$ can be found in~\eqref{eq:uidtoeqv}.
+
+\subsection{The circle}
+
+\index{type!circle}%
+
+Here we give an example of a basic higher inductive type; others follow the same
+general scheme, albeit with elaborations.
+
+Note that the rules below do not precisely follow the pattern of the ordinary
+inductive types in \cref{sec:syntax-more-formally}: the rules refer to the
+notions of transport and functoriality of maps (\cref{sec:functors}), and the
+second computation rule is a propositional, not judgmental, equality. These
+differences are discussed in \cref{sec:dependent-paths}.
+
+\begin{mathparpagebreakable}
+  \inferrule*[right=$\Sn^1$-\rform]
+  {\wfctx\Gamma}
+  {\oftp\Gamma{\Sn^1}{\UU_i}}
+\and
+  \inferrule*[right=$\Sn^1$-\rintro${}_1$]
+  {\wfctx\Gamma}
+  {\oftp\Gamma{\base}{\Sn^1}}
+\and
+  \inferrule*[right=$\Sn^1$-\rintro${}_2$]
+  {\wfctx\Gamma}
+  {\oftp\Gamma{\lloop}{\id[\Sn^1]{\base}{\base}}}
+\and
+  \inferrule*[right=$\Sn^1$-\relim]
+  {\oftp{\Gamma,\tmtp x{\Sn^1}}{C}{\UU_i} \\
+   \oftp{\Gamma}{b}{C[\base/x]} \\
+   \oftp{\Gamma}{\ell}{\dpath C \lloop b b} \\
+   \oftp\Gamma{p}{\Sn^1}}
+  {\oftp\Gamma{\ind{\Sn^1}(x.C,b,\ell,p)}{C[p/x]}}
+\and
+  \inferrule*[right=$\Sn^1$-\rcomp${}_1$]
+  {\oftp{\Gamma,\tmtp x{\Sn^1}}{C}{\UU_i} \\
+   \oftp{\Gamma}{b}{C[\base/x]} \\
+   \oftp{\Gamma}{\ell}{\dpath C \lloop b b}}
+  {\jdeqtp\Gamma{\ind{\Sn^1}(x.C,b,\ell,\base)}{b}{C[\base/x]}}
+\and
+  \inferrule*[right=$\Sn^1$-\rcomp${}_2$]
+  {\oftp{\Gamma,\tmtp x{\Sn^1}}{C}{\UU_i} \\
+   \oftp{\Gamma}{b}{C[\base/x]} \\
+   \oftp{\Gamma}{\ell}{\dpath C \lloop b b}}
+  {\oftp\Gamma{\Sn^1\text{-}\mathsf{loopcomp}}
+    {\id {\apd{(\lamu{y:\Sn^1} \ind{\Sn^1}(x.C,b,\ell,y))}{\lloop}} {\ell}}}
+\end{mathparpagebreakable}
+%
+In $\ind{\Sn^1}$, $x$ is bound in $C$. The notation ${\dpath C \lloop b b}$ for dependent paths was introduced in \cref{sec:dependent-paths}.
+\index{rules of type theory|)}%
+
+\section{Basic metatheory}
+\index{metatheory|(}%
+
+This section discusses the meta-theoretic properties of the type theory presented in 
+\cref{sec:syntax-informally}, and similar results hold for \cref{sec:syntax-more-formally}. Figuring out which of these still hold when we add the features from \cref{sec:hott-features} quickly leads to open questions,\index{open!problem} as discussed at the end of this section.
+
+Recall that \cref{sec:syntax-informally} defines the terms of type theory as
+an extension of the untyped $\lambda$-calculus. The $\lambda$-calculus 
+has its own notion of computation, namely the computation rule\index{computation rule!for function types}: 
+\[
+  (\lam{x} t)(u) \defeq t[u/x].
+\]
+This rule, together with the defining equations for the defined constants form
+\emph{rewriting rules}\index{rewriting rule}\index{rule!rewriting} that determine reduction steps for a rewriting 
+system. These steps yield a notion of computation in the sense that each rule
+has a natural direction: one simplifies $(\lam{x} t)(u)$ by evaluating the
+function at its argument.
+
+Moreover, this system is \emph{confluent}\index{confluence}, that is, if $a$ simplifies in some
+number of steps to both $a'$ and $a''$, there is some $b$ to which both $a'$ and
+$a''$ eventually simplify. Thus we can define $t\conv u$ to mean that $t$ and
+$u$ simplify to the same term.
+
+(The situation is similar in \cref{sec:syntax-more-formally}: Although there
+we presented the computation rules as undirected equalities $\jdeq$, we can give
+an operational semantics by saying that the application of an eliminator to an
+introductory form simplifies to its equal, not the other way around.)
+
+Using standard techniques from type theory, it is possible to show that the system in \cref{sec:syntax-informally}
+has the following properties:
+
+\begin{thm}\label{thm:conversion-preserves-typing}
+If $A : \UU$ and $A \conv A'$ then $A' : \UU$.
+If $t:A$ and $t \conv t'$ then $t':A$.
+\end{thm}
+
+We say that a term is \define{normalizable}
+\indexdef{term!normalizable}%
+\index{normalization}%
+\indexdef{normalizable term}%
+(respectively, \define{strongly
+normalizable})
+\indexdef{term!strongly normalizable}%
+\index{normalization!strong}%
+\index{strong!normalization}%
+if some (respectively, every), sequence of rewriting steps from the term
+terminates.
+
+\begin{thm}\label{thm:strong-normalization}
+If $A : \UU$ then $A$ is strongly normalizable.
+If $t:A$ then $A$ and $t$ are strongly normalizable.
+\end{thm}
+
+We say that a term is in \define{normal form}
+\index{normal form}%
+\index{term!normal form of}%
+if it cannot be further
+simplified, and that a term is \define{closed}
+\index{closed!term}%
+\index{term!closed}%
+if no variable occurs freely in
+it. A closed normal type has to be a primitive type, i.e., of the form
+$c(\vec{v})$ for some primitive constant $c$ (where the list $\vec{v}$ of closed
+normal terms may be omitted if empty, for instance, as with $\N$). In fact, we
+can explicitly describe all normal forms:
+
+\begin{lem}\label{lem:normal-forms}
+  The terms in normal form can be described by the following syntax:
+  % 
+  \begin{align*}
+    v & \production  k \mid \lam{x} v \mid c(\vec{v}) \mid f(\vec{v}), \\
+    k &\production x \mid k(v) \mid f(\vec{v})(k),
+  \end{align*}
+  % 
+  where $f(\vec{v})$ represents a partial application of the defined function $f$.
+  In particular, a type in normal form is of the form $k$ or $c(\vec{v})$.
+\end{lem}
+
+\begin{thm}
+  If $A$ is in normal form then the 
+  judgment $A : \UU$ is decidable. If $A : \UU$ and $t$ is in normal form then the judgment
+  $t:A$ is decidable.
+\end{thm}
+
+Logical consistency\index{consistency} (of the system in \cref{sec:syntax-informally}) follows
+immediately: if we had $a:\emptyt$ in the empty context, then by
+\cref{thm:conversion-preserves-typing,thm:strong-normalization}, $a$
+simplifies to a normal term $a':\emptyt$. But by
+\cref{lem:normal-forms} no such term exists.
+
+\begin{cor}
+ The system in \cref{sec:syntax-informally} is logically consistent.
+\end{cor}
+
+Similarly, we have the \emph{canonicity}\indexdef{canonicity} property that if $a:\N$ in the empty
+context, then $a$ simplifies to a normal term $\suc^k(0)$ for some numeral $k$.
+
+\begin{cor}
+ The system in \cref{sec:syntax-informally} has the canonicity property.
+\end{cor}
+
+Finally, if $a,A$ are in normal form, it is \emph{decidable} whether $a:A$; in
+other words, because type-checking amounts to verifying the correctness of a
+proof, this means we can always ``recognize a correct proof when we see one''.
+
+\begin{cor}
+The property of being a proof in the system in \cref{sec:syntax-informally} is decidable.
+\end{cor}
+
+\mentalpause
+
+The above results do not apply to the extended system of homotopy type
+theory (i.e., the above system extended by \cref{sec:hott-features}), since
+occurrences of the univalence axiom and constructors of higher inductive types
+never simplify, breaking \cref{lem:normal-forms}. It is an open question\index{open!problem}
+whether one can simplify applications of these constants in order to restore
+canonicity. We also do not have a schema describing all permissible higher
+inductive types, nor are we certain how to correctly formulate their rules
+(e.g., whether the computation rules on higher constructors should be judgmental
+equalities).
+
+The consistency\index{consistency} of Martin-L\"{o}f type theory extended with univalence and higher
+inductive types could be shown by inventing an appropriate normalization procedure, but currently
+the only proofs that these systems are consistent are via semantic models --- for
+univalence, a model in Kan\index{Kan complex} complexes due to Voevodsky \cite{klv:ssetmodel}, and
+for higher inductive types, a model due to Lumsdaine and Shulman \cite{ls:hits}.
+
+Other metatheoretic issues, and a summary of our current results, are discussed
+in greater length in the ``Constructivity'' and ``Open problems'' sections of
+the introduction to this book.
+
+\index{metatheory|)}%
+
+\sectionNotes\label{subsec:general-remarks}
+
+% This presentation is strongly inspired by two  Martin-L\"of 1972 and 1973.
+
+The system of rules with introduction (primitive constants) and elimination
+and computation rules (defined constant) is inspired by Gentzen natural
+deduction. The possibility of strengthening the elimination rule for
+existential quantification was indicated in \cite{howard:pat}. The
+strengthening of the axioms for disjunction appears in \cite{Martin-Lof-1972},
+and for absurdity elimination and identity type in \cite{Martin-Lof-1973}. The
+$W$-types were introduced in \cite{Martin-Lof-1979}. They generalize a notion
+of trees introduced by \cite{Tait-1968}.
+\index{Martin-L\"of}%
+
+%inspired from unpublished work of Spector.
+
+The generalized form of primitive recursion for natural numbers and ordinals
+appear in \cite{Hilbert-1925}. This motivated G\"odel's system $T$,
+\cite{Goedel-T-1958}, which was analyzed by \cite{Tait-1966}, who used,
+following \cite{Goedel-T-1958}, the terminology ``definitional equality'' for
+conversion: two terms are \emph{judgmentally equal} if they reduce to a
+common term by means of a sequence of applications of the reduction
+rules. This terminology was also used by de Bruijn \cite{deBruijn-1973} in his
+presentation of \emph{AUTOMATH}.\index{AUTOMATH}
+
+Our second presentation comprises fairly standard presentation of
+intensional Martin-L\"{o}f type theory, with some additional features needed in
+homotopy type theory. Compared to a reference presentation of
+\cite{hofmann:syntax-and-semantics}, the type theory of this book has a few
+non-critical differences:
+%
+\begin{itemize}
+\item universes \`{a} la Russell, in the sense of
+\cite{martin-lof:bibliopolis}; and
+\item judgmental $\eta$ and function extensionality for $\Pi$ types;
+\end{itemize}
+and a few features essential for homotopy type theory:
+\begin{itemize}
+\item the univalence axiom; and
+\item higher inductive types.
+\end{itemize}
+%
+As a matter of convenience, the book primarily defines functions by induction
+using definition by \emph{pattern matching}.
+\index{pattern matching}%
+\index{definition!by pattern matching}%
+It is possible to formalize the
+notion of pattern matching, as done in \cref{sec:syntax-informally}. However, the
+standard type-theoretic presentation, adopted in \cref{sec:syntax-more-formally}, is to introduce a single \emph{dependent
+eliminator} for each type former, from which functions out of that type must be
+defined. This approach is easier to formalize both syntactically and
+semantically, as it amounts to the universal property of the type former.
+The two approaches are equivalent; see \cref{sec:pattern-matching} for a
+longer discussion.
+
+\index{type theory!formal|)}%
+\index{formal!type theory|)}%
+
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "hott-online"
+%%% End: 

front.tex

@@ -0,0 +1,168 @@
+%%%%%%%%%%%%%%%%%%%% Cover page %%%%%%%%%%%%%%%%%%%%
+
+\newgeometry{noheadfoot,bindingoffset=-5pt,top=0pt,bottom=0pt,inner=0pt,outer=0pt}%
+\ifOPTcover
+\setcounter{page}{-1} % Otherwise we end up having two pages numbered 1
+\newlength{\coverheight}
+\setlength{\coverheight}{\OPTcoverheight}
+\newlength{\coverwidth}
+\setlength{\coverwidth}{\OPTcoverwidth}
+\input{frontpage}
+\ThisLLCornerWallPaper{1.1}{\OPTfrontimage}
+\pagecolor{covercolor}
+\frontpage
+\newpage
+% Reset page counter, cover page does not count
+\ifpdf
+\nopagecolor
+\else
+\pagecolor{white}
+\fi
+\cleartooddpage
+\else
+\fi
+
+%%%%%%%%%%%%%%%%%%%% Bastard page %%%%%%%%%%%%%%%%%%%%
+\ifOPTbastard
+\cleartooddpage
+\hbox{}
+\vspace{0.2\textwidth}
+{\centering
+\makebox[\OPTbastardwidth][s]{
+\fontsize{\OPTbastardtitlefont}{\OPTbastardtitlefont}\fontshape{n}\selectfont%
+\textbf{Homotopy Type Theory}}\par
+\vspace*{\OPTbastardtitleskip}
+\makebox[\OPTbastardwidth][s]{
+\fontsize{\OPTbastardsubtitlefont}{\OPTbastardsubtitlefont}\fontshape{n}\selectfont%
+\textit{Univalent Foundations of Mathematics}}\par
+}
+\else
+\fi
+
+%%%%%%%%%%%%%%%%%%%% Title page %%%%%%%%%%%%%%%%%%%%
+\cleartooddpage
+\hbox{}\vfill
+{\centering
+\makebox[\OPTtitlewidth][s]{\fontsize{\OPTtitletitlefont}{\OPTtitletitlefont}\fontseries{b}\selectfont%
+Homotopy Type Theory}\par
+\vspace*{\OPTtitletitleskip}
+\makebox[\OPTtitlewidth][s]{\fontsize{\OPTtitlesubtitlefont}{\OPTtitlesubtitlefont}\fontshape{it}\selectfont%
+Univalent Foundations of Mathematics}\par
+\vspace*{\OPTtitleskip}
+{\fontsize{\OPTtitleauthorfont}{\OPTtitleauthorfont}\fontshape{n}\selectfont%
+The Univalent Foundations Program\par
+\vspace*{\OPTtitleauthorskip}
+Institute for Advanced Study\par
+}
+\vspace*{\OPTtitleskip}
+\vspace*{\OPTtitleskip}
+\includegraphics[width=\OPTtitlewidth]{\OPThalftorus}\par
+}
+
+\vfill
+\hbox{}
+
+\clearpage
+%%% Restore page style
+\restoregeometry
+
+%%%%%%%%%%%%%%%%%%%% Copyright page %%%%%%%%%%%%%%%%%%%%
+\hbox{}
+\vfill
+\input{version.tex}
+{\small
+\noindent
+\emph{``Homotopy Type Theory: Univalent Foundations of Mathematics''}\\
+\copyright\ 2013 The Univalent Foundations Program
+
+\medskip
+\noindent
+Book version: \texttt{\OPTversion}
+
+\medskip
+\noindent
+MSC 2010 classification:
+\texttt{03-02},
+\texttt{55-02},
+\texttt{03B15}
+
+\bigskip
+\footnotesize
+
+\noindent
+This work is licensed under the
+\textbf{\emph{Creative Commons Attribution-ShareAlike 3.0 Unported License.}}
+%
+To view a copy of this license, visit
+\url{http://creativecommons.org/licenses/by-sa/3.0/}.
+
+\bigskip
+
+\noindent
+This book is freely available at \url{http://homotopytypetheory.org/book/}.
+
+\bigskip
+
+\noindent
+\emph{\textbf{\small Acknowledgment}}
+
+\medskip
+
+\noindent
+Apart from the generous support from the Institute for Advanced Study, some contributors
+to the book were partially or fully supported by the following agencies and grants:
+%
+\begin{itemize}
+\item Association of Members of the Institute for Advanced Study: a grant to the Institute for Advanced Study % Dan Grayson
+% SLOVENIA
+\item Agencija za raziskovalno dejavnost Republike Slovenije:  % Andrej's Slovenian agency
+\href{http://www.sicris.si/search/prg.aspx?id=6120}{P1--0294},
+\href{http://www.sicris.si/search/prj.aspx?id=7109}{N1--0011}.
+
+\item Air Force Office of Scientific Research:
+  FA9550-11-1-0143, and % Steve's ASFOR
+  FA9550-12-1-0370.  % Bob's ASFOR
+  {
+    \setlength{\parskip}{0pt}
+    \begin{quote}
+      \noindent\scriptsize
+      This material is based in part upon work supported by the AFOSR under the above awards.
+      Any opinions, findings, and conclusions or recommendations expressed in this publication are those of the author(s) and do not necessarily reflect the views of the AFOSR.
+    \end{quote}
+  }
+
+\item Engineering and Physical Sciences Research Council: % Thorsten and students
+   \href{http://gow.epsrc.ac.uk/NGBOViewGrant.aspx?GrantRef=EP/G034109/1}{EP/G034109/1}, % Reusability and dependent types
+   \href{http://gow.epsrc.ac.uk/NGBOViewGrant.aspx?GrantRef=EP/G03298X/1}{EP/G03298X/1}. % Theory and Application of Induction Recursion
+
+\item European Union's 7th Framework Programme under grant agreement nr.\ 243847 (%
+\href{http://wiki.portal.chalmers.se/cse/pmwiki.php/ForMath/ForMath/}{ForMath}). %% several Europeans, via Bas
+
+\item National Science Foundation:
+  \href{http://www.nsf.gov/awardsearch/showAward.do?AwardNumber=1001191}{DMS-1001191}, %% Steve's NSF, including Chris and Kristina
+  \href{http://www.nsf.gov/awardsearch/showAward.do?AwardNumber=1100938}{DMS-1100938}, %% Vladimir's NSF
+  \href{http://www.nsf.gov/awardsearch/showAward.do?AwardNumber=1116703}{CCF-1116703}, %% Foundations and Applications of Higher-Dimensional Directed Type Theory
+  and
+  \href{http://www.nsf.gov/awardsearch/showAward.do?AwardNumber=1128155}{DMS-1128155}. %% IAS support for Mike Shulman, copied from our %% paper by Dan Licata
+  {
+    \setlength{\itemsep}{0pt}
+    \begin{quote}
+      \noindent\scriptsize
+      This material is based in part upon work supported by the
+      National Science Foundation under the above awards.  Any opinions,
+      findings, and conclusions or recommendations expressed in this
+      material are those of the author(s) and do not necessarily reflect the
+      views of the National Science Foundation.
+    \end{quote}
+  }
+\item The Simonyi Fund: a grant to the Institute for Advanced Study          %% Dan Grayson
+  \end{itemize}
+
+
+}
+\cleartooddpage
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "hott-online"
+%%% End:

frontpage.tex

@@ -0,0 +1,27 @@
+\newcommand{\frontpage}{
+\begin{minipage}[b][\coverheight][c]{\coverwidth}
+\hbox{}\hfill
+\begin{minipage}[b][\coverheight][t]{0.83\coverwidth}
+\color{covertext}
+\vspace{\OPTtopskip}
+{\fontsize{\OPTcovertitlefont}{\OPTcovertitlefont}\fontseries{b}\selectfont%
+  \hfill Homotopy\par \hfill Type Theory}\par
+\vspace*{\OPTcovertitleskip}
+{\fontsize{\OPTcoversubtitlefont}{\OPTcoversubtitlefont}\fontshape{it}\selectfont
+\hfill Univalent Foundations of Mathematics}
+
+\vfill
+
+{\fontsize{\OPTcoverauthorfont}{\OPTcoverauthorfont}\fontseries{b}\fontshape{sc}\selectfont
+
+\hfill The Univalent Foundations Program
+\par
+\vspace*{\OPTcoverauthorskip}
+\hfill Institute for Advanced Study\par
+
+\vspace*{\OPTbotskip}
+}
+
+\end{minipage}\hfill\hbox{}
+\end{minipage}
+}

generate-nightlies

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+if [ $# -ne 2 ]; then
+    echo "Usage: ${0} www-dir wiki-dir"
+    exit 1
+fi
+
+WWW_DIR=$1
+WIKI_DIR=$2
+
+VERSION_MARKER="$(git describe --always --long)"
+VERSION="${VERSION_MARKER#first-edition-}"
+DATE="$(date +"%B %-d, %Y")"
+
+function generate_www () {
+  rm -rf -- "${WWW_DIR}" && mkdir -p -- "${WWW_DIR}" || exit 1
+  PDF_TARGETS=(hott-online hott-ebook hott-letter hott-a4 errata)
+  for TARGET in "${PDF_TARGETS[@]}"; do
+      echo "::group::Generating ${WWW_DIR}/$TARGET-$VERSION.pdf"
+      if [ ! -f "$TARGET.pdf" ]; then
+        make "${TARGET}.pdf" || exit 1
+      fi
+      echo "Copying $TARGET.pdf to ${WWW_DIR}/$TARGET-$VERSION.pdf"
+      cp -f "$TARGET.pdf" "${WWW_DIR}/$TARGET-$VERSION.pdf" || exit 1
+      echo "::endgroup::"
+      echo "::group::Generating ${WWW_DIR}/${TARGET}.pdf.html"
+      tee "${WWW_DIR}/${TARGET}.pdf.html" <<EOF
+<!doctype html><title>$TARGET-$VERSION.pdf</title><meta http-equiv=refresh content="0; url=$TARGET-$VERSION.pdf">
+EOF
+      echo "::endgroup::"
+  done
+}
+
+function generate_wiki () {
+  rm -rf -- "${WIKI_DIR}" && mkdir -p -- "${WIKI_DIR}" || exit 1
+  echo "::group::Generating ${WIKI_DIR}/Home.md"
+  tee "${WIKI_DIR}/Home.md" <<EOF
+This wiki is not in use, except that it hosts the [[Nightly builds]] page.  There is a general wiki for homotopy type theory [here](http://ncatlab.org/homotopytypetheory).
+EOF
+  echo "::endgroup::"
+  echo "::group::Generating ${WIKI_DIR}/Nightly-Builds.md"
+  tee "${WIKI_DIR}/Nightly-Builds.md" <<EOF
+<!--- This page is auto-generated.  To update this page; update the build-nightlies script. --->
+Below are links to "nightly builds" of the book, incorporating fixes and improvements that have not yet been incorporated into the "released version" that can be found on the [official book web site](http://homotopytypetheory.org/book/).  The nightly builds are updated automatically; their most recent update was on $DATE and their version marker is "$VERSION_MARKER".
+
+* [PDF for on-screen viewing](//hott.github.io/book/hott-online-$VERSION.pdf)
+* [PDF for e-book readers](//hott.github.io/book/hott-ebook-$VERSION.pdf)
+* [PDF for printing on letter paper](//hott.github.io/book/hott-letter-$VERSION.pdf)
+* [PDF for printing on A4 paper](//hott.github.io/book/hott-a4-$VERSION.pdf)
+* [errata for previous versions](//hott.github.io/book/errata-$VERSION.pdf)
+EOF
+  echo "::endgroup::"
+}
+
+generate_www
+generate_wiki

halpha.bst

@@ -0,0 +1,1281 @@
+% halpha: adds eprint field (www-admin@xxx.lanl.gov)
+% an extension of:
+% BibTeX standard bibliography style `alpha'
+	% version 0.99a for BibTeX versions 0.99a or later, LaTeX version 2.09.
+	% Copyright (C) 1985, all rights reserved.
+	% Copying of this file is authorized only if either
+	% (1) you make absolutely no changes to your copy, including name, or
+	% (2) if you do make changes, you name it something other than
+	% btxbst.doc, plain.bst, unsrt.bst, alpha.bst, and abbrv.bst.
+	% This restriction helps ensure that all standard styles are identical.
+	% The file btxbst.doc has the documentation for this style.
+
+ENTRY
+  { address
+    author
+    booktitle
+    chapter
+    edition
+    editor
+    eprint
+    howpublished
+    institution
+    journal
+    key
+    month
+    note
+    number
+    organization
+    pages
+    publisher
+    school
+    series
+    title
+    type
+    volume
+    year
+  }
+  {}
+  { label extra.label sort.label }
+
+INTEGERS { output.state before.all mid.sentence after.sentence after.block }
+
+FUNCTION {init.state.consts}
+{ #0 'before.all :=
+  #1 'mid.sentence :=
+  #2 'after.sentence :=
+  #3 'after.block :=
+}
+
+STRINGS { s t }
+
+FUNCTION {output.nonnull}
+{ 's :=
+  output.state mid.sentence =
+    { ", " * write$ }
+    { output.state after.block =
+	{ add.period$ write$
+	  newline$
+	  "\newblock " write$
+	}
+	{ output.state before.all =
+	    'write$
+	    { add.period$ " " * write$ }
+	  if$
+	}
+      if$
+      mid.sentence 'output.state :=
+    }
+  if$
+  s
+}
+
+FUNCTION {output}
+{ duplicate$ empty$
+    'pop$
+    'output.nonnull
+  if$
+}
+
+FUNCTION {output.check}
+{ 't :=
+  duplicate$ empty$
+    { pop$ "empty " t * " in " * cite$ * warning$ }
+    'output.nonnull
+  if$
+}
+
+FUNCTION {output.bibitem}
+{ newline$
+  "\bibitem[" write$
+  label write$
+  "]{" write$
+  cite$ write$
+  "}" write$
+  newline$
+  ""
+  before.all 'output.state :=
+}
+
+FUNCTION {fin.entry}
+{ add.period$
+  write$
+  newline$
+}
+
+FUNCTION {new.block}
+{ output.state before.all =
+    'skip$
+    { after.block 'output.state := }
+  if$
+}
+
+FUNCTION {new.sentence}
+{ output.state after.block =
+    'skip$
+    { output.state before.all =
+	'skip$
+	{ after.sentence 'output.state := }
+      if$
+    }
+  if$
+}
+
+FUNCTION {not}
+{   { #0 }
+    { #1 }
+  if$
+}
+
+FUNCTION {and}
+{   'skip$
+    { pop$ #0 }
+  if$
+}
+
+FUNCTION {or}
+{   { pop$ #1 }
+    'skip$
+  if$
+}
+
+FUNCTION {new.block.checka}
+{ empty$
+    'skip$
+    'new.block
+  if$
+}
+
+FUNCTION {new.block.checkb}
+{ empty$
+  swap$ empty$
+  and
+    'skip$
+    'new.block
+  if$
+}
+
+FUNCTION {new.sentence.checka}
+{ empty$
+    'skip$
+    'new.sentence
+  if$
+}
+
+FUNCTION {new.sentence.checkb}
+{ empty$
+  swap$ empty$
+  and
+    'skip$
+    'new.sentence
+  if$
+}
+
+FUNCTION {field.or.null}
+{ duplicate$ empty$
+    { pop$ "" }
+    'skip$
+  if$
+}
+
+FUNCTION {emphasize}
+{ duplicate$ empty$
+    { pop$ "" }
+    { "{\em " swap$ * "}" * }
+  if$
+}
+
+INTEGERS { nameptr namesleft numnames }
+
+FUNCTION {format.names}
+{ 's :=
+  #1 'nameptr :=
+  s num.names$ 'numnames :=
+  numnames 'namesleft :=
+    { namesleft #0 > }
+    { s nameptr "{ff~}{vv~}{ll}{, jj}" format.name$ 't :=
+      nameptr #1 >
+	{ namesleft #1 >
+	    { ", " * t * }
+	    { numnames #2 >
+		{ "," * }
+		'skip$
+	      if$
+	      t "others" =
+		{ " et~al." * }
+		{ " and " * t * }
+	      if$
+	    }
+	  if$
+	}
+	't
+      if$
+      nameptr #1 + 'nameptr :=
+      namesleft #1 - 'namesleft :=
+    }
+  while$
+}
+
+FUNCTION {format.authors}
+{ author empty$
+    { "" }
+    { author format.names }
+  if$
+}
+
+FUNCTION {format.editors}
+{ editor empty$
+    { "" }
+    { editor format.names
+      editor num.names$ #1 >
+	{ ", editors" * }
+	{ ", editor" * }
+      if$
+    }
+  if$
+}
+
+FUNCTION {format.title}
+{ title empty$
+    { "" }
+    { title "t" change.case$ }
+  if$
+}
+
+FUNCTION {format.eprint}
+{ eprint empty$
+    { "" }
+    { eprint }
+  if$
+}
+
+
+FUNCTION {n.dashify}
+{ 't :=
+  ""
+    { t empty$ not }
+    { t #1 #1 substring$ "-" =
+	{ t #1 #2 substring$ "--" = not
+	    { "--" *
+	      t #2 global.max$ substring$ 't :=
+	    }
+	    {   { t #1 #1 substring$ "-" = }
+		{ "-" *
+		  t #2 global.max$ substring$ 't :=
+		}
+	      while$
+	    }
+	  if$
+	}
+	{ t #1 #1 substring$ *
+	  t #2 global.max$ substring$ 't :=
+	}
+      if$
+    }
+  while$
+}
+
+FUNCTION {format.date}
+{ year empty$
+    { month empty$
+	{ "" }
+	{ "there's a month but no year in " cite$ * warning$
+	  month
+	}
+      if$
+    }
+    { month empty$
+	'year
+	{ month " " * year * }
+      if$
+    }
+  if$
+}
+
+FUNCTION {format.btitle}
+{ title emphasize
+}
+
+FUNCTION {tie.or.space.connect}
+{ duplicate$ text.length$ #3 <
+    { "~" }
+    { " " }
+  if$
+  swap$ * *
+}
+
+FUNCTION {either.or.check}
+{ empty$
+    'pop$
+    { "can't use both " swap$ * " fields in " * cite$ * warning$ }
+  if$
+}
+
+FUNCTION {format.bvolume}
+{ volume empty$
+    { "" }
+    { "volume" volume tie.or.space.connect
+      series empty$
+	'skip$
+	{ " of " * series emphasize * }
+      if$
+      "volume and number" number either.or.check
+    }
+  if$
+}
+
+FUNCTION {format.number.series}
+{ volume empty$
+    { number empty$
+	{ series field.or.null }
+	{ output.state mid.sentence =
+	    { "number" }
+	    { "Number" }
+	  if$
+	  number tie.or.space.connect
+	  series empty$
+	    { "there's a number but no series in " cite$ * warning$ }
+	    { " in " * series * }
+	  if$
+	}
+      if$
+    }
+    { "" }
+  if$
+}
+
+FUNCTION {format.edition}
+{ edition empty$
+    { "" }
+    { output.state mid.sentence =
+	{ edition "l" change.case$ " edition" * }
+	{ edition "t" change.case$ " edition" * }
+      if$
+    }
+  if$
+}
+
+INTEGERS { multiresult }
+
+FUNCTION {multi.page.check}
+{ 't :=
+  #0 'multiresult :=
+    { multiresult not
+      t empty$ not
+      and
+    }
+    { t #1 #1 substring$
+      duplicate$ "-" =
+      swap$ duplicate$ "," =
+      swap$ "+" =
+      or or
+	{ #1 'multiresult := }
+	{ t #2 global.max$ substring$ 't := }
+      if$
+    }
+  while$
+  multiresult
+}
+
+FUNCTION {format.pages}
+{ pages empty$
+    { "" }
+    { pages multi.page.check
+	{ "pages" pages n.dashify tie.or.space.connect }
+	{ "page" pages tie.or.space.connect }
+      if$
+    }
+  if$
+}
+
+FUNCTION {format.vol.num.pages}
+{ volume field.or.null
+  number empty$
+    'skip$
+    { "(" number * ")" * *
+      volume empty$
+	{ "there's a number but no volume in " cite$ * warning$ }
+	'skip$
+      if$
+    }
+  if$
+  pages empty$
+    'skip$
+    { duplicate$ empty$
+	{ pop$ format.pages }
+	{ ":" * pages n.dashify * }
+      if$
+    }
+  if$
+}
+
+FUNCTION {format.chapter.pages}
+{ chapter empty$
+    'format.pages
+    { type empty$
+	{ "chapter" }
+	{ type "l" change.case$ }
+      if$
+      chapter tie.or.space.connect
+      pages empty$
+	'skip$
+	{ ", " * format.pages * }
+      if$
+    }
+  if$
+}
+
+FUNCTION {format.in.ed.booktitle}
+{ booktitle empty$
+    { "" }
+    { editor empty$
+	{ "In " booktitle emphasize * }
+	{ "In " format.editors * ", " * booktitle emphasize * }
+      if$
+    }
+  if$
+}
+
+FUNCTION {empty.misc.check}
+{ author empty$ title empty$ howpublished empty$
+  month empty$ year empty$ note empty$
+  and and and and and
+  key empty$ not and
+    { "all relevant fields are empty in " cite$ * warning$ }
+    'skip$
+  if$
+}
+
+FUNCTION {format.thesis.type}
+{ type empty$
+    'skip$
+    { pop$
+      type "t" change.case$
+    }
+  if$
+}
+
+FUNCTION {format.tr.number}
+{ type empty$
+    { "Technical Report" }
+    'type
+  if$
+  number empty$
+    { "t" change.case$ }
+    { number tie.or.space.connect }
+  if$
+}
+
+FUNCTION {format.article.crossref}
+{ key empty$
+    { journal empty$
+	{ "need key or journal for " cite$ * " to crossref " * crossref *
+	  warning$
+	  ""
+	}
+	{ "In {\em " journal * "\/}" * }
+      if$
+    }
+    { "In " key * }
+  if$
+  " \cite{" * crossref * "}" *
+}
+
+FUNCTION {format.crossref.editor}
+{ editor #1 "{vv~}{ll}" format.name$
+  editor num.names$ duplicate$
+  #2 >
+    { pop$ " et~al." * }
+    { #2 <
+	'skip$
+	{ editor #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" =
+	    { " et~al." * }
+	    { " and " * editor #2 "{vv~}{ll}" format.name$ * }
+	  if$
+	}
+      if$
+    }
+  if$
+}
+
+FUNCTION {format.book.crossref}
+{ volume empty$
+    { "empty volume in " cite$ * "'s crossref of " * crossref * warning$
+      "In "
+    }
+    { "Volume" volume tie.or.space.connect
+      " of " *
+    }
+  if$
+  editor empty$
+  editor field.or.null author field.or.null =
+  or
+    { key empty$
+	{ series empty$
+	    { "need editor, key, or series for " cite$ * " to crossref " *
+	      crossref * warning$
+	      "" *
+	    }
+	    { "{\em " * series * "\/}" * }
+	  if$
+	}
+	{ key * }
+      if$
+    }
+    { format.crossref.editor * }
+  if$
+  " \cite{" * crossref * "}" *
+}
+
+FUNCTION {format.incoll.inproc.crossref}
+{ editor empty$
+  editor field.or.null author field.or.null =
+  or
+    { key empty$
+	{ booktitle empty$
+	    { "need editor, key, or booktitle for " cite$ * " to crossref " *
+	      crossref * warning$
+	      ""
+	    }
+	    { "In {\em " booktitle * "\/}" * }
+	  if$
+	}
+	{ "In " key * }
+      if$
+    }
+    { "In " format.crossref.editor * }
+  if$
+  " \cite{" * crossref * "}" *
+}
+
+FUNCTION {article}
+{ output.bibitem
+  format.authors "author" output.check
+  new.block
+  format.title "title" output.check
+  new.block
+  crossref missing$
+    { journal emphasize "journal" output.check
+      format.vol.num.pages output
+      format.date "year" output.check
+    }
+    { format.article.crossref output.nonnull
+      format.pages output
+    }
+  if$
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {book}
+{ output.bibitem
+  author empty$
+    { format.editors "author and editor" output.check }
+    { format.authors output.nonnull
+      crossref missing$
+	{ "author and editor" editor either.or.check }
+	'skip$
+      if$
+    }
+  if$
+  new.block
+  format.btitle "title" output.check
+  crossref missing$
+    { format.bvolume output
+      new.block
+      format.number.series output
+      new.sentence
+      publisher "publisher" output.check
+      address output
+    }
+    { new.block
+      format.book.crossref output.nonnull
+    }
+  if$
+  format.edition output
+  format.date "year" output.check
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {booklet}
+{ output.bibitem
+  format.authors output
+  new.block
+  format.title "title" output.check
+  howpublished address new.block.checkb
+  howpublished output
+  address output
+  format.date output
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {inbook}
+{ output.bibitem
+  author empty$
+    { format.editors "author and editor" output.check }
+    { format.authors output.nonnull
+      crossref missing$
+	{ "author and editor" editor either.or.check }
+	'skip$
+      if$
+    }
+  if$
+  new.block
+  format.btitle "title" output.check
+  crossref missing$
+    { format.bvolume output
+      format.chapter.pages "chapter and pages" output.check
+      new.block
+      format.number.series output
+      new.sentence
+      publisher "publisher" output.check
+      address output
+    }
+    { format.chapter.pages "chapter and pages" output.check
+      new.block
+      format.book.crossref output.nonnull
+    }
+  if$
+  format.edition output
+  format.date "year" output.check
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {incollection}
+{ output.bibitem
+  format.authors "author" output.check
+  new.block
+  format.title "title" output.check
+  new.block
+  crossref missing$
+    { format.in.ed.booktitle "booktitle" output.check
+      format.bvolume output
+      format.number.series output
+      format.chapter.pages output
+      new.sentence
+      publisher "publisher" output.check
+      address output
+      format.edition output
+      format.date "year" output.check
+    }
+    { format.incoll.inproc.crossref output.nonnull
+      format.chapter.pages output
+    }
+  if$
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {inproceedings}
+{ output.bibitem
+  format.authors "author" output.check
+  new.block
+  format.title "title" output.check
+  new.block
+  crossref missing$
+    { format.in.ed.booktitle "booktitle" output.check
+      format.bvolume output
+      format.number.series output
+      format.pages output
+      address empty$
+	{ organization publisher new.sentence.checkb
+	  organization output
+	  publisher output
+	  format.date "year" output.check
+	}
+	{ address output.nonnull
+	  format.date "year" output.check
+	  new.sentence
+	  organization output
+	  publisher output
+	}
+      if$
+    }
+    { format.incoll.inproc.crossref output.nonnull
+      format.pages output
+    }
+  if$
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {conference} { inproceedings }
+
+FUNCTION {manual}
+{ output.bibitem
+  author empty$
+    { organization empty$
+	'skip$
+	{ organization output.nonnull
+	  address output
+	}
+      if$
+    }
+    { format.authors output.nonnull }
+  if$
+  new.block
+  format.btitle "title" output.check
+  author empty$
+    { organization empty$
+	{ address new.block.checka
+	  address output
+	}
+	'skip$
+      if$
+    }
+    { organization address new.block.checkb
+      organization output
+      address output
+    }
+  if$
+  format.edition output
+  format.date output
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {mastersthesis}
+{ output.bibitem
+  format.authors "author" output.check
+  new.block
+  format.title "title" output.check
+  new.block
+  "Master's thesis" format.thesis.type output.nonnull
+  school "school" output.check
+  address output
+  format.date "year" output.check
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {misc}
+{ output.bibitem
+  format.authors output
+  title howpublished new.block.checkb
+  format.title output
+  howpublished new.block.checka
+  howpublished output
+  format.date output
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+  empty.misc.check
+}
+
+FUNCTION {phdthesis}
+{ output.bibitem
+  format.authors "author" output.check
+  new.block
+  format.btitle "title" output.check
+  new.block
+  "PhD thesis" format.thesis.type output.nonnull
+  school "school" output.check
+  address output
+  format.date "year" output.check
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {proceedings}
+{ output.bibitem
+  editor empty$
+    { organization output }
+    { format.editors output.nonnull }
+  if$
+  new.block
+  format.btitle "title" output.check
+  format.bvolume output
+  format.number.series output
+  address empty$
+    { editor empty$
+	{ publisher new.sentence.checka }
+	{ organization publisher new.sentence.checkb
+	  organization output
+	}
+      if$
+      publisher output
+      format.date "year" output.check
+    }
+    { address output.nonnull
+      format.date "year" output.check
+      new.sentence
+      editor empty$
+	'skip$
+	{ organization output }
+      if$
+      publisher output
+    }
+  if$
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {techreport}
+{ output.bibitem
+  format.authors "author" output.check
+  new.block
+  format.title "title" output.check
+  new.block
+  format.tr.number output.nonnull
+  institution "institution" output.check
+  address output
+  format.date "year" output.check
+  format.eprint output
+  new.block
+  note output
+  fin.entry
+}
+
+FUNCTION {unpublished}
+{ output.bibitem
+  format.authors "author" output.check
+  new.block
+  format.title "title" output.check
+  new.block
+  note "note" output.check
+  format.date output
+  format.eprint output
+  fin.entry
+}
+
+FUNCTION {default.type} { misc }
+
+MACRO {jan} {"January"}
+
+MACRO {feb} {"February"}
+
+MACRO {mar} {"March"}
+
+MACRO {apr} {"April"}
+
+MACRO {may} {"May"}
+
+MACRO {jun} {"June"}
+
+MACRO {jul} {"July"}
+
+MACRO {aug} {"August"}
+
+MACRO {sep} {"September"}
+
+MACRO {oct} {"October"}
+
+MACRO {nov} {"November"}
+
+MACRO {dec} {"December"}
+
+MACRO {acmcs} {"ACM Computing Surveys"}
+
+MACRO {acta} {"Acta Informatica"}
+
+MACRO {cacm} {"Communications of the ACM"}
+
+MACRO {ibmjrd} {"IBM Journal of Research and Development"}
+
+MACRO {ibmsj} {"IBM Systems Journal"}
+
+MACRO {ieeese} {"IEEE Transactions on Software Engineering"}
+
+MACRO {ieeetc} {"IEEE Transactions on Computers"}
+
+MACRO {ieeetcad}
+ {"IEEE Transactions on Computer-Aided Design of Integrated Circuits"}
+
+MACRO {ipl} {"Information Processing Letters"}
+
+MACRO {jacm} {"Journal of the ACM"}
+
+MACRO {jcss} {"Journal of Computer and System Sciences"}
+
+MACRO {scp} {"Science of Computer Programming"}
+
+MACRO {sicomp} {"SIAM Journal on Computing"}
+
+MACRO {tocs} {"ACM Transactions on Computer Systems"}
+
+MACRO {tods} {"ACM Transactions on Database Systems"}
+
+MACRO {tog} {"ACM Transactions on Graphics"}
+
+MACRO {toms} {"ACM Transactions on Mathematical Software"}
+
+MACRO {toois} {"ACM Transactions on Office Information Systems"}
+
+MACRO {toplas} {"ACM Transactions on Programming Languages and Systems"}
+
+MACRO {tcs} {"Theoretical Computer Science"}
+
+READ
+
+FUNCTION {sortify}
+{ purify$
+  "l" change.case$
+}
+
+INTEGERS { len }
+
+FUNCTION {chop.word}
+{ 's :=
+  'len :=
+  s #1 len substring$ =
+    { s len #1 + global.max$ substring$ }
+    's
+  if$
+}
+
+INTEGERS { et.al.char.used }
+
+FUNCTION {initialize.et.al.char.used}
+{ #0 'et.al.char.used :=
+}
+
+EXECUTE {initialize.et.al.char.used}
+
+FUNCTION {format.lab.names}
+{ 's :=
+  s num.names$ 'numnames :=
+  numnames #1 >
+    { numnames #4 >
+	{ #3 'namesleft := }
+	{ numnames 'namesleft := }
+      if$
+      #1 'nameptr :=
+      ""
+	{ namesleft #0 > }
+	{ nameptr numnames =
+	    { s nameptr "{ff }{vv }{ll}{ jj}" format.name$ "others" =
+		{ "{\etalchar{+}}" *
+		  #1 'et.al.char.used :=
+		}
+		{ s nameptr "{v{}}{l{}}" format.name$ * }
+	      if$
+	    }
+	    { s nameptr "{v{}}{l{}}" format.name$ * }
+	  if$
+	  nameptr #1 + 'nameptr :=
+	  namesleft #1 - 'namesleft :=
+	}
+      while$
+      numnames #4 >
+	{ "{\etalchar{+}}" *
+	  #1 'et.al.char.used :=
+	}
+	'skip$
+      if$
+    }
+    { s #1 "{v{}}{l{}}" format.name$
+      duplicate$ text.length$ #2 <
+	{ pop$ s #1 "{ll}" format.name$ #3 text.prefix$ }
+	'skip$
+      if$
+    }
+  if$
+}
+
+FUNCTION {author.key.label}
+{ author empty$
+    { key empty$
+	{ cite$ #1 #3 substring$ }
+	{ key #3 text.prefix$ }
+      if$
+    }
+    { author format.lab.names }
+  if$
+}
+
+FUNCTION {author.editor.key.label}
+{ author empty$
+    { editor empty$
+	{ key empty$
+	    { cite$ #1 #3 substring$ }
+	    { key #3 text.prefix$ }
+	  if$
+	}
+	{ editor format.lab.names }
+      if$
+    }
+    { author format.lab.names }
+  if$
+}
+
+FUNCTION {author.key.organization.label}
+{ author empty$
+    { key empty$
+	{ organization empty$
+	    { cite$ #1 #3 substring$ }
+	    { "The " #4 organization chop.word #3 text.prefix$ }
+	  if$
+	}
+	{ key #3 text.prefix$ }
+      if$
+    }
+    { author format.lab.names }
+  if$
+}
+
+FUNCTION {editor.key.organization.label}
+{ editor empty$
+    { key empty$
+	{ organization empty$
+	    { cite$ #1 #3 substring$ }
+	    { "The " #4 organization chop.word #3 text.prefix$ }
+	  if$
+	}
+	{ key #3 text.prefix$ }
+      if$
+    }
+    { editor format.lab.names }
+  if$
+}
+
+FUNCTION {calc.label}
+{ type$ "book" =
+  type$ "inbook" =
+  or
+    'author.editor.key.label
+    { type$ "proceedings" =
+	'editor.key.organization.label
+	{ type$ "manual" =
+	    'author.key.organization.label
+	    'author.key.label
+	  if$
+	}
+      if$
+    }
+  if$
+  duplicate$
+  year field.or.null purify$ #-1 #2 substring$
+  *
+  'label :=
+  year field.or.null purify$ #-1 #4 substring$
+  *
+  sortify 'sort.label :=
+}
+
+FUNCTION {sort.format.names}
+{ 's :=
+  #1 'nameptr :=
+  ""
+  s num.names$ 'numnames :=
+  numnames 'namesleft :=
+    { namesleft #0 > }
+    { nameptr #1 >
+	{ "   " * }
+	'skip$
+      if$
+      s nameptr "{vv{ } }{ll{ }}{  ff{ }}{  jj{ }}" format.name$ 't :=
+      nameptr numnames = t "others" = and
+	{ "et al" * }
+	{ t sortify * }
+      if$
+      nameptr #1 + 'nameptr :=
+      namesleft #1 - 'namesleft :=
+    }
+  while$
+}
+
+FUNCTION {sort.format.title}
+{ 't :=
+  "A " #2
+    "An " #3
+      "The " #4 t chop.word
+    chop.word
+  chop.word
+  sortify
+  #1 global.max$ substring$
+}
+
+FUNCTION {author.sort}
+{ author empty$
+    { key empty$
+	{ "to sort, need author or key in " cite$ * warning$
+	  ""
+	}
+	{ key sortify }
+      if$
+    }
+    { author sort.format.names }
+  if$
+}
+
+FUNCTION {author.editor.sort}
+{ author empty$
+    { editor empty$
+	{ key empty$
+	    { "to sort, need author, editor, or key in " cite$ * warning$
+	      ""
+	    }
+	    { key sortify }
+	  if$
+	}
+	{ editor sort.format.names }
+      if$
+    }
+    { author sort.format.names }
+  if$
+}
+
+FUNCTION {author.organization.sort}
+{ author empty$
+    { organization empty$
+	{ key empty$
+	    { "to sort, need author, organization, or key in " cite$ * warning$
+	      ""
+	    }
+	    { key sortify }
+	  if$
+	}
+	{ "The " #4 organization chop.word sortify }
+      if$
+    }
+    { author sort.format.names }
+  if$
+}
+
+FUNCTION {editor.organization.sort}
+{ editor empty$
+    { organization empty$
+	{ key empty$
+	    { "to sort, need editor, organization, or key in " cite$ * warning$
+	      ""
+	    }
+	    { key sortify }
+	  if$
+	}
+	{ "The " #4 organization chop.word sortify }
+      if$
+    }
+    { editor sort.format.names }
+  if$
+}
+
+FUNCTION {presort}
+{ calc.label
+  sort.label
+  "    "
+  *
+  type$ "book" =
+  type$ "inbook" =
+  or
+    'author.editor.sort
+    { type$ "proceedings" =
+	'editor.organization.sort
+	{ type$ "manual" =
+	    'author.organization.sort
+	    'author.sort
+	  if$
+	}
+      if$
+    }
+  if$
+  *
+  "    "
+  *
+  year field.or.null sortify
+  *
+  "    "
+  *
+  title field.or.null
+  sort.format.title
+  *
+  #1 entry.max$ substring$
+  'sort.key$ :=
+}
+
+ITERATE {presort}
+
+SORT
+
+STRINGS { longest.label last.sort.label next.extra }
+
+INTEGERS { longest.label.width last.extra.num }
+
+FUNCTION {initialize.longest.label}
+{ "" 'longest.label :=
+  #0 int.to.chr$ 'last.sort.label :=
+  "" 'next.extra :=
+  #0 'longest.label.width :=
+  #0 'last.extra.num :=
+}
+
+FUNCTION {forward.pass}
+{ last.sort.label sort.label =
+    { last.extra.num #1 + 'last.extra.num :=
+      last.extra.num int.to.chr$ 'extra.label :=
+    }
+    { "a" chr.to.int$ 'last.extra.num :=
+      "" 'extra.label :=
+      sort.label 'last.sort.label :=
+    }
+  if$
+}
+
+FUNCTION {reverse.pass}
+{ next.extra "b" =
+    { "a" 'extra.label := }
+    'skip$
+  if$
+  label extra.label * 'label :=
+  label width$ longest.label.width >
+    { label 'longest.label :=
+      label width$ 'longest.label.width :=
+    }
+    'skip$
+  if$
+  extra.label 'next.extra :=
+}
+
+EXECUTE {initialize.longest.label}
+
+ITERATE {forward.pass}
+
+REVERSE {reverse.pass}
+
+FUNCTION {begin.bib}
+{ et.al.char.used
+    { "\newcommand{\etalchar}[1]{$^{#1}$}" write$ newline$ }
+    'skip$
+  if$
+  preamble$ empty$
+    'skip$
+    { preamble$ write$ newline$ }
+  if$
+  "\begin{thebibliography}{"  longest.label  * "}" * write$ newline$
+}
+
+EXECUTE {begin.bib}
+
+EXECUTE {init.state.consts}
+
+ITERATE {call.type$}
+
+FUNCTION {end.bib}
+{ newline$
+  "\end{thebibliography}" write$ newline$
+}
+
+EXECUTE {end.bib}