From bc21da4b58669ede55856ecfecc65761fbc2bb77 Mon Sep 17 00:00:00 2001
From: Fredrik Bakke <fredrbak@gmail.com>
Date: Wed, 1 Nov 2023 15:26:12 +0100
Subject: [PATCH] Opposite categories, gaunt categories, replete
 subprecategories, large Yoneda, and miscellaneous additions (#880)

---
 TEMPLATE.lagda.md                             |   3 +-
 src/category-theory.lagda.md                  |   9 +
 src/category-theory/categories.lagda.md       | 121 ++++++
 .../copresheaf-categories.lagda.md            | 169 +++++++++
 .../coproducts-in-precategories.lagda.md      |   3 +-
 .../equivalences-of-precategories.lagda.md    |   2 +-
 .../faithful-maps-precategories.lagda.md      |   6 +-
 .../full-maps-precategories.lagda.md          |   3 +-
 .../full-subprecategories.lagda.md            |   4 +-
 ...fully-faithful-maps-precategories.lagda.md |   3 +-
 .../functors-precategories.lagda.md           | 217 +++++++++--
 src/category-theory/gaunt-categories.lagda.md | 359 ++++++++++++++++++
 .../isomorphism-induction-categories.lagda.md |   4 +-
 .../isomorphisms-in-categories.lagda.md       |  10 +-
 .../isomorphisms-in-precategories.lagda.md    |  48 ++-
 .../isomorphisms-in-subprecategories.lagda.md | 264 +++++++++++++
 .../large-subprecategories.lagda.md           |   4 +-
 ...-isomorphisms-functors-categories.lagda.md |   2 +-
 ...omorphisms-functors-precategories.lagda.md |   2 +-
 ...ural-isomorphisms-maps-categories.lagda.md |   2 +-
 ...l-isomorphisms-maps-precategories.lagda.md |   4 +-
 ...ansformations-functors-categories.lagda.md |   6 +-
 ...rs-from-small-to-large-categories.lagda.md | 245 ++++++++++++
 ...from-small-to-large-precategories.lagda.md |   6 +-
 ...formations-functors-precategories.lagda.md |   6 +-
 ...l-transformations-maps-categories.lagda.md |   6 +-
 ...from-small-to-large-precategories.lagda.md |  14 +-
 ...ransformations-maps-precategories.lagda.md |  14 +-
 .../nonunital-precategories.lagda.md          |  35 ++
 .../opposite-categories.lagda.md              | 159 ++++++++
 .../opposite-precategories.lagda.md           | 156 +++++++-
 .../opposite-preunivalent-categories.lagda.md | 182 +++++++++
 src/category-theory/precategories.lagda.md    |  54 ++-
 .../presheaf-categories.lagda.md              | 148 ++++++--
 .../preunivalent-categories.lagda.md          |  59 ++-
 .../products-in-precategories.lagda.md        |   3 +-
 .../pullbacks-in-precategories.lagda.md       |   4 +-
 .../replete-subprecategories.lagda.md         | 332 ++++++++++++++++
 ...representable-functors-categories.lagda.md |   6 +-
 ...resentable-functors-precategories.lagda.md | 126 ++++--
 .../rigid-objects-categories.lagda.md         |  81 ++++
 .../rigid-objects-precategories.lagda.md      |  72 ++++
 .../strict-categories.lagda.md                |  91 ++++-
 src/category-theory/subcategories.lagda.md    | 246 +++++++++---
 src/category-theory/subprecategories.lagda.md | 274 +++++++------
 .../terminal-objects-precategories.lagda.md   |   5 +-
 .../yoneda-lemma-categories.lagda.md          | 121 +++---
 .../yoneda-lemma-precategories.lagda.md       | 153 +++++---
 .../peano-arithmetic.lagda.md                 |  12 +-
 src/foundation-core/1-types.lagda.md          |  33 +-
 .../equality-dependent-pair-types.lagda.md    |  12 +-
 src/foundation-core/identity-types.lagda.md   |  12 +-
 src/foundation-core/path-split-maps.lagda.md  |   3 +-
 src/foundation-core/propositions.lagda.md     | 223 -----------
 src/foundation-core/pullbacks.lagda.md        |  10 +-
 src/foundation-core/truncated-types.lagda.md  |   2 +-
 .../truncation-levels.lagda.md                |  14 +-
 src/foundation.lagda.md                       |   1 +
 src/foundation/1-types.lagda.md               |  56 ++-
 src/foundation/binary-relations.lagda.md      |   3 +-
 ...cantor-schroder-bernstein-escardo.lagda.md |   2 +-
 src/foundation/category-of-sets.lagda.md      |  22 +-
 .../commuting-cubes-of-maps.lagda.md          |   2 +-
 ...ting-pentagons-of-identifications.lagda.md |  54 +++
 src/foundation/decidable-embeddings.lagda.md  |   2 +-
 src/foundation/decidable-equality.lagda.md    |   6 +-
 .../double-negation-modality.lagda.md         |   2 +-
 src/foundation/embeddings.lagda.md            |   6 +-
 ...equality-dependent-function-types.lagda.md |   1 -
 .../functoriality-fibers-of-maps.lagda.md     |   4 +-
 src/foundation/identity-types.lagda.md        |  11 +-
 src/foundation/locally-small-types.lagda.md   |   3 +-
 .../multivariable-homotopies.lagda.md         |   2 +-
 src/foundation/path-split-maps.lagda.md       |   3 +-
 src/foundation/preidempotent-maps.lagda.md    |   3 +-
 src/foundation/propositions.lagda.md          |  16 +
 src/foundation/pullbacks.lagda.md             |   6 +-
 src/foundation/replacement.lagda.md           |   3 +-
 src/foundation/sets.lagda.md                  |  20 +-
 src/foundation/surjective-maps.lagda.md       |   2 +-
 ...port-along-higher-identifications.lagda.md |   1 -
 .../transport-along-identifications.lagda.md  |   4 -
 src/foundation/truncated-types.lagda.md       |  25 +-
 src/foundation/truncation-levels.lagda.md     |  23 ++
 ...e-arithmetic-dependent-pair-types.lagda.md |  70 ++--
 src/group-theory/automorphism-groups.lagda.md |   3 +-
 src/group-theory/concrete-monoids.lagda.md    |   2 +-
 src/group-theory/torsors.lagda.md             |   6 +-
 src/order-theory/large-posets.lagda.md        |   2 +-
 src/order-theory/posets.lagda.md              |   6 +-
 .../closed-modalities.lagda.md                |   2 +-
 .../higher-modalities.lagda.md                |   2 +-
 .../localizations-maps.lagda.md               |   5 +-
 .../localizations-subuniverses.lagda.md       |   5 +-
 .../modal-operators.lagda.md                  |   2 +-
 .../orthogonal-factorization-systems.lagda.md |   2 +-
 .../reflective-subuniverses.lagda.md          |   8 +-
 .../separated-types.lagda.md                  |   3 +-
 ...ma-closed-reflective-subuniverses.lagda.md |   2 +-
 ...-orthogonal-factorization-systems.lagda.md |   2 +-
 .../uniquely-eliminating-modalities.lagda.md  |   2 +-
 src/set-theory/cumulative-hierarchy.lagda.md  |   3 +-
 .../joins-of-types.lagda.md                   |   3 +-
 103 files changed, 3731 insertions(+), 846 deletions(-)
 create mode 100644 src/category-theory/copresheaf-categories.lagda.md
 create mode 100644 src/category-theory/gaunt-categories.lagda.md
 create mode 100644 src/category-theory/isomorphisms-in-subprecategories.lagda.md
 create mode 100644 src/category-theory/natural-transformations-functors-from-small-to-large-categories.lagda.md
 create mode 100644 src/category-theory/opposite-categories.lagda.md
 create mode 100644 src/category-theory/opposite-preunivalent-categories.lagda.md
 create mode 100644 src/category-theory/replete-subprecategories.lagda.md
 create mode 100644 src/category-theory/rigid-objects-categories.lagda.md
 create mode 100644 src/category-theory/rigid-objects-precategories.lagda.md
 create mode 100644 src/foundation/commuting-pentagons-of-identifications.lagda.md

diff --git a/TEMPLATE.lagda.md b/TEMPLATE.lagda.md
index ab7065acb1..407fdace78 100644
--- a/TEMPLATE.lagda.md
+++ b/TEMPLATE.lagda.md
@@ -55,5 +55,4 @@ concept-subconcept = ...
 
 1. Univalent Foundations Project, _Homotopy Type Theory – Univalent Foundations
    of Mathematics_ (2013) ([website](https://homotopytypetheory.org/book/),
-   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729),
-   [DOI:10.48550](https://doi.org/10.48550/arXiv.1308.0729))
+   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729))
diff --git a/src/category-theory.lagda.md b/src/category-theory.lagda.md
index 3b99e5908a..246d29dd86 100644
--- a/src/category-theory.lagda.md
+++ b/src/category-theory.lagda.md
@@ -26,6 +26,7 @@ open import category-theory.category-of-maps-from-small-to-large-categories publ
 open import category-theory.commuting-squares-of-morphisms-in-large-precategories public
 open import category-theory.commuting-squares-of-morphisms-in-precategories public
 open import category-theory.composition-operations-on-binary-families-of-sets public
+open import category-theory.copresheaf-categories public
 open import category-theory.coproducts-in-precategories public
 open import category-theory.dependent-products-of-categories public
 open import category-theory.dependent-products-of-large-categories public
@@ -59,6 +60,7 @@ open import category-theory.functors-from-small-to-large-precategories public
 open import category-theory.functors-large-categories public
 open import category-theory.functors-large-precategories public
 open import category-theory.functors-precategories public
+open import category-theory.gaunt-categories public
 open import category-theory.groupoids public
 open import category-theory.homotopies-natural-transformations-large-precategories public
 open import category-theory.initial-objects-large-categories public
@@ -70,6 +72,7 @@ open import category-theory.isomorphisms-in-categories public
 open import category-theory.isomorphisms-in-large-categories public
 open import category-theory.isomorphisms-in-large-precategories public
 open import category-theory.isomorphisms-in-precategories public
+open import category-theory.isomorphisms-in-subprecategories public
 open import category-theory.large-categories public
 open import category-theory.large-function-categories public
 open import category-theory.large-function-precategories public
@@ -88,6 +91,7 @@ open import category-theory.natural-isomorphisms-maps-categories public
 open import category-theory.natural-isomorphisms-maps-precategories public
 open import category-theory.natural-numbers-object-precategories public
 open import category-theory.natural-transformations-functors-categories public
+open import category-theory.natural-transformations-functors-from-small-to-large-categories public
 open import category-theory.natural-transformations-functors-from-small-to-large-precategories public
 open import category-theory.natural-transformations-functors-large-categories public
 open import category-theory.natural-transformations-functors-large-precategories public
@@ -97,7 +101,9 @@ open import category-theory.natural-transformations-maps-from-small-to-large-pre
 open import category-theory.natural-transformations-maps-precategories public
 open import category-theory.nonunital-precategories public
 open import category-theory.one-object-precategories public
+open import category-theory.opposite-categories public
 open import category-theory.opposite-precategories public
+open import category-theory.opposite-preunivalent-categories public
 open import category-theory.precategories public
 open import category-theory.precategory-of-functors public
 open import category-theory.precategory-of-functors-from-small-to-large-precategories public
@@ -109,10 +115,13 @@ open import category-theory.preunivalent-categories public
 open import category-theory.products-in-precategories public
 open import category-theory.products-of-precategories public
 open import category-theory.pullbacks-in-precategories public
+open import category-theory.replete-subprecategories public
 open import category-theory.representable-functors-categories public
 open import category-theory.representable-functors-large-precategories public
 open import category-theory.representable-functors-precategories public
 open import category-theory.representing-arrow-category public
+open import category-theory.rigid-objects-categories public
+open import category-theory.rigid-objects-precategories public
 open import category-theory.sieves-in-categories public
 open import category-theory.simplex-category public
 open import category-theory.slice-precategories public
diff --git a/src/category-theory/categories.lagda.md b/src/category-theory/categories.lagda.md
index b668dda0c3..c0994b4ba5 100644
--- a/src/category-theory/categories.lagda.md
+++ b/src/category-theory/categories.lagda.md
@@ -14,11 +14,13 @@ open import category-theory.precategories
 open import category-theory.preunivalent-categories
 
 open import foundation.1-types
+open import foundation.cartesian-product-types
 open import foundation.dependent-pair-types
 open import foundation.equivalences
 open import foundation.identity-types
 open import foundation.propositions
 open import foundation.sets
+open import foundation.surjective-maps
 open import foundation.universe-levels
 ```
 
@@ -56,6 +58,10 @@ module _
 
   is-category-Precategory : UU (l1 ⊔ l2)
   is-category-Precategory = type-Prop is-category-prop-Precategory
+
+  is-prop-is-category-Precategory : is-prop is-category-Precategory
+  is-prop-is-category-Precategory =
+    is-prop-type-Prop is-category-prop-Precategory
 ```
 
 ### The type of categories
@@ -156,6 +162,20 @@ module _
     is-emb-is-equiv (is-category-Category C x y)
 ```
 
+### The total hom-type of a preunivalent category
+
+```agda
+total-hom-Category :
+  {l1 l2 : Level} (C : Category l1 l2) → UU (l1 ⊔ l2)
+total-hom-Category C = total-hom-Precategory (precategory-Category C)
+
+obj-total-hom-Category :
+  {l1 l2 : Level} (C : Category l1 l2) →
+  total-hom-Category C →
+  obj-Category C × obj-Category C
+obj-total-hom-Category C = obj-total-hom-Precategory (precategory-Category C)
+```
+
 ### Equalities induce morphisms
 
 ```agda
@@ -207,3 +227,104 @@ module _
   obj-1-type-Category =
     obj-1-type-Preunivalent-Category (preunivalent-category-Category C)
 ```
+
+### The total hom-type of a category is a 1-type
+
+```agda
+module _
+  {l1 l2 : Level} (C : Category l1 l2)
+  where
+
+  is-1-type-total-hom-Category :
+    is-1-type (total-hom-Category C)
+  is-1-type-total-hom-Category =
+    is-1-type-total-hom-Preunivalent-Category (preunivalent-category-Category C)
+
+  total-hom-1-type-Category : 1-Type (l1 ⊔ l2)
+  total-hom-1-type-Category =
+    total-hom-1-type-Preunivalent-Category (preunivalent-category-Category C)
+```
+
+### A preunivalent category is a category if and only if `iso-eq` is surjective
+
+```agda
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2)
+  where
+
+  is-surjective-iso-eq-prop-Precategory : Prop (l1 ⊔ l2)
+  is-surjective-iso-eq-prop-Precategory =
+    Π-Prop
+      ( obj-Precategory C)
+      ( λ x →
+        Π-Prop
+          ( obj-Precategory C)
+          ( λ y →
+            is-surjective-Prop
+              ( iso-eq-Precategory C x y)))
+
+  is-surjective-iso-eq-Precategory : UU (l1 ⊔ l2)
+  is-surjective-iso-eq-Precategory =
+    type-Prop is-surjective-iso-eq-prop-Precategory
+
+  is-prop-is-surjective-iso-eq-Precategory :
+    is-prop is-surjective-iso-eq-Precategory
+  is-prop-is-surjective-iso-eq-Precategory =
+    is-prop-type-Prop is-surjective-iso-eq-prop-Precategory
+```
+
+```agda
+module _
+  {l1 l2 : Level} (C : Preunivalent-Category l1 l2)
+  where
+
+  is-category-is-surjective-iso-eq-Preunivalent-Category :
+    is-surjective-iso-eq-Precategory (precategory-Preunivalent-Category C) →
+    is-category-Precategory (precategory-Preunivalent-Category C)
+  is-category-is-surjective-iso-eq-Preunivalent-Category
+    is-surjective-iso-eq-C x y =
+    is-equiv-is-emb-is-surjective
+      ( is-surjective-iso-eq-C x y)
+      ( is-preunivalent-Preunivalent-Category C x y)
+
+  is-surjective-iso-eq-is-category-Preunivalent-Category :
+    is-category-Precategory (precategory-Preunivalent-Category C) →
+    is-surjective-iso-eq-Precategory (precategory-Preunivalent-Category C)
+  is-surjective-iso-eq-is-category-Preunivalent-Category
+    is-category-C x y =
+    is-surjective-is-equiv (is-category-C x y)
+
+  is-equiv-is-category-is-surjective-iso-eq-Preunivalent-Category :
+    is-equiv is-category-is-surjective-iso-eq-Preunivalent-Category
+  is-equiv-is-category-is-surjective-iso-eq-Preunivalent-Category =
+    is-equiv-is-prop
+      ( is-prop-is-surjective-iso-eq-Precategory
+        ( precategory-Preunivalent-Category C))
+      ( is-prop-is-category-Precategory (precategory-Preunivalent-Category C))
+      ( is-surjective-iso-eq-is-category-Preunivalent-Category)
+
+  is-equiv-is-surjective-iso-eq-is-category-Preunivalent-Category :
+    is-equiv is-surjective-iso-eq-is-category-Preunivalent-Category
+  is-equiv-is-surjective-iso-eq-is-category-Preunivalent-Category =
+    is-equiv-is-prop
+      ( is-prop-is-category-Precategory (precategory-Preunivalent-Category C))
+      ( is-prop-is-surjective-iso-eq-Precategory
+        ( precategory-Preunivalent-Category C))
+      ( is-category-is-surjective-iso-eq-Preunivalent-Category)
+
+  equiv-is-category-is-surjective-iso-eq-Preunivalent-Category :
+    is-surjective-iso-eq-Precategory (precategory-Preunivalent-Category C) ≃
+    is-category-Precategory (precategory-Preunivalent-Category C)
+  pr1 equiv-is-category-is-surjective-iso-eq-Preunivalent-Category =
+    is-category-is-surjective-iso-eq-Preunivalent-Category
+  pr2 equiv-is-category-is-surjective-iso-eq-Preunivalent-Category =
+    is-equiv-is-category-is-surjective-iso-eq-Preunivalent-Category
+
+  equiv-is-surjective-iso-eq-is-category-Preunivalent-Category :
+    is-category-Precategory (precategory-Preunivalent-Category C) ≃
+    is-surjective-iso-eq-Precategory (precategory-Preunivalent-Category C)
+  pr1 equiv-is-surjective-iso-eq-is-category-Preunivalent-Category =
+    is-surjective-iso-eq-is-category-Preunivalent-Category
+  pr2 equiv-is-surjective-iso-eq-is-category-Preunivalent-Category =
+    is-equiv-is-surjective-iso-eq-is-category-Preunivalent-Category
+```
diff --git a/src/category-theory/copresheaf-categories.lagda.md b/src/category-theory/copresheaf-categories.lagda.md
new file mode 100644
index 0000000000..66c99e5828
--- /dev/null
+++ b/src/category-theory/copresheaf-categories.lagda.md
@@ -0,0 +1,169 @@
+# Copresheaf categories
+
+```agda
+module category-theory.copresheaf-categories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.categories
+open import category-theory.category-of-functors-from-small-to-large-categories
+open import category-theory.functors-precategories
+open import category-theory.large-categories
+open import category-theory.large-precategories
+open import category-theory.precategories
+open import category-theory.precategory-of-functors-from-small-to-large-precategories
+
+open import foundation.category-of-sets
+open import foundation.sets
+open import foundation.universe-levels
+```
+
+</details>
+
+## Idea
+
+Given a [precategory](category-theory.precategories.md) `C`, we can form its
+**copresheaf [category](category-theory.large-categories.md)** as the
+[large category of functors](category-theory.functors-from-small-to-large-precategories.md)
+from `C`, into the [large category of sets](foundation.category-of-sets.md)
+
+```text
+  C → Set.
+```
+
+To this large category, there is an associated
+[small category](category-theory.categories.md) of small copresheaves, taking
+values in small [sets](foundation-core.sets.md).
+
+## Definitions
+
+### The large category of copresheaves on a precategory
+
+```agda
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2)
+  where
+
+  copresheaf-Large-Precategory :
+    Large-Precategory (λ l → l1 ⊔ l2 ⊔ lsuc l) (λ l l' → l1 ⊔ l2 ⊔ l ⊔ l')
+  copresheaf-Large-Precategory =
+    functor-large-precategory-Small-Large-Precategory C Set-Large-Precategory
+
+  is-large-category-copresheaf-Large-Category :
+    is-large-category-Large-Precategory copresheaf-Large-Precategory
+  is-large-category-copresheaf-Large-Category =
+    is-large-category-functor-large-precategory-is-large-category-Small-Large-Precategory
+      ( C)
+      ( Set-Large-Precategory)
+      ( is-large-category-Set-Large-Precategory)
+
+  copresheaf-Large-Category :
+    Large-Category (λ l → l1 ⊔ l2 ⊔ lsuc l) (λ l l' → l1 ⊔ l2 ⊔ l ⊔ l')
+  large-precategory-Large-Category copresheaf-Large-Category =
+    copresheaf-Large-Precategory
+  is-large-category-Large-Category copresheaf-Large-Category =
+    is-large-category-copresheaf-Large-Category
+```
+
+We record the components of the large category of copresheaves on a precategory.
+
+```agda
+  obj-copresheaf-Large-Category =
+    obj-Large-Precategory copresheaf-Large-Precategory
+
+  hom-set-copresheaf-Large-Category =
+    hom-set-Large-Precategory copresheaf-Large-Precategory
+
+  hom-copresheaf-Large-Category =
+    hom-Large-Precategory copresheaf-Large-Precategory
+
+  comp-hom-copresheaf-Large-Category =
+    comp-hom-Large-Precategory copresheaf-Large-Precategory
+
+  id-hom-copresheaf-Large-Category =
+    id-hom-Large-Precategory copresheaf-Large-Precategory
+
+  associative-comp-hom-copresheaf-Large-Category =
+    associative-comp-hom-Large-Precategory copresheaf-Large-Precategory
+
+  left-unit-law-comp-hom-copresheaf-Large-Category =
+    left-unit-law-comp-hom-Large-Precategory copresheaf-Large-Precategory
+
+  right-unit-law-comp-hom-copresheaf-Large-Category =
+    right-unit-law-comp-hom-Large-Precategory copresheaf-Large-Precategory
+```
+
+### The category of small copresheaves on a precategory
+
+```agda
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2) (l : Level)
+  where
+
+  copresheaf-Precategory : Precategory (l1 ⊔ l2 ⊔ lsuc l) (l1 ⊔ l2 ⊔ l)
+  copresheaf-Precategory =
+    precategory-Large-Precategory (copresheaf-Large-Precategory C) l
+
+  copresheaf-Category : Category (l1 ⊔ l2 ⊔ lsuc l) (l1 ⊔ l2 ⊔ l)
+  copresheaf-Category = category-Large-Category (copresheaf-Large-Category C) l
+```
+
+We also record the components of the category of small copresheaves on a
+precategory.
+
+```agda
+  obj-copresheaf-Category =
+    obj-Precategory copresheaf-Precategory
+
+  hom-set-copresheaf-Category =
+    hom-set-Precategory copresheaf-Precategory
+
+  hom-copresheaf-Category =
+    hom-Precategory copresheaf-Precategory
+
+  comp-hom-copresheaf-Category =
+    comp-hom-Precategory copresheaf-Precategory
+
+  id-hom-copresheaf-Category =
+    id-hom-Precategory copresheaf-Precategory
+
+  associative-comp-hom-copresheaf-Category =
+    associative-comp-hom-Precategory copresheaf-Precategory
+
+  left-unit-law-comp-hom-copresheaf-Category =
+    left-unit-law-comp-hom-Precategory copresheaf-Precategory
+
+  right-unit-law-comp-hom-copresheaf-Category =
+    right-unit-law-comp-hom-Precategory copresheaf-Precategory
+```
+
+### Sections of copresheaves
+
+As a choice of universe level must be made to talk about sections of
+copresheaves, this notion coincides for the large and small category of
+copresheaves.
+
+```agda
+module _
+  {l1 l2 l3 : Level} (C : Precategory l1 l2)
+  where
+
+  section-copresheaf-Category :
+    (F : obj-copresheaf-Category C l3) (c : obj-Precategory C) → UU l3
+  section-copresheaf-Category F c =
+    type-Set (obj-functor-Precategory C (Set-Precategory l3) F c)
+```
+
+## See also
+
+- [The Yoneda lemma](category-theory.yoneda-lemma-precategories.md)
+
+## External links
+
+- [Presheaf precategories](https://1lab.dev/Cat.Functor.Base.html#presheaf-precategories)
+  at 1lab
+- [category of presheaves](https://ncatlab.org/nlab/show/category+of+presheaves)
+  at nlab
+- [copresheaf](https://ncatlab.org/nlab/show/copresheaf) at nlab
diff --git a/src/category-theory/coproducts-in-precategories.lagda.md b/src/category-theory/coproducts-in-precategories.lagda.md
index 18c02fc8a9..ce33878ae2 100644
--- a/src/category-theory/coproducts-in-precategories.lagda.md
+++ b/src/category-theory/coproducts-in-precategories.lagda.md
@@ -14,6 +14,7 @@ open import foundation.cartesian-product-types
 open import foundation.contractible-types
 open import foundation.dependent-pair-types
 open import foundation.identity-types
+open import foundation.iterated-dependent-product-types
 open import foundation.propositions
 open import foundation.unique-existence
 open import foundation.universe-levels
@@ -121,7 +122,7 @@ module _
   is-prop-is-coproduct-Precategory :
     is-prop (is-coproduct-Precategory C x y p l r)
   is-prop-is-coproduct-Precategory =
-    is-prop-Π³ (λ z f g → is-property-is-contr)
+    is-prop-iterated-Π 3 (λ z f g → is-property-is-contr)
 
   is-coproduct-prop-Precategory : Prop (l1 ⊔ l2)
   pr1 is-coproduct-prop-Precategory = is-coproduct-Precategory C x y p l r
diff --git a/src/category-theory/equivalences-of-precategories.lagda.md b/src/category-theory/equivalences-of-precategories.lagda.md
index d26d30138f..4487578e80 100644
--- a/src/category-theory/equivalences-of-precategories.lagda.md
+++ b/src/category-theory/equivalences-of-precategories.lagda.md
@@ -59,5 +59,5 @@ module _
 
 ```agda
   equiv-Precategory : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4)
-  equiv-Precategory = Σ (functor-Precategory C D) is-equiv-functor-Precategory
+  equiv-Precategory = Σ (functor-Precategory C D) (is-equiv-functor-Precategory)
 ```
diff --git a/src/category-theory/faithful-maps-precategories.lagda.md b/src/category-theory/faithful-maps-precategories.lagda.md
index d4376bf7cd..2fcbc71d8c 100644
--- a/src/category-theory/faithful-maps-precategories.lagda.md
+++ b/src/category-theory/faithful-maps-precategories.lagda.md
@@ -15,6 +15,7 @@ open import foundation.embeddings
 open import foundation.equivalences
 open import foundation.function-types
 open import foundation.injective-maps
+open import foundation.iterated-dependent-product-types
 open import foundation.propositions
 open import foundation.universe-levels
 ```
@@ -49,7 +50,8 @@ module _
 
   is-prop-is-faithful-map-Precategory : is-prop is-faithful-map-Precategory
   is-prop-is-faithful-map-Precategory =
-    is-prop-Π² (λ x y → is-prop-is-emb (hom-map-Precategory C D F {x} {y}))
+    is-prop-iterated-Π 2
+      ( λ x y → is-property-is-emb (hom-map-Precategory C D F {x} {y}))
 
   is-faithful-prop-map-Precategory : Prop (l1 ⊔ l2 ⊔ l4)
   pr1 is-faithful-prop-map-Precategory = is-faithful-map-Precategory
@@ -110,7 +112,7 @@ module _
   is-prop-is-injective-hom-map-Precategory :
     is-prop is-injective-hom-map-Precategory
   is-prop-is-injective-hom-map-Precategory =
-    is-prop-Π²
+    is-prop-iterated-Π 2
       ( λ x y →
         is-prop-is-injective
           ( is-set-hom-Precategory C x y)
diff --git a/src/category-theory/full-maps-precategories.lagda.md b/src/category-theory/full-maps-precategories.lagda.md
index aac8e8fb73..06d6cef6ce 100644
--- a/src/category-theory/full-maps-precategories.lagda.md
+++ b/src/category-theory/full-maps-precategories.lagda.md
@@ -12,6 +12,7 @@ open import category-theory.precategories
 
 open import foundation.dependent-pair-types
 open import foundation.function-types
+open import foundation.iterated-dependent-product-types
 open import foundation.propositions
 open import foundation.surjective-maps
 open import foundation.universe-levels
@@ -45,7 +46,7 @@ module _
 
   is-prop-is-full-map-Precategory : is-prop is-full-map-Precategory
   is-prop-is-full-map-Precategory =
-    is-prop-Π²
+    is-prop-iterated-Π 2
       ( λ x y → is-prop-is-surjective (hom-map-Precategory C D F {x} {y}))
 
   is-full-prop-map-Precategory : Prop (l1 ⊔ l2 ⊔ l4)
diff --git a/src/category-theory/full-subprecategories.lagda.md b/src/category-theory/full-subprecategories.lagda.md
index 96cc1399f8..2437f2eda8 100644
--- a/src/category-theory/full-subprecategories.lagda.md
+++ b/src/category-theory/full-subprecategories.lagda.md
@@ -246,9 +246,7 @@ module _
   is-category-precategory-is-category-Full-Subprecategory is-category-C X =
     fundamental-theorem-id
       ( is-torsorial-Eq-subtype
-        ( is-torsorial-iso-Category
-          ( C , is-category-C)
-          ( inclusion-subtype P X))
+        ( is-torsorial-iso-Category (C , is-category-C) (inclusion-subtype P X))
         ( is-prop-is-in-subtype P)
         ( inclusion-subtype P X)
         ( id-iso-Precategory C)
diff --git a/src/category-theory/fully-faithful-maps-precategories.lagda.md b/src/category-theory/fully-faithful-maps-precategories.lagda.md
index e2cdc1758d..2e532d64a4 100644
--- a/src/category-theory/fully-faithful-maps-precategories.lagda.md
+++ b/src/category-theory/fully-faithful-maps-precategories.lagda.md
@@ -15,6 +15,7 @@ open import category-theory.precategories
 open import foundation.dependent-pair-types
 open import foundation.equivalences
 open import foundation.function-types
+open import foundation.iterated-dependent-product-types
 open import foundation.propositions
 open import foundation.surjective-maps
 open import foundation.universe-levels
@@ -50,7 +51,7 @@ module _
   is-prop-is-fully-faithful-map-Precategory :
     is-prop is-fully-faithful-map-Precategory
   is-prop-is-fully-faithful-map-Precategory =
-    is-prop-Π²
+    is-prop-iterated-Π 2
       ( λ x y → is-property-is-equiv (hom-map-Precategory C D F {x} {y}))
 
   is-fully-faithful-prop-map-Precategory : Prop (l1 ⊔ l2 ⊔ l4)
diff --git a/src/category-theory/functors-precategories.lagda.md b/src/category-theory/functors-precategories.lagda.md
index 061e652f80..1d7354c47c 100644
--- a/src/category-theory/functors-precategories.lagda.md
+++ b/src/category-theory/functors-precategories.lagda.md
@@ -19,6 +19,7 @@ open import foundation.equivalences
 open import foundation.function-types
 open import foundation.homotopies
 open import foundation.identity-types
+open import foundation.iterated-dependent-product-types
 open import foundation.propositions
 open import foundation.subtypes
 open import foundation.type-arithmetic-dependent-pair-types
@@ -161,27 +162,56 @@ pr2 (pr2 (pr2 (id-functor-Precategory C))) x = refl
 Any two compatible functors can be composed to a new functor.
 
 ```agda
-comp-functor-Precategory :
+module _
   {l1 l2 l3 l4 l5 l6 : Level}
-  (C : Precategory l1 l2) (D : Precategory l3 l4) (E : Precategory l5 l6) →
-  functor-Precategory D E → functor-Precategory C D → functor-Precategory C E
-pr1 (comp-functor-Precategory C D E G F) =
-  obj-functor-Precategory D E G ∘ obj-functor-Precategory C D F
-pr1 (pr2 (comp-functor-Precategory C D E G F)) =
-  hom-functor-Precategory D E G ∘ hom-functor-Precategory C D F
-pr1 (pr2 (pr2 (comp-functor-Precategory C D E G F))) g f =
-  ( ap
-    ( hom-functor-Precategory D E G)
-    ( preserves-comp-functor-Precategory C D F g f)) ∙
-  ( preserves-comp-functor-Precategory D E G
-    ( hom-functor-Precategory C D F g)
-    ( hom-functor-Precategory C D F f))
-pr2 (pr2 (pr2 (comp-functor-Precategory C D E G F))) x =
-  ( ap
-    ( hom-functor-Precategory D E G)
-    ( preserves-id-functor-Precategory C D F x)) ∙
-  ( preserves-id-functor-Precategory D E G
-    ( obj-functor-Precategory C D F x))
+  (A : Precategory l1 l2) (B : Precategory l3 l4) (C : Precategory l5 l6)
+  (G : functor-Precategory B C) (F : functor-Precategory A B)
+  where
+
+  obj-comp-functor-Precategory : obj-Precategory A → obj-Precategory C
+  obj-comp-functor-Precategory =
+    obj-functor-Precategory B C G ∘ obj-functor-Precategory A B F
+
+  hom-comp-functor-Precategory :
+    {x y : obj-Precategory A} →
+    hom-Precategory A x y →
+    hom-Precategory C
+      ( obj-comp-functor-Precategory x)
+      ( obj-comp-functor-Precategory y)
+  hom-comp-functor-Precategory =
+    hom-functor-Precategory B C G ∘ hom-functor-Precategory A B F
+
+  map-comp-functor-precategory : map-Precategory A C
+  pr1 map-comp-functor-precategory = obj-comp-functor-Precategory
+  pr2 map-comp-functor-precategory = hom-comp-functor-Precategory
+
+  preserves-comp-comp-functor-Precategory :
+    preserves-comp-hom-map-Precategory A C map-comp-functor-precategory
+  preserves-comp-comp-functor-Precategory g f =
+    ( ap
+      ( hom-functor-Precategory B C G)
+      ( preserves-comp-functor-Precategory A B F g f)) ∙
+    ( preserves-comp-functor-Precategory B C G
+      ( hom-functor-Precategory A B F g)
+      ( hom-functor-Precategory A B F f))
+
+  preserves-id-comp-functor-Precategory :
+    preserves-id-hom-map-Precategory A C map-comp-functor-precategory
+  preserves-id-comp-functor-Precategory x =
+    ( ap
+      ( hom-functor-Precategory B C G)
+      ( preserves-id-functor-Precategory A B F x)) ∙
+    ( preserves-id-functor-Precategory B C G
+      ( obj-functor-Precategory A B F x))
+
+  comp-functor-Precategory : functor-Precategory A C
+  pr1 comp-functor-Precategory = obj-comp-functor-Precategory
+  pr1 (pr2 comp-functor-Precategory) =
+    hom-functor-Precategory B C G ∘ hom-functor-Precategory A B F
+  pr1 (pr2 (pr2 comp-functor-Precategory)) =
+    preserves-comp-comp-functor-Precategory
+  pr2 (pr2 (pr2 comp-functor-Precategory)) =
+    preserves-id-comp-functor-Precategory
 ```
 
 ## Properties
@@ -202,22 +232,17 @@ module _
   is-prop-preserves-comp-hom-map-Precategory :
     is-prop (preserves-comp-hom-map-Precategory C D F)
   is-prop-preserves-comp-hom-map-Precategory =
-    is-prop-Π'
-      ( λ x →
-        is-prop-Π'
-          ( λ y →
-            is-prop-Π'
-              ( λ z →
-                is-prop-Π²
-                  ( λ g f →
-                    is-set-hom-Precategory D
-                      ( obj-map-Precategory C D F x)
-                      ( obj-map-Precategory C D F z)
-                      ( hom-map-Precategory C D F
-                        ( comp-hom-Precategory C g f))
-                      ( comp-hom-Precategory D
-                        ( hom-map-Precategory C D F g)
-                        ( hom-map-Precategory C D F f))))))
+    is-prop-iterated-implicit-Π 3
+      ( λ x y z →
+        is-prop-iterated-Π 2
+          ( λ g f →
+            is-set-hom-Precategory D
+              ( obj-map-Precategory C D F x)
+              ( obj-map-Precategory C D F z)
+              ( hom-map-Precategory C D F (comp-hom-Precategory C g f))
+              ( comp-hom-Precategory D
+                ( hom-map-Precategory C D F g)
+                ( hom-map-Precategory C D F f))))
 
   preserves-comp-hom-prop-map-Precategory : Prop (l1 ⊔ l2 ⊔ l4)
   pr1 preserves-comp-hom-prop-map-Precategory =
@@ -422,6 +447,126 @@ module _
       ( is-iso-iso-Precategory C f)
 ```
 
+### Categorical laws for functor composition
+
+#### Unit laws for functor composition
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2) (D : Precategory l3 l4)
+  (F : functor-Precategory C D)
+  where
+
+  left-unit-law-comp-functor-Precategory :
+    comp-functor-Precategory C D D (id-functor-Precategory D) F ＝ F
+  left-unit-law-comp-functor-Precategory =
+    eq-eq-map-functor-Precategory C D _ _ refl
+
+  right-unit-law-comp-functor-Precategory :
+    comp-functor-Precategory C C D F (id-functor-Precategory C) ＝ F
+  right-unit-law-comp-functor-Precategory = refl
+```
+
+#### Associativity of functor composition
+
+```agda
+module _
+  {l1 l1' l2 l2' l3 l3' l4 l4' : Level}
+  (A : Precategory l1 l1')
+  (B : Precategory l2 l2')
+  (C : Precategory l3 l3')
+  (D : Precategory l4 l4')
+  (F : functor-Precategory A B)
+  (G : functor-Precategory B C)
+  (H : functor-Precategory C D)
+  where
+
+  associative-comp-functor-Precategory :
+    comp-functor-Precategory A B D (comp-functor-Precategory B C D H G) F ＝
+    comp-functor-Precategory A C D H (comp-functor-Precategory A B C G F)
+  associative-comp-functor-Precategory =
+    eq-eq-map-functor-Precategory A D _ _ refl
+```
+
+#### MacLane pentagon for functor composition
+
+```text
+    (I(GH))F ---- I((GH)F)
+          /        \
+         /          \
+  ((IH)G)F          I(H(GF))
+          \        /
+            \    /
+           (IH)(GF)
+```
+
+The proof remains to be formalized.
+
+```text
+module _
+  {l1 l1' l2 l2' l3 l3' l4 l4' : Level}
+  (A : Precategory l1 l1')
+  (B : Precategory l2 l2')
+  (C : Precategory l3 l3')
+  (D : Precategory l4 l4')
+  (E : Precategory l4 l4')
+  (F : functor-Precategory A B)
+  (G : functor-Precategory B C)
+  (H : functor-Precategory C D)
+  (I : functor-Precategory D E)
+  where
+
+  mac-lane-pentagon-comp-functor-Precategory :
+    coherence-pentagon-identifications
+      { x =
+        comp-functor-Precategory A B E
+        ( comp-functor-Precategory B D E I
+          ( comp-functor-Precategory B C D H G))
+        ( F)}
+      { comp-functor-Precategory A D E I
+        ( comp-functor-Precategory A B D
+          ( comp-functor-Precategory B C D H G)
+          ( F))}
+      { comp-functor-Precategory A B E
+        ( comp-functor-Precategory B C E
+          ( comp-functor-Precategory C D E I H)
+          ( G))
+        ( F)}
+      { comp-functor-Precategory A D E
+        ( I)
+        ( comp-functor-Precategory A C D
+          ( H)
+          ( comp-functor-Precategory A B C G F))}
+      { comp-functor-Precategory A C E
+        ( comp-functor-Precategory C D E I H)
+        ( comp-functor-Precategory A B C G F)}
+      ( associative-comp-functor-Precategory A B D E
+        ( F) (comp-functor-Precategory B C D H G) (I))
+      ( ap
+        ( λ p → comp-functor-Precategory A B E p F)
+        ( inv (associative-comp-functor-Precategory B C D E G H I)))
+      ( ap
+        ( λ p → comp-functor-Precategory A D E I p)
+        ( associative-comp-functor-Precategory A B C D F G H))
+      ( associative-comp-functor-Precategory A B C E
+        ( F) (G) (comp-functor-Precategory C D E I H))
+      ( inv
+        ( associative-comp-functor-Precategory A C D E
+          (comp-functor-Precategory A B C G F) H I))
+  mac-lane-pentagon-comp-functor-Precategory = {!!}
+```
+
 ## See also
 
 - [The precategory of functors and natural transformations between precategories](category-theory.precategory-of-functors.md)
+
+## References
+
+1. Univalent Foundations Project, _Homotopy Type Theory – Univalent Foundations
+   of Mathematics_ (2013) ([website](https://homotopytypetheory.org/book/),
+   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729))
+2. Benedikt Ahrens and Krzysztof Kapulkin and Michael Shulman, _Univalent
+   Categories and the Rezk completion_ (2015)
+   ([arXiv:1303.0584](https://arxiv.org/abs/1303.0584),
+   [DOI:10.1017/S0960129514000486](https://doi.org/10.1017/S0960129514000486))
diff --git a/src/category-theory/gaunt-categories.lagda.md b/src/category-theory/gaunt-categories.lagda.md
new file mode 100644
index 0000000000..d902799dff
--- /dev/null
+++ b/src/category-theory/gaunt-categories.lagda.md
@@ -0,0 +1,359 @@
+# Gaunt categories
+
+```agda
+module category-theory.gaunt-categories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.categories
+open import category-theory.composition-operations-on-binary-families-of-sets
+open import category-theory.isomorphism-induction-categories
+open import category-theory.isomorphisms-in-categories
+open import category-theory.isomorphisms-in-precategories
+open import category-theory.nonunital-precategories
+open import category-theory.precategories
+open import category-theory.preunivalent-categories
+open import category-theory.rigid-objects-categories
+open import category-theory.strict-categories
+
+open import foundation.cartesian-product-types
+open import foundation.contractible-types
+open import foundation.dependent-pair-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sets
+open import foundation.universe-levels
+```
+
+</details>
+
+## Idea
+
+A **gaunt category** is a [category](category-theory.categories.md) such that
+one of the following equivalent conditions hold:
+
+1. The
+   [isomorphism](category-theory.isomorphisms-in-categories.md)-[sets](foundation-core.sets.md)
+   are [propositions](foundation-core.propositions.md).
+2. The objects form a set.
+3. Every object is [rigid](category-theory.rigid-objects-categories.md), meaning
+   its [automorphism group](group-theory.automorphism-groups.md) is
+   [trivial](group-theory.trivial-groups.md).
+
+Gaunt categories forms the common intersection of (univalent) categories and
+[strict categories](category-theory.strict-categories.md). We have the following
+diagram relating the different notions of "category":
+
+```text
+        Gaunt categories
+              /   \
+            /       \
+          v           v
+  Categories         Strict categories
+          \           /
+            \       /
+              v   v
+      Preunivalent categories
+                |
+                |
+                v
+          Precategories
+```
+
+## Definitions
+
+### The predicate on precategories that there is at most one isomorphism between any two objects
+
+```agda
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2)
+  where
+
+  is-prop-iso-prop-Precategory : Prop (l1 ⊔ l2)
+  is-prop-iso-prop-Precategory =
+    Π-Prop
+      ( obj-Precategory C)
+      ( λ x →
+        Π-Prop
+          ( obj-Precategory C)
+          ( λ y → is-prop-Prop (iso-Precategory C x y)))
+
+  is-prop-iso-Precategory : UU (l1 ⊔ l2)
+  is-prop-iso-Precategory = type-Prop is-prop-iso-prop-Precategory
+
+  is-property-is-prop-iso-Precategory : is-prop is-prop-iso-Precategory
+  is-property-is-prop-iso-Precategory =
+    is-prop-type-Prop is-prop-iso-prop-Precategory
+```
+
+### The predicate on precategories of being gaunt
+
+```agda
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2)
+  where
+
+  is-gaunt-prop-Precategory : Prop (l1 ⊔ l2)
+  is-gaunt-prop-Precategory =
+    prod-Prop (is-category-prop-Precategory C) (is-prop-iso-prop-Precategory C)
+
+  is-gaunt-Precategory : UU (l1 ⊔ l2)
+  is-gaunt-Precategory = type-Prop is-gaunt-prop-Precategory
+```
+
+### The predicate on categories of being gaunt
+
+```agda
+module _
+  {l1 l2 : Level} (C : Category l1 l2)
+  where
+
+  is-gaunt-prop-Category : Prop (l1 ⊔ l2)
+  is-gaunt-prop-Category = is-prop-iso-prop-Precategory (precategory-Category C)
+
+  is-gaunt-Category : UU (l1 ⊔ l2)
+  is-gaunt-Category = type-Prop is-gaunt-prop-Category
+```
+
+### The type of gaunt categories
+
+```agda
+Gaunt-Category : (l1 l2 : Level) → UU (lsuc l1 ⊔ lsuc l2)
+Gaunt-Category l1 l2 = Σ (Category l1 l2) (is-gaunt-Category)
+
+module _
+  {l1 l2 : Level} (C : Gaunt-Category l1 l2)
+  where
+
+  category-Gaunt-Category : Category l1 l2
+  category-Gaunt-Category = pr1 C
+
+  obj-Gaunt-Category : UU l1
+  obj-Gaunt-Category = obj-Category category-Gaunt-Category
+
+  hom-set-Gaunt-Category :
+    obj-Gaunt-Category → obj-Gaunt-Category → Set l2
+  hom-set-Gaunt-Category =
+    hom-set-Category category-Gaunt-Category
+
+  hom-Gaunt-Category :
+    obj-Gaunt-Category → obj-Gaunt-Category → UU l2
+  hom-Gaunt-Category = hom-Category category-Gaunt-Category
+
+  is-set-hom-Gaunt-Category :
+    (x y : obj-Gaunt-Category) → is-set (hom-Gaunt-Category x y)
+  is-set-hom-Gaunt-Category =
+    is-set-hom-Category category-Gaunt-Category
+
+  comp-hom-Gaunt-Category :
+    {x y z : obj-Gaunt-Category} →
+    hom-Gaunt-Category y z →
+    hom-Gaunt-Category x y →
+    hom-Gaunt-Category x z
+  comp-hom-Gaunt-Category =
+    comp-hom-Category category-Gaunt-Category
+
+  associative-comp-hom-Gaunt-Category :
+    {x y z w : obj-Gaunt-Category}
+    (h : hom-Gaunt-Category z w)
+    (g : hom-Gaunt-Category y z)
+    (f : hom-Gaunt-Category x y) →
+    comp-hom-Gaunt-Category (comp-hom-Gaunt-Category h g) f ＝
+    comp-hom-Gaunt-Category h (comp-hom-Gaunt-Category g f)
+  associative-comp-hom-Gaunt-Category =
+    associative-comp-hom-Category category-Gaunt-Category
+
+  associative-composition-operation-Gaunt-Category :
+    associative-composition-operation-binary-family-Set
+      hom-set-Gaunt-Category
+  associative-composition-operation-Gaunt-Category =
+    associative-composition-operation-Category
+      ( category-Gaunt-Category)
+
+  id-hom-Gaunt-Category :
+    {x : obj-Gaunt-Category} → hom-Gaunt-Category x x
+  id-hom-Gaunt-Category =
+    id-hom-Category category-Gaunt-Category
+
+  left-unit-law-comp-hom-Gaunt-Category :
+    {x y : obj-Gaunt-Category} (f : hom-Gaunt-Category x y) →
+    comp-hom-Gaunt-Category id-hom-Gaunt-Category f ＝ f
+  left-unit-law-comp-hom-Gaunt-Category =
+    left-unit-law-comp-hom-Category category-Gaunt-Category
+
+  right-unit-law-comp-hom-Gaunt-Category :
+    {x y : obj-Gaunt-Category} (f : hom-Gaunt-Category x y) →
+    comp-hom-Gaunt-Category f id-hom-Gaunt-Category ＝ f
+  right-unit-law-comp-hom-Gaunt-Category =
+    right-unit-law-comp-hom-Category category-Gaunt-Category
+
+  is-unital-composition-operation-Gaunt-Category :
+    is-unital-composition-operation-binary-family-Set
+      hom-set-Gaunt-Category
+      comp-hom-Gaunt-Category
+  is-unital-composition-operation-Gaunt-Category =
+    is-unital-composition-operation-Category
+      ( category-Gaunt-Category)
+
+  is-gaunt-Gaunt-Category :
+    is-gaunt-Category category-Gaunt-Category
+  is-gaunt-Gaunt-Category = pr2 C
+```
+
+### The underlying nonunital precategory of a gaunt category
+
+```agda
+nonunital-precategory-Gaunt-Category :
+  {l1 l2 : Level} → Gaunt-Category l1 l2 → Nonunital-Precategory l1 l2
+nonunital-precategory-Gaunt-Category C =
+  nonunital-precategory-Category (category-Gaunt-Category C)
+```
+
+### The underlying precategory of a gaunt category
+
+```agda
+precategory-Gaunt-Category :
+  {l1 l2 : Level} → Gaunt-Category l1 l2 → Precategory l1 l2
+precategory-Gaunt-Category C = precategory-Category (category-Gaunt-Category C)
+```
+
+### The underlying preunivalent category of a gaunt category
+
+```agda
+preunivalent-category-Gaunt-Category :
+  {l1 l2 : Level} → Gaunt-Category l1 l2 → Preunivalent-Category l1 l2
+preunivalent-category-Gaunt-Category C =
+  preunivalent-category-Category (category-Gaunt-Category C)
+```
+
+### The total hom-type of a gaunt category
+
+```agda
+total-hom-Gaunt-Category :
+  {l1 l2 : Level} (C : Gaunt-Category l1 l2) → UU (l1 ⊔ l2)
+total-hom-Gaunt-Category C =
+  total-hom-Category (category-Gaunt-Category C)
+
+obj-total-hom-Gaunt-Category :
+  {l1 l2 : Level} (C : Gaunt-Category l1 l2) →
+  total-hom-Gaunt-Category C →
+  obj-Gaunt-Category C × obj-Gaunt-Category C
+obj-total-hom-Gaunt-Category C =
+  obj-total-hom-Category (category-Gaunt-Category C)
+```
+
+### Equalities induce morphisms
+
+```agda
+module _
+  {l1 l2 : Level}
+  (C : Gaunt-Category l1 l2)
+  where
+
+  hom-eq-Gaunt-Category :
+    (x y : obj-Gaunt-Category C) → x ＝ y → hom-Gaunt-Category C x y
+  hom-eq-Gaunt-Category =
+    hom-eq-Category (category-Gaunt-Category C)
+
+  hom-inv-eq-Gaunt-Category :
+    (x y : obj-Gaunt-Category C) → x ＝ y → hom-Gaunt-Category C y x
+  hom-inv-eq-Gaunt-Category =
+    hom-inv-eq-Category (category-Gaunt-Category C)
+```
+
+## Properties
+
+### Preunivalent categories whose isomorphism-sets are propositions are strict categories
+
+```agda
+is-strict-category-is-prop-iso-Preunivalent-Category :
+  {l1 l2 : Level} (C : Preunivalent-Category l1 l2) →
+  is-prop-iso-Precategory (precategory-Preunivalent-Category C) →
+  is-strict-category-Preunivalent-Category C
+is-strict-category-is-prop-iso-Preunivalent-Category C is-prop-iso-C x y =
+  is-prop-emb (emb-iso-eq-Preunivalent-Category C) (is-prop-iso-C x y)
+```
+
+### Gaunt categories are strict
+
+```agda
+is-strict-category-is-gaunt-Category :
+  {l1 l2 : Level} (C : Category l1 l2) →
+  is-gaunt-Category C → is-strict-category-Category C
+is-strict-category-is-gaunt-Category C =
+  is-strict-category-is-prop-iso-Preunivalent-Category
+    ( preunivalent-category-Category C)
+```
+
+### A strict category is gaunt if `iso-eq` is surjective
+
+```agda
+module _
+  {l1 l2 : Level} (C : Strict-Category l1 l2)
+  where
+
+  is-category-is-surjective-iso-eq-Strict-Category :
+    is-surjective-iso-eq-Precategory (precategory-Strict-Category C) →
+    is-category-Precategory (precategory-Strict-Category C)
+  is-category-is-surjective-iso-eq-Strict-Category =
+    is-category-is-surjective-iso-eq-Preunivalent-Category
+      ( preunivalent-category-Strict-Category C)
+
+  is-prop-iso-is-category-Strict-Category :
+    is-category-Precategory (precategory-Strict-Category C) →
+    is-prop-iso-Precategory (precategory-Strict-Category C)
+  is-prop-iso-is-category-Strict-Category is-category-C x y =
+    is-prop-is-equiv' (is-category-C x y) (is-set-obj-Strict-Category C x y)
+
+  is-prop-iso-is-surjective-iso-eq-Strict-Category :
+    is-surjective-iso-eq-Precategory (precategory-Strict-Category C) →
+    is-prop-iso-Precategory (precategory-Strict-Category C)
+  is-prop-iso-is-surjective-iso-eq-Strict-Category is-surj-iso-eq-C =
+    is-prop-iso-is-category-Strict-Category
+      ( is-category-is-surjective-iso-eq-Strict-Category is-surj-iso-eq-C)
+
+  is-gaunt-is-surjective-iso-eq-Strict-Category :
+    is-surjective-iso-eq-Precategory (precategory-Strict-Category C) →
+    is-gaunt-Precategory (precategory-Strict-Category C)
+  pr1 (is-gaunt-is-surjective-iso-eq-Strict-Category is-surj-iso-eq-C) =
+    is-category-is-surjective-iso-eq-Strict-Category is-surj-iso-eq-C
+  pr2 (is-gaunt-is-surjective-iso-eq-Strict-Category is-surj-iso-eq-C) =
+    is-prop-iso-is-surjective-iso-eq-Strict-Category is-surj-iso-eq-C
+```
+
+### A category is gaunt if and only if every object is rigid
+
+**Proof:** Using the fact that a type is a
+[proposition](foundation-core.propositions.md) if and only if having an
+inhabitant implies it is [contractible](foundation-core.contractible-types.md),
+we can apply
+[isomorphism induction](category-theory.isomorphism-induction-categories.md) to
+get our result.
+
+```agda
+module _
+  {l1 l2 : Level} (C : Category l1 l2)
+  where
+
+  is-gaunt-is-rigid-Category :
+    ((x : obj-Category C) → is-rigid-obj-Category C x) → is-gaunt-Category C
+  is-gaunt-is-rigid-Category is-rigid-obj-C x y =
+    is-prop-is-proof-irrelevant (ind-iso-Category C _ (is-rigid-obj-C x))
+
+  is-rigid-is-gaunt-Category :
+    is-gaunt-Category C → (x : obj-Category C) → is-rigid-obj-Category C x
+  is-rigid-is-gaunt-Category is-gaunt-C x =
+    is-proof-irrelevant-is-prop (is-gaunt-C x x) (id-iso-Category C)
+```
+
+## See also
+
+- [Posets](order-theory.posets.md) are gaunt.
+
+## External links
+
+- [Gaunt (pre)categories](https://1lab.dev/Cat.Gaunt.html) at 1lab
+- [gaunt category](https://ncatlab.org/nlab/show/gaunt+category#in_type_theory)
+  at nlab
diff --git a/src/category-theory/isomorphism-induction-categories.lagda.md b/src/category-theory/isomorphism-induction-categories.lagda.md
index 5a9dd08498..a736c05d8a 100644
--- a/src/category-theory/isomorphism-induction-categories.lagda.md
+++ b/src/category-theory/isomorphism-induction-categories.lagda.md
@@ -29,8 +29,8 @@ open import foundation.universe-levels
 
 ## Idea
 
-**Isomorphism induction** in a category `𝒞` is the principle asserting that,
-given an object `A : 𝒞` and any type family
+**Isomorphism induction** in a [category](category-theory.categories.md) `𝒞` is
+the principle asserting that, given an object `A : 𝒞` and any type family
 
 ```text
   P : (B : 𝒞) (ϕ : A ≅ B) → 𝒰
diff --git a/src/category-theory/isomorphisms-in-categories.lagda.md b/src/category-theory/isomorphisms-in-categories.lagda.md
index 4937a6170b..ed3292cb95 100644
--- a/src/category-theory/isomorphisms-in-categories.lagda.md
+++ b/src/category-theory/isomorphisms-in-categories.lagda.md
@@ -557,13 +557,15 @@ module _
   {x y : obj-Category C}
   where
 
-  is-prop-iso-Category :
+  is-prop-iso-is-prop-hom-Category :
     is-prop (hom-Category C x y) → is-prop (iso-Category C x y)
-  is-prop-iso-Category = is-prop-iso-Precategory (precategory-Category C)
+  is-prop-iso-is-prop-hom-Category =
+    is-prop-iso-is-prop-hom-Precategory (precategory-Category C)
 
-  iso-prop-Category :
+  iso-prop-is-prop-hom-Category :
     is-prop (hom-Category C x y) → Prop l2
-  iso-prop-Category = iso-prop-Precategory (precategory-Category C)
+  iso-prop-is-prop-hom-Category =
+    iso-prop-is-prop-hom-Precategory (precategory-Category C)
 ```
 
 ### When `hom x y` and `hom y x` are propositions, it suffices to provide a morphism in each direction to construct an isomorphism
diff --git a/src/category-theory/isomorphisms-in-precategories.lagda.md b/src/category-theory/isomorphisms-in-precategories.lagda.md
index dce1b6d1aa..3b06e59939 100644
--- a/src/category-theory/isomorphisms-in-precategories.lagda.md
+++ b/src/category-theory/isomorphisms-in-precategories.lagda.md
@@ -14,6 +14,7 @@ open import foundation.cartesian-product-types
 open import foundation.dependent-pair-types
 open import foundation.equivalences
 open import foundation.function-types
+open import foundation.homotopies
 open import foundation.identity-types
 open import foundation.injective-maps
 open import foundation.propositions
@@ -432,6 +433,12 @@ module _
   pr1 (inv-iso-Precategory f) = hom-inv-iso-Precategory C f
   pr2 (inv-iso-Precategory f) =
     is-iso-inv-is-iso-Precategory C (is-iso-iso-Precategory C f)
+
+  is-iso-inv-iso-Precategory :
+    (f : iso-Precategory C x y) →
+    is-iso-Precategory C (hom-inv-iso-Precategory C f)
+  is-iso-inv-iso-Precategory f =
+    is-iso-iso-Precategory C (inv-iso-Precategory f)
 ```
 
 ### Groupoid laws of isomorphisms in precategories
@@ -519,6 +526,33 @@ module _
       ( is-section-hom-inv-iso-Precategory C f)
 ```
 
+### The inverse operation is a fibered involution on isomorphisms
+
+```agda
+module _
+  {l1 l2 : Level}
+  (C : Precategory l1 l2)
+  where
+
+  is-fibered-involution-inv-iso-Precategory :
+    {x y : obj-Precategory C} →
+    inv-iso-Precategory C {y} {x} ∘ inv-iso-Precategory C {x} {y} ~ id
+  is-fibered-involution-inv-iso-Precategory f = refl
+
+  is-equiv-inv-iso-Precategory :
+    {x y : obj-Precategory C} → is-equiv (inv-iso-Precategory C {x} {y})
+  is-equiv-inv-iso-Precategory =
+    is-equiv-is-invertible
+      ( inv-iso-Precategory C)
+      ( is-fibered-involution-inv-iso-Precategory)
+      ( is-fibered-involution-inv-iso-Precategory)
+
+  equiv-inv-iso-Precategory :
+    {x y : obj-Precategory C} → iso-Precategory C x y ≃ iso-Precategory C y x
+  pr1 equiv-inv-iso-Precategory = inv-iso-Precategory C
+  pr2 equiv-inv-iso-Precategory = is-equiv-inv-iso-Precategory
+```
+
 ### A morphism `f` is an isomorphism if and only if precomposition by `f` is an equivalence
 
 **Proof:** If `f` is an isomorphism with inverse `f⁻¹`, then precomposing with
@@ -686,15 +720,17 @@ module _
   {x y : obj-Precategory C}
   where
 
-  is-prop-iso-Precategory :
+  is-prop-iso-is-prop-hom-Precategory :
     is-prop (hom-Precategory C x y) → is-prop (iso-Precategory C x y)
-  is-prop-iso-Precategory = is-prop-type-subtype (is-iso-prop-Precategory C)
+  is-prop-iso-is-prop-hom-Precategory =
+    is-prop-type-subtype (is-iso-prop-Precategory C)
 
-  iso-prop-Precategory :
+  iso-prop-is-prop-hom-Precategory :
     is-prop (hom-Precategory C x y) → Prop l2
-  pr1 (iso-prop-Precategory _) = iso-Precategory C x y
-  pr2 (iso-prop-Precategory is-prop-hom-C-x-y) =
-    is-prop-iso-Precategory is-prop-hom-C-x-y
+  pr1 (iso-prop-is-prop-hom-Precategory is-prop-hom-C-x-y) =
+    iso-Precategory C x y
+  pr2 (iso-prop-is-prop-hom-Precategory is-prop-hom-C-x-y) =
+    is-prop-iso-is-prop-hom-Precategory is-prop-hom-C-x-y
 ```
 
 ### When `hom x y` and `hom y x` are propositions, it suffices to provide a morphism in each direction to construct an isomorphism
diff --git a/src/category-theory/isomorphisms-in-subprecategories.lagda.md b/src/category-theory/isomorphisms-in-subprecategories.lagda.md
new file mode 100644
index 0000000000..e0d8560de0
--- /dev/null
+++ b/src/category-theory/isomorphisms-in-subprecategories.lagda.md
@@ -0,0 +1,264 @@
+# Isomorphisms in subprecategories
+
+```agda
+module category-theory.isomorphisms-in-subprecategories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.isomorphisms-in-precategories
+open import category-theory.precategories
+open import category-theory.subprecategories
+
+open import foundation.action-on-identifications-functions
+open import foundation.dependent-pair-types
+open import foundation.propositions
+open import foundation.sets
+open import foundation.subtypes
+open import foundation.universe-levels
+```
+
+</details>
+
+## Definitions
+
+### Isomorphisms in subprecategories
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  {x y : obj-Subprecategory C P}
+  (f : hom-Subprecategory C P x y)
+  where
+
+  is-iso-prop-Subprecategory : Prop (l2 ⊔ l4)
+  is-iso-prop-Subprecategory =
+    is-iso-prop-Precategory (precategory-Subprecategory C P) {x} {y} f
+
+  is-iso-Subprecategory : UU (l2 ⊔ l4)
+  is-iso-Subprecategory = type-Prop is-iso-prop-Subprecategory
+
+  is-prop-is-iso-Subprecategory : is-prop is-iso-Subprecategory
+  is-prop-is-iso-Subprecategory = is-prop-type-Prop is-iso-prop-Subprecategory
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  (x y : obj-Subprecategory C P)
+  where
+
+  iso-set-Subprecategory : Set (l2 ⊔ l4)
+  iso-set-Subprecategory =
+    iso-set-Precategory (precategory-Subprecategory C P) {x} {y}
+
+  iso-Subprecategory : UU (l2 ⊔ l4)
+  iso-Subprecategory = type-Set iso-set-Subprecategory
+
+  is-set-iso-Subprecategory : is-set iso-Subprecategory
+  is-set-iso-Subprecategory = is-set-type-Set iso-set-Subprecategory
+```
+
+#### The predicate on an isomorphism proof of being contained in a subprecategory
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  {x y : obj-Subprecategory C P}
+  (f : hom-Subprecategory C P x y)
+  (is-iso-f : is-iso-Precategory C (inclusion-hom-Subprecategory C P x y f))
+  where
+
+  is-in-is-iso-prop-Subprecategory : Prop l4
+  is-in-is-iso-prop-Subprecategory =
+    subtype-hom-obj-subprecategory-Subprecategory C P y x
+      ( hom-inv-is-iso-Precategory C is-iso-f)
+
+  is-in-is-iso-Subprecategory : UU l4
+  is-in-is-iso-Subprecategory =
+    type-Prop is-in-is-iso-prop-Subprecategory
+
+  is-prop-is-in-is-iso-Subprecategory : is-prop is-in-is-iso-Subprecategory
+  is-prop-is-in-is-iso-Subprecategory =
+    is-prop-type-Prop is-in-is-iso-prop-Subprecategory
+
+  is-iso-is-in-is-iso-Subprecategory :
+    is-in-is-iso-Subprecategory → is-iso-Subprecategory C P f
+  pr1 (pr1 (is-iso-is-in-is-iso-Subprecategory is-in-is-iso-f)) =
+    hom-inv-is-iso-Precategory C is-iso-f
+  pr2 (pr1 (is-iso-is-in-is-iso-Subprecategory is-in-is-iso-f)) =
+    is-in-is-iso-f
+  pr1 (pr2 (is-iso-is-in-is-iso-Subprecategory is-in-is-iso-f)) =
+    eq-type-subtype
+      ( subtype-hom-obj-subprecategory-Subprecategory C P y y)
+      ( pr1 (pr2 is-iso-f))
+  pr2 (pr2 (is-iso-is-in-is-iso-Subprecategory is-in-is-iso-f)) =
+    eq-type-subtype
+      ( subtype-hom-obj-subprecategory-Subprecategory C P x x)
+      ( pr2 (pr2 is-iso-f))
+```
+
+#### The predicate on an isomorphism between objects in the subprecategory of being contained in the subprecategory
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  {x y : obj-Subprecategory C P}
+  (f :
+    iso-Precategory C
+      ( inclusion-obj-Subprecategory C P x)
+      ( inclusion-obj-Subprecategory C P y))
+  where
+
+  is-in-iso-obj-subprecategory-prop-Subprecategory : Prop l4
+  is-in-iso-obj-subprecategory-prop-Subprecategory =
+    Σ-Prop
+      ( subtype-hom-obj-subprecategory-Subprecategory C P x y
+        ( hom-iso-Precategory C f))
+      ( λ f₀ →
+        is-in-is-iso-prop-Subprecategory C P
+          ( hom-iso-Precategory C f , f₀)
+          ( is-iso-iso-Precategory C f))
+
+  is-in-iso-obj-subprecategory-Subprecategory : UU l4
+  is-in-iso-obj-subprecategory-Subprecategory =
+    type-Prop is-in-iso-obj-subprecategory-prop-Subprecategory
+
+  is-prop-is-in-iso-obj-subprecategory-Subprecategory :
+    is-prop is-in-iso-obj-subprecategory-Subprecategory
+  is-prop-is-in-iso-obj-subprecategory-Subprecategory =
+    is-prop-type-Prop is-in-iso-obj-subprecategory-prop-Subprecategory
+
+  is-iso-is-in-iso-obj-subprecategory-Subprecategory :
+    ((f₀ , f₁) : is-in-iso-obj-subprecategory-Subprecategory) →
+    is-iso-Subprecategory C P (hom-iso-Precategory C f , f₀)
+  is-iso-is-in-iso-obj-subprecategory-Subprecategory (f₀ , f₁) =
+    is-iso-is-in-is-iso-Subprecategory C P (pr1 f , f₀) (pr2 f) f₁
+
+  iso-is-in-iso-obj-subprecategory-Subprecategory :
+    is-in-iso-obj-subprecategory-Subprecategory → iso-Subprecategory C P x y
+  pr1 (pr1 (iso-is-in-iso-obj-subprecategory-Subprecategory is-in-iso-f)) =
+    hom-iso-Precategory C f
+  pr2 (pr1 (iso-is-in-iso-obj-subprecategory-Subprecategory is-in-iso-f)) =
+    pr1 is-in-iso-f
+  pr2 (iso-is-in-iso-obj-subprecategory-Subprecategory is-in-iso-f) =
+    is-iso-is-in-is-iso-Subprecategory C P _
+      ( is-iso-iso-Precategory C f)
+      ( pr2 is-in-iso-f)
+```
+
+#### The predicate on an isomorphism between any objects of being contained in the subprecategory
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  {x y : obj-Precategory C}
+  (f : iso-Precategory C x y)
+  where
+
+  is-in-iso-prop-Subprecategory : Prop (l3 ⊔ l4)
+  is-in-iso-prop-Subprecategory =
+    Σ-Prop
+      ( subtype-obj-Subprecategory C P x)
+      ( λ x₀ →
+        Σ-Prop
+          ( subtype-obj-Subprecategory C P y)
+          ( λ y₀ →
+            is-in-iso-obj-subprecategory-prop-Subprecategory C P
+              { x , x₀} {y , y₀} f))
+
+  is-in-iso-Subprecategory : UU (l3 ⊔ l4)
+  is-in-iso-Subprecategory = type-Prop is-in-iso-prop-Subprecategory
+
+  is-prop-is-in-iso-Subprecategory : is-prop is-in-iso-Subprecategory
+  is-prop-is-in-iso-Subprecategory =
+    is-prop-type-Prop is-in-iso-prop-Subprecategory
+
+  iso-is-in-iso-Subprecategory :
+    (is-in-iso-f : is-in-iso-Subprecategory) →
+    iso-Subprecategory C P (x , pr1 is-in-iso-f) (y , pr1 (pr2 is-in-iso-f))
+  iso-is-in-iso-Subprecategory is-in-iso-f =
+    iso-is-in-iso-obj-subprecategory-Subprecategory C P f
+      ( pr2 (pr2 is-in-iso-f))
+
+  is-iso-is-in-iso-Subprecategory :
+    ( is-in-iso-f : is-in-iso-Subprecategory) →
+    is-iso-Subprecategory C P
+      ( pr1 f , pr2 (pr1 (iso-is-in-iso-Subprecategory is-in-iso-f)))
+  is-iso-is-in-iso-Subprecategory is-in-iso-f =
+    pr2 (iso-is-in-iso-Subprecategory is-in-iso-f)
+```
+
+### If a subprecategory contains an object, it contains its identity ismorphism
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  (x : obj-Subprecategory C P)
+  where
+
+  is-iso-id-hom-Subprecategory :
+    is-iso-Subprecategory C P (id-hom-Subprecategory C P {x})
+  is-iso-id-hom-Subprecategory =
+    is-iso-id-hom-Precategory (precategory-Subprecategory C P)
+
+  is-in-is-iso-id-obj-subprecategory-Subprecategory :
+    is-in-is-iso-Subprecategory C P {x}
+      (id-hom-Subprecategory C P) (is-iso-id-hom-Precategory C)
+  is-in-is-iso-id-obj-subprecategory-Subprecategory =
+    contains-id-Subprecategory C P
+      ( inclusion-obj-Subprecategory C P x)
+      ( is-in-obj-inclusion-obj-Subprecategory C P x)
+
+  is-in-iso-id-obj-subprecategory-Subprecategory :
+    is-in-iso-obj-subprecategory-Subprecategory C P (id-iso-Precategory C)
+  pr1 is-in-iso-id-obj-subprecategory-Subprecategory =
+    is-in-is-iso-id-obj-subprecategory-Subprecategory
+  pr2 is-in-iso-id-obj-subprecategory-Subprecategory =
+    is-in-is-iso-id-obj-subprecategory-Subprecategory
+
+  is-in-iso-id-Subprecategory :
+    is-in-iso-Subprecategory C P (id-iso-Precategory C)
+  pr1 is-in-iso-id-Subprecategory = is-in-obj-inclusion-obj-Subprecategory C P x
+  pr1 (pr2 is-in-iso-id-Subprecategory) =
+    is-in-obj-inclusion-obj-Subprecategory C P x
+  pr2 (pr2 is-in-iso-id-Subprecategory) =
+    is-in-iso-id-obj-subprecategory-Subprecategory
+```
+
+## Properties
+
+### Isomorphisms in a subprecategory are isomorphisms in the base category
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  {x y : obj-Subprecategory C P}
+  where
+
+  is-iso-base-is-iso-Subprecategory :
+    {f : hom-Subprecategory C P x y} →
+    is-iso-Subprecategory C P f →
+    is-iso-Precategory C (inclusion-hom-Subprecategory C P x y f)
+  pr1 (is-iso-base-is-iso-Subprecategory is-iso-f) =
+    pr1 (pr1 is-iso-f)
+  pr1 (pr2 (is-iso-base-is-iso-Subprecategory is-iso-f)) =
+    ap pr1 (pr1 (pr2 (is-iso-f)))
+  pr2 (pr2 (is-iso-base-is-iso-Subprecategory is-iso-f)) =
+    ap pr1 (pr2 (pr2 (is-iso-f)))
+```
diff --git a/src/category-theory/large-subprecategories.lagda.md b/src/category-theory/large-subprecategories.lagda.md
index ecba71cf2f..efeeebbc58 100644
--- a/src/category-theory/large-subprecategories.lagda.md
+++ b/src/category-theory/large-subprecategories.lagda.md
@@ -89,8 +89,8 @@ module _
   (P : Large-Subprecategory γ δ C)
   where
 
-  is-in-subtype-obj-Large-Subprecategory :
+  is-in-obj-Large-Subprecategory :
     {l : Level} → obj-Large-Precategory C l → UU (γ l)
-  is-in-subtype-obj-Large-Subprecategory =
+  is-in-obj-Large-Subprecategory =
     is-in-subtype (subtype-obj-Large-Subprecategory P _)
 ```
diff --git a/src/category-theory/natural-isomorphisms-functors-categories.lagda.md b/src/category-theory/natural-isomorphisms-functors-categories.lagda.md
index 74a02c09b1..f8f8894aea 100644
--- a/src/category-theory/natural-isomorphisms-functors-categories.lagda.md
+++ b/src/category-theory/natural-isomorphisms-functors-categories.lagda.md
@@ -195,7 +195,7 @@ module _
       ( hom-family-natural-transformation-Category C D F G
         ( natural-transformation-natural-isomorphism-Category))
   coherence-square-natural-isomorphism-Category =
-    coherence-square-natural-transformation-Category C D F G
+    naturality-natural-transformation-Category C D F G
       ( natural-transformation-natural-isomorphism-Category)
 
   is-natural-isomorphism-natural-isomorphism-Category :
diff --git a/src/category-theory/natural-isomorphisms-functors-precategories.lagda.md b/src/category-theory/natural-isomorphisms-functors-precategories.lagda.md
index a7ca42e597..35a1b71552 100644
--- a/src/category-theory/natural-isomorphisms-functors-precategories.lagda.md
+++ b/src/category-theory/natural-isomorphisms-functors-precategories.lagda.md
@@ -177,7 +177,7 @@ module _
       ( hom-family-natural-transformation-Precategory C D F G
         ( natural-transformation-natural-isomorphism-Precategory))
   coherence-square-natural-isomorphism-Precategory =
-    coherence-square-natural-transformation-Precategory C D F G
+    naturality-natural-transformation-Precategory C D F G
       ( natural-transformation-natural-isomorphism-Precategory)
 
   is-natural-isomorphism-natural-isomorphism-Precategory :
diff --git a/src/category-theory/natural-isomorphisms-maps-categories.lagda.md b/src/category-theory/natural-isomorphisms-maps-categories.lagda.md
index af45614ba5..571c2723dc 100644
--- a/src/category-theory/natural-isomorphisms-maps-categories.lagda.md
+++ b/src/category-theory/natural-isomorphisms-maps-categories.lagda.md
@@ -194,7 +194,7 @@ module _
       ( hom-family-natural-transformation-map-Category C D F G
         ( natural-transformation-map-natural-isomorphism-map-Category))
   coherence-square-natural-isomorphism-map-Category =
-    coherence-square-natural-transformation-map-Category C D F G
+    naturality-natural-transformation-map-Category C D F G
       ( natural-transformation-map-natural-isomorphism-map-Category)
 
   is-natural-isomorphism-map-natural-isomorphism-map-Category :
diff --git a/src/category-theory/natural-isomorphisms-maps-precategories.lagda.md b/src/category-theory/natural-isomorphisms-maps-precategories.lagda.md
index 420e96b26f..1e2ff1ccc6 100644
--- a/src/category-theory/natural-isomorphisms-maps-precategories.lagda.md
+++ b/src/category-theory/natural-isomorphisms-maps-precategories.lagda.md
@@ -161,7 +161,7 @@ module _
       ( hom-family-natural-transformation-map-Precategory C D F G
         ( natural-transformation-map-natural-isomorphism-map-Precategory))
   coherence-square-natural-isomorphism-map-Precategory =
-    coherence-square-natural-transformation-map-Precategory C D F G
+    naturality-natural-transformation-map-Precategory C D F G
       ( natural-transformation-map-natural-isomorphism-map-Precategory)
 
   is-natural-isomorphism-map-natural-isomorphism-map-Precategory :
@@ -415,7 +415,7 @@ module _
         ( ap
           ( comp-hom-Precategory' D _)
           ( inv
-            ( coherence-square-natural-transformation-map-Precategory
+            ( naturality-natural-transformation-map-Precategory
                 C D F G f g))) ∙
         ( associative-comp-hom-Precategory D
           ( hom-map-Precategory C D G g)
diff --git a/src/category-theory/natural-transformations-functors-categories.lagda.md b/src/category-theory/natural-transformations-functors-categories.lagda.md
index 66303411bd..31ddf1de0b 100644
--- a/src/category-theory/natural-transformations-functors-categories.lagda.md
+++ b/src/category-theory/natural-transformations-functors-categories.lagda.md
@@ -74,12 +74,12 @@ module _
       ( F)
       ( G)
 
-  coherence-square-natural-transformation-Category :
+  naturality-natural-transformation-Category :
     (γ : natural-transformation-Category) →
     is-natural-transformation-Category
       ( hom-family-natural-transformation-Category γ)
-  coherence-square-natural-transformation-Category =
-    coherence-square-natural-transformation-Precategory
+  naturality-natural-transformation-Category =
+    naturality-natural-transformation-Precategory
       ( precategory-Category C)
       ( precategory-Category D)
       ( F)
diff --git a/src/category-theory/natural-transformations-functors-from-small-to-large-categories.lagda.md b/src/category-theory/natural-transformations-functors-from-small-to-large-categories.lagda.md
new file mode 100644
index 0000000000..53da547b30
--- /dev/null
+++ b/src/category-theory/natural-transformations-functors-from-small-to-large-categories.lagda.md
@@ -0,0 +1,245 @@
+# Natural transformations between functors from small to large categories
+
+```agda
+module category-theory.natural-transformations-functors-from-small-to-large-categories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.categories
+open import category-theory.functors-from-small-to-large-categories
+open import category-theory.large-categories
+open import category-theory.natural-transformations-functors-from-small-to-large-precategories
+
+open import foundation.dependent-pair-types
+open import foundation.embeddings
+open import foundation.equivalences
+open import foundation.homotopies
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sets
+open import foundation.universe-levels
+```
+
+</details>
+
+## Idea
+
+Given a small [category](category-theory.categories.md) `C` and a
+[large category](category-theory.large-categories.md) `D`, a **natural
+transformation** from a
+[functor](category-theory.functors-from-small-to-large-categories.md)
+`F : C → D` to `G : C → D` consists of :
+
+- a family of morphisms `a : (x : C) → hom (F x) (G x)` such that the following
+  identity holds:
+- `(G f) ∘ (a x) = (a y) ∘ (F f)`, for all `f : hom x y`.
+
+## Definition
+
+```agda
+module _
+  {l1 l2 γF γG : Level} {α : Level → Level} {β : Level → Level → Level}
+  (C : Category l1 l2)
+  (D : Large-Category α β)
+  (F : functor-Small-Large-Category C D γF)
+  (G : functor-Small-Large-Category C D γG)
+  where
+
+  hom-family-functor-Small-Large-Category : UU (l1 ⊔ β γF γG)
+  hom-family-functor-Small-Large-Category =
+    hom-family-functor-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  is-natural-transformation-Small-Large-Category :
+    hom-family-functor-Small-Large-Category → UU (l1 ⊔ l2 ⊔ β γF γG)
+  is-natural-transformation-Small-Large-Category =
+    is-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  natural-transformation-Small-Large-Category : UU (l1 ⊔ l2 ⊔ β γF γG)
+  natural-transformation-Small-Large-Category =
+    natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  hom-family-natural-transformation-Small-Large-Category :
+    natural-transformation-Small-Large-Category →
+    hom-family-functor-Small-Large-Category
+  hom-family-natural-transformation-Small-Large-Category =
+    hom-family-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  naturality-natural-transformation-Small-Large-Category :
+    (γ : natural-transformation-Small-Large-Category) →
+    is-natural-transformation-Small-Large-Category
+      ( hom-family-natural-transformation-Small-Large-Category γ)
+  naturality-natural-transformation-Small-Large-Category =
+    naturality-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+```
+
+## Composition and identity of natural transformations
+
+```agda
+module _
+  {l1 l2 : Level} {α : Level → Level} {β : Level → Level → Level}
+  (C : Category l1 l2)
+  (D : Large-Category α β)
+  where
+
+  id-natural-transformation-Small-Large-Category :
+    {γF : Level} (F : functor-Small-Large-Category C D γF) →
+    natural-transformation-Small-Large-Category C D F F
+  id-natural-transformation-Small-Large-Category =
+    id-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D)
+
+  comp-natural-transformation-Small-Large-Category :
+    {γF γG γH : Level}
+    (F : functor-Small-Large-Category C D γF)
+    (G : functor-Small-Large-Category C D γG)
+    (H : functor-Small-Large-Category C D γH) →
+    natural-transformation-Small-Large-Category C D G H →
+    natural-transformation-Small-Large-Category C D F G →
+    natural-transformation-Small-Large-Category C D F H
+  comp-natural-transformation-Small-Large-Category =
+    comp-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D)
+```
+
+## Properties
+
+### That a family of morphisms is a natural transformation is a proposition
+
+This follows from the fact that the hom-types are
+[sets](foundation-core.sets.md).
+
+```agda
+module _
+  {l1 l2 γF γG : Level} {α : Level → Level} {β : Level → Level → Level}
+  (C : Category l1 l2)
+  (D : Large-Category α β)
+  (F : functor-Small-Large-Category C D γF)
+  (G : functor-Small-Large-Category C D γG)
+  where
+
+  is-prop-is-natural-transformation-Small-Large-Category :
+    (γ : hom-family-functor-Small-Large-Category C D F G) →
+    is-prop (is-natural-transformation-Small-Large-Category C D F G γ)
+  is-prop-is-natural-transformation-Small-Large-Category =
+    is-prop-is-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  is-natural-transformation-prop-Small-Large-Category :
+    (γ : hom-family-functor-Small-Large-Category C D F G) →
+    Prop (l1 ⊔ l2 ⊔ β γF γG)
+  is-natural-transformation-prop-Small-Large-Category =
+    is-natural-transformation-prop-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+```
+
+### The set of natural transformations
+
+```agda
+module _
+  {l1 l2 γF γG : Level} {α : Level → Level} {β : Level → Level → Level}
+  (C : Category l1 l2)
+  (D : Large-Category α β)
+  (F : functor-Small-Large-Category C D γF)
+  (G : functor-Small-Large-Category C D γG)
+  where
+
+  is-emb-hom-family-natural-transformation-Small-Large-Category :
+    is-emb (hom-family-natural-transformation-Small-Large-Category C D F G)
+  is-emb-hom-family-natural-transformation-Small-Large-Category =
+    is-emb-hom-family-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  emb-hom-family-natural-transformation-Small-Large-Category :
+    natural-transformation-Small-Large-Category C D F G ↪
+    hom-family-functor-Small-Large-Category C D F G
+  emb-hom-family-natural-transformation-Small-Large-Category =
+    emb-hom-family-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  is-set-natural-transformation-Small-Large-Category :
+    is-set (natural-transformation-Small-Large-Category C D F G)
+  is-set-natural-transformation-Small-Large-Category =
+    is-set-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  natural-transformation-set-Small-Large-Category :
+    Set (l1 ⊔ l2 ⊔ β γF γG)
+  pr1 (natural-transformation-set-Small-Large-Category) =
+    natural-transformation-Small-Large-Category C D F G
+  pr2 (natural-transformation-set-Small-Large-Category) =
+    is-set-natural-transformation-Small-Large-Category
+
+  extensionality-natural-transformation-Small-Large-Category :
+    (a b : natural-transformation-Small-Large-Category C D F G) →
+    ( a ＝ b) ≃
+    ( hom-family-natural-transformation-Small-Large-Category C D F G a ~
+      hom-family-natural-transformation-Small-Large-Category C D F G b)
+  extensionality-natural-transformation-Small-Large-Category =
+    extensionality-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+
+  eq-htpy-hom-family-natural-transformation-Small-Large-Category :
+    (a b : natural-transformation-Small-Large-Category C D F G) →
+    ( hom-family-natural-transformation-Small-Large-Category C D F G a ~
+      hom-family-natural-transformation-Small-Large-Category C D F G b) →
+    a ＝ b
+  eq-htpy-hom-family-natural-transformation-Small-Large-Category =
+    eq-htpy-hom-family-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D) F G
+```
+
+### Categorical laws for natural transformations
+
+```agda
+module _
+  {l1 l2 : Level} {α : Level → Level} {β : Level → Level → Level}
+  (C : Category l1 l2)
+  (D : Large-Category α β)
+  where
+
+  right-unit-law-comp-natural-transformation-Small-Large-Category :
+    {γF γG : Level}
+    (F : functor-Small-Large-Category C D γF)
+    (G : functor-Small-Large-Category C D γG)
+    (a : natural-transformation-Small-Large-Category C D F G) →
+    comp-natural-transformation-Small-Large-Category C D F F G a
+      ( id-natural-transformation-Small-Large-Category C D F) ＝ a
+  right-unit-law-comp-natural-transformation-Small-Large-Category =
+    right-unit-law-comp-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D)
+
+  left-unit-law-comp-natural-transformation-Small-Large-Category :
+    {γF γG : Level}
+    (F : functor-Small-Large-Category C D γF)
+    (G : functor-Small-Large-Category C D γG)
+    (a : natural-transformation-Small-Large-Category C D F G) →
+    comp-natural-transformation-Small-Large-Category C D F G G
+      ( id-natural-transformation-Small-Large-Category C D G) a ＝ a
+  left-unit-law-comp-natural-transformation-Small-Large-Category =
+    left-unit-law-comp-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D)
+
+  associative-comp-natural-transformation-Small-Large-Category :
+    {γF γG γH γI : Level}
+    (F : functor-Small-Large-Category C D γF)
+    (G : functor-Small-Large-Category C D γG)
+    (H : functor-Small-Large-Category C D γH)
+    (I : functor-Small-Large-Category C D γI)
+    (a : natural-transformation-Small-Large-Category C D F G)
+    (b : natural-transformation-Small-Large-Category C D G H)
+    (c : natural-transformation-Small-Large-Category C D H I) →
+    comp-natural-transformation-Small-Large-Category C D F G I
+      ( comp-natural-transformation-Small-Large-Category C D G H I c b) a ＝
+    comp-natural-transformation-Small-Large-Category C D F H I c
+      ( comp-natural-transformation-Small-Large-Category C D F G H b a)
+  associative-comp-natural-transformation-Small-Large-Category =
+    associative-comp-natural-transformation-Small-Large-Precategory
+      ( precategory-Category C) (large-precategory-Large-Category D)
+```
diff --git a/src/category-theory/natural-transformations-functors-from-small-to-large-precategories.lagda.md b/src/category-theory/natural-transformations-functors-from-small-to-large-precategories.lagda.md
index 1df426695b..b74325623b 100644
--- a/src/category-theory/natural-transformations-functors-from-small-to-large-precategories.lagda.md
+++ b/src/category-theory/natural-transformations-functors-from-small-to-large-precategories.lagda.md
@@ -74,12 +74,12 @@ module _
       ( map-functor-Small-Large-Precategory C D F)
       ( map-functor-Small-Large-Precategory C D G)
 
-  coherence-square-natural-transformation-Small-Large-Precategory :
+  naturality-natural-transformation-Small-Large-Precategory :
     (γ : natural-transformation-Small-Large-Precategory) →
     is-natural-transformation-Small-Large-Precategory
       ( hom-family-natural-transformation-Small-Large-Precategory γ)
-  coherence-square-natural-transformation-Small-Large-Precategory =
-    coherence-square-natural-transformation-map-Small-Large-Precategory C D
+  naturality-natural-transformation-Small-Large-Precategory =
+    naturality-natural-transformation-map-Small-Large-Precategory C D
       ( map-functor-Small-Large-Precategory C D F)
       ( map-functor-Small-Large-Precategory C D G)
 ```
diff --git a/src/category-theory/natural-transformations-functors-precategories.lagda.md b/src/category-theory/natural-transformations-functors-precategories.lagda.md
index fc103c786c..b2e8a178af 100644
--- a/src/category-theory/natural-transformations-functors-precategories.lagda.md
+++ b/src/category-theory/natural-transformations-functors-precategories.lagda.md
@@ -69,12 +69,12 @@ module _
       ( map-functor-Precategory C D F)
       ( map-functor-Precategory C D G)
 
-  coherence-square-natural-transformation-Precategory :
+  naturality-natural-transformation-Precategory :
     (γ : natural-transformation-Precategory) →
     is-natural-transformation-Precategory
       ( hom-family-natural-transformation-Precategory γ)
-  coherence-square-natural-transformation-Precategory =
-    coherence-square-natural-transformation-map-Precategory C D
+  naturality-natural-transformation-Precategory =
+    naturality-natural-transformation-map-Precategory C D
       ( map-functor-Precategory C D F)
       ( map-functor-Precategory C D G)
 ```
diff --git a/src/category-theory/natural-transformations-maps-categories.lagda.md b/src/category-theory/natural-transformations-maps-categories.lagda.md
index 8cb719604a..04e78aa05e 100644
--- a/src/category-theory/natural-transformations-maps-categories.lagda.md
+++ b/src/category-theory/natural-transformations-maps-categories.lagda.md
@@ -74,12 +74,12 @@ module _
       ( F)
       ( G)
 
-  coherence-square-natural-transformation-map-Category :
+  naturality-natural-transformation-map-Category :
     (γ : natural-transformation-map-Category) →
     is-natural-transformation-map-Category
       ( hom-family-natural-transformation-map-Category γ)
-  coherence-square-natural-transformation-map-Category =
-    coherence-square-natural-transformation-map-Precategory
+  naturality-natural-transformation-map-Category =
+    naturality-natural-transformation-map-Precategory
       ( precategory-Category C)
       ( precategory-Category D)
       ( F)
diff --git a/src/category-theory/natural-transformations-maps-from-small-to-large-precategories.lagda.md b/src/category-theory/natural-transformations-maps-from-small-to-large-precategories.lagda.md
index 1e5424b966..054aa20477 100644
--- a/src/category-theory/natural-transformations-maps-from-small-to-large-precategories.lagda.md
+++ b/src/category-theory/natural-transformations-maps-from-small-to-large-precategories.lagda.md
@@ -58,10 +58,10 @@ module _
       ( obj-map-Small-Large-Precategory C D F x)
       ( obj-map-Small-Large-Precategory C D G x)
 
-  coherence-square-hom-family-map-Small-Large-Precategory :
+  naturality-hom-family-map-Small-Large-Precategory :
     hom-family-map-Small-Large-Precategory →
     {x y : obj-Precategory C} (f : hom-Precategory C x y) → UU (β γF γG)
-  coherence-square-hom-family-map-Small-Large-Precategory γ {x} {y} f =
+  naturality-hom-family-map-Small-Large-Precategory γ {x} {y} f =
     coherence-square-hom-Large-Precategory D
       ( hom-map-Small-Large-Precategory C D F f)
       ( γ x)
@@ -72,7 +72,7 @@ module _
     hom-family-map-Small-Large-Precategory → UU (l1 ⊔ l2 ⊔ β γF γG)
   is-natural-transformation-map-Small-Large-Precategory γ =
     {x y : obj-Precategory C} (f : hom-Precategory C x y) →
-    coherence-square-hom-family-map-Small-Large-Precategory γ f
+    naturality-hom-family-map-Small-Large-Precategory γ f
 
   natural-transformation-map-Small-Large-Precategory : UU (l1 ⊔ l2 ⊔ β γF γG)
   natural-transformation-map-Small-Large-Precategory =
@@ -84,11 +84,11 @@ module _
     hom-family-map-Small-Large-Precategory
   hom-family-natural-transformation-map-Small-Large-Precategory = pr1
 
-  coherence-square-natural-transformation-map-Small-Large-Precategory :
+  naturality-natural-transformation-map-Small-Large-Precategory :
     (γ : natural-transformation-map-Small-Large-Precategory) →
     is-natural-transformation-map-Small-Large-Precategory
       ( hom-family-natural-transformation-map-Small-Large-Precategory γ)
-  coherence-square-natural-transformation-map-Small-Large-Precategory = pr2
+  naturality-natural-transformation-map-Small-Large-Precategory = pr2
 ```
 
 ## Composition and identity of natural transformations
@@ -140,7 +140,7 @@ module _
       ( comp-hom-Large-Precategory' D
         ( hom-family-natural-transformation-map-Small-Large-Precategory
             C D F G α X))
-      ( coherence-square-natural-transformation-map-Small-Large-Precategory
+      ( naturality-natural-transformation-map-Small-Large-Precategory
           C D G H β f)) ∙
     ( associative-comp-hom-Large-Precategory D
       ( hom-family-natural-transformation-map-Small-Large-Precategory
@@ -152,7 +152,7 @@ module _
       ( comp-hom-Large-Precategory D
         ( hom-family-natural-transformation-map-Small-Large-Precategory
             C D G H β Y))
-      ( coherence-square-natural-transformation-map-Small-Large-Precategory
+      ( naturality-natural-transformation-map-Small-Large-Precategory
           C D F G α f)) ∙
     ( inv
       ( associative-comp-hom-Large-Precategory D
diff --git a/src/category-theory/natural-transformations-maps-precategories.lagda.md b/src/category-theory/natural-transformations-maps-precategories.lagda.md
index 060154f9a0..f130e7ef49 100644
--- a/src/category-theory/natural-transformations-maps-precategories.lagda.md
+++ b/src/category-theory/natural-transformations-maps-precategories.lagda.md
@@ -55,10 +55,10 @@ module _
       ( obj-map-Precategory C D F x)
       ( obj-map-Precategory C D G x)
 
-  coherence-square-hom-family-map-Precategory :
+  naturality-hom-family-map-Precategory :
     hom-family-map-Precategory →
     {x y : obj-Precategory C} (f : hom-Precategory C x y) → UU l4
-  coherence-square-hom-family-map-Precategory γ {x} {y} f =
+  naturality-hom-family-map-Precategory γ {x} {y} f =
     coherence-square-hom-Precategory D
       ( hom-map-Precategory C D F f)
       ( γ x)
@@ -69,7 +69,7 @@ module _
     hom-family-map-Precategory → UU (l1 ⊔ l2 ⊔ l4)
   is-natural-transformation-map-Precategory γ =
     {x y : obj-Precategory C} (f : hom-Precategory C x y) →
-    coherence-square-hom-family-map-Precategory γ f
+    naturality-hom-family-map-Precategory γ f
 
   natural-transformation-map-Precategory : UU (l1 ⊔ l2 ⊔ l4)
   natural-transformation-map-Precategory =
@@ -80,11 +80,11 @@ module _
     natural-transformation-map-Precategory → hom-family-map-Precategory
   hom-family-natural-transformation-map-Precategory = pr1
 
-  coherence-square-natural-transformation-map-Precategory :
+  naturality-natural-transformation-map-Precategory :
     (γ : natural-transformation-map-Precategory) →
     is-natural-transformation-map-Precategory
       ( hom-family-natural-transformation-map-Precategory γ)
-  coherence-square-natural-transformation-map-Precategory = pr2
+  naturality-natural-transformation-map-Precategory = pr2
 ```
 
 ## Composition and identity of natural transformations
@@ -124,7 +124,7 @@ module _
     ( ap
       ( comp-hom-Precategory' D
         ( hom-family-natural-transformation-map-Precategory C D F G α X))
-      ( coherence-square-natural-transformation-map-Precategory C D G H β f)) ∙
+      ( naturality-natural-transformation-map-Precategory C D G H β f)) ∙
     ( associative-comp-hom-Precategory D
       ( hom-family-natural-transformation-map-Precategory C D G H β Y)
       ( hom-map-Precategory C D G f)
@@ -132,7 +132,7 @@ module _
     ( ap
       ( comp-hom-Precategory D
         ( hom-family-natural-transformation-map-Precategory C D G H β Y))
-      ( coherence-square-natural-transformation-map-Precategory C D F G α f)) ∙
+      ( naturality-natural-transformation-map-Precategory C D F G α f)) ∙
     ( inv
       ( associative-comp-hom-Precategory D
         ( hom-family-natural-transformation-map-Precategory C D G H β Y)
diff --git a/src/category-theory/nonunital-precategories.lagda.md b/src/category-theory/nonunital-precategories.lagda.md
index 57edb55811..f758d636a4 100644
--- a/src/category-theory/nonunital-precategories.lagda.md
+++ b/src/category-theory/nonunital-precategories.lagda.md
@@ -14,6 +14,8 @@ open import foundation.dependent-pair-types
 open import foundation.identity-types
 open import foundation.propositions
 open import foundation.sets
+open import foundation.truncated-types
+open import foundation.truncation-levels
 open import foundation.universe-levels
 ```
 
@@ -169,6 +171,39 @@ module _
       ( comp-hom-Nonunital-Precategory C)
 ```
 
+## Properties
+
+### If the objects of a nonunital precategory are `k`-truncated for non-negative `k`, the total hom-type is `k`-truncated
+
+```agda
+module _
+  {l1 l2 : Level} {k : 𝕋} (C : Nonunital-Precategory l1 l2)
+  where
+
+  is-trunc-total-hom-is-trunc-obj-Nonunital-Precategory :
+    is-trunc (succ-𝕋 (succ-𝕋 k)) (obj-Nonunital-Precategory C) →
+    is-trunc (succ-𝕋 (succ-𝕋 k)) (total-hom-Nonunital-Precategory C)
+  is-trunc-total-hom-is-trunc-obj-Nonunital-Precategory is-trunc-obj-C =
+    is-trunc-Σ
+      ( is-trunc-obj-C)
+      ( λ x →
+        is-trunc-Σ
+          ( is-trunc-obj-C)
+          ( λ y → is-trunc-is-set k (is-set-hom-Nonunital-Precategory C x y)))
+
+  total-hom-truncated-type-is-trunc-obj-Nonunital-Precategory :
+    is-trunc (succ-𝕋 (succ-𝕋 k)) (obj-Nonunital-Precategory C) →
+    Truncated-Type (l1 ⊔ l2) (succ-𝕋 (succ-𝕋 k))
+  pr1
+    ( total-hom-truncated-type-is-trunc-obj-Nonunital-Precategory
+      is-trunc-obj-C) =
+    total-hom-Nonunital-Precategory C
+  pr2
+    ( total-hom-truncated-type-is-trunc-obj-Nonunital-Precategory
+      is-trunc-obj-C) =
+    is-trunc-total-hom-is-trunc-obj-Nonunital-Precategory is-trunc-obj-C
+```
+
 ## Comments
 
 As discussed in [Semicategories](https://ncatlab.org/nlab/show/semicategory) at
diff --git a/src/category-theory/opposite-categories.lagda.md b/src/category-theory/opposite-categories.lagda.md
new file mode 100644
index 0000000000..b6b18e96af
--- /dev/null
+++ b/src/category-theory/opposite-categories.lagda.md
@@ -0,0 +1,159 @@
+# Opposite categories
+
+```agda
+module category-theory.opposite-categories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.categories
+open import category-theory.isomorphisms-in-precategories
+open import category-theory.opposite-precategories
+open import category-theory.precategories
+
+open import foundation.dependent-pair-types
+open import foundation.equivalences
+open import foundation.identity-types
+open import foundation.involutions
+open import foundation.sets
+open import foundation.subtypes
+open import foundation.transport-along-identifications
+open import foundation.universe-levels
+```
+
+</details>
+
+## Idea
+
+Let `C` be a [category](category-theory.categories.md), its **opposite
+category** `Cᵒᵖ` is given by reversing every morphism.
+
+## Lemma
+
+### The underlying precategory is a category if and only if the opposite is a category
+
+```agda
+abstract
+  is-category-opposite-is-category-Precategory :
+    {l1 l2 : Level} (C : Precategory l1 l2) →
+    is-category-Precategory C →
+    is-category-Precategory (opposite-Precategory C)
+  is-category-opposite-is-category-Precategory C is-category-C x y =
+    is-equiv-htpy-equiv
+      ( compute-iso-opposite-Precategory C ∘e
+        equiv-inv-iso-Precategory C ∘e
+        (_ , is-category-C x y))
+      ( λ where
+        refl →
+          eq-type-subtype
+            ( is-iso-prop-Precategory (opposite-Precategory C))
+            ( refl))
+
+abstract
+  is-category-is-category-opposite-Precategory :
+    {l1 l2 : Level} (C : Precategory l1 l2) →
+    is-category-Precategory (opposite-Precategory C) →
+    is-category-Precategory C
+  is-category-is-category-opposite-Precategory C is-category-op-C =
+    tr
+      ( is-category-Precategory)
+      ( is-involution-opposite-Precategory C)
+      ( is-category-opposite-is-category-Precategory
+        ( opposite-Precategory C)
+        ( is-category-op-C))
+```
+
+## Definitions
+
+### The opposite category
+
+```agda
+module _
+  {l1 l2 : Level} (C : Category l1 l2)
+  where
+
+  obj-opposite-Category : UU l1
+  obj-opposite-Category = obj-opposite-Precategory (precategory-Category C)
+
+  hom-set-opposite-Category : (x y : obj-opposite-Category) → Set l2
+  hom-set-opposite-Category =
+    hom-set-opposite-Precategory (precategory-Category C)
+
+  hom-opposite-Category : (x y : obj-opposite-Category) → UU l2
+  hom-opposite-Category = hom-opposite-Precategory (precategory-Category C)
+
+  comp-hom-opposite-Category :
+    {x y z : obj-opposite-Category} →
+    hom-opposite-Category y z →
+    hom-opposite-Category x y →
+    hom-opposite-Category x z
+  comp-hom-opposite-Category =
+    comp-hom-opposite-Precategory (precategory-Category C)
+
+  associative-comp-hom-opposite-Category :
+    {x y z w : obj-opposite-Category}
+    (h : hom-opposite-Category z w)
+    (g : hom-opposite-Category y z)
+    (f : hom-opposite-Category x y) →
+    ( comp-hom-opposite-Category (comp-hom-opposite-Category h g) f) ＝
+    ( comp-hom-opposite-Category h (comp-hom-opposite-Category g f))
+  associative-comp-hom-opposite-Category =
+    associative-comp-hom-opposite-Precategory (precategory-Category C)
+
+  id-hom-opposite-Category :
+    {x : obj-opposite-Category} → hom-opposite-Category x x
+  id-hom-opposite-Category =
+    id-hom-opposite-Precategory (precategory-Category C)
+
+  left-unit-law-comp-hom-opposite-Category :
+    {x y : obj-opposite-Category}
+    (f : hom-opposite-Category x y) →
+    comp-hom-opposite-Category id-hom-opposite-Category f ＝ f
+  left-unit-law-comp-hom-opposite-Category =
+    left-unit-law-comp-hom-opposite-Precategory (precategory-Category C)
+
+  right-unit-law-comp-hom-opposite-Category :
+    {x y : obj-opposite-Category} (f : hom-opposite-Category x y) →
+    comp-hom-opposite-Category f id-hom-opposite-Category ＝ f
+  right-unit-law-comp-hom-opposite-Category =
+    right-unit-law-comp-hom-opposite-Precategory (precategory-Category C)
+
+  precategory-opposite-Category : Precategory l1 l2
+  precategory-opposite-Category = opposite-Precategory (precategory-Category C)
+
+  opposite-Category : Category l1 l2
+  pr1 opposite-Category = precategory-opposite-Category
+  pr2 opposite-Category =
+    is-category-opposite-is-category-Precategory
+      ( precategory-Category C)
+      ( is-category-Category C)
+```
+
+## Properties
+
+### The opposite category construction is an involution on the type of categories
+
+```agda
+is-involution-opposite-Category :
+  {l1 l2 : Level} → is-involution (opposite-Category {l1} {l2})
+is-involution-opposite-Category C =
+  eq-type-subtype
+    ( is-category-prop-Precategory)
+    ( is-involution-opposite-Precategory (precategory-Category C))
+
+involution-opposite-Category :
+  (l1 l2 : Level) → involution (Category l1 l2)
+pr1 (involution-opposite-Category l1 l2) = opposite-Category
+pr2 (involution-opposite-Category l1 l2) = is-involution-opposite-Category
+
+is-equiv-opposite-Category :
+  {l1 l2 : Level} → is-equiv (opposite-Category {l1} {l2})
+is-equiv-opposite-Category =
+  is-equiv-is-involution is-involution-opposite-Category
+
+equiv-opposite-Category :
+  (l1 l2 : Level) → Category l1 l2 ≃ Category l1 l2
+equiv-opposite-Category l1 l2 =
+  equiv-involution (involution-opposite-Category l1 l2)
+```
diff --git a/src/category-theory/opposite-precategories.lagda.md b/src/category-theory/opposite-precategories.lagda.md
index 6c1304e2e5..7f5bb7e217 100644
--- a/src/category-theory/opposite-precategories.lagda.md
+++ b/src/category-theory/opposite-precategories.lagda.md
@@ -7,10 +7,18 @@ module category-theory.opposite-precategories where
 <details><summary>Imports</summary>
 
 ```agda
+open import category-theory.composition-operations-on-binary-families-of-sets
+open import category-theory.isomorphisms-in-precategories
 open import category-theory.precategories
 
 open import foundation.dependent-pair-types
+open import foundation.equality-dependent-pair-types
+open import foundation.equivalences
+open import foundation.homotopies
 open import foundation.identity-types
+open import foundation.involutions
+open import foundation.propositions
+open import foundation.sets
 open import foundation.universe-levels
 ```
 
@@ -23,20 +31,148 @@ precategory** `Cᵒᵖ` is given by reversing every morphism.
 
 ## Definition
 
+### The opposite precategory
+
 ```agda
 module _
   {l1 l2 : Level} (C : Precategory l1 l2)
   where
 
+  obj-opposite-Precategory : UU l1
+  obj-opposite-Precategory = obj-Precategory C
+
+  hom-set-opposite-Precategory : (x y : obj-opposite-Precategory) → Set l2
+  hom-set-opposite-Precategory x y = hom-set-Precategory C y x
+
+  hom-opposite-Precategory : (x y : obj-opposite-Precategory) → UU l2
+  hom-opposite-Precategory x y = type-Set (hom-set-opposite-Precategory x y)
+
+  comp-hom-opposite-Precategory :
+    {x y z : obj-opposite-Precategory} →
+    hom-opposite-Precategory y z →
+    hom-opposite-Precategory x y →
+    hom-opposite-Precategory x z
+  comp-hom-opposite-Precategory g f = comp-hom-Precategory C f g
+
+  associative-comp-hom-opposite-Precategory :
+    {x y z w : obj-opposite-Precategory}
+    (h : hom-opposite-Precategory z w)
+    (g : hom-opposite-Precategory y z)
+    (f : hom-opposite-Precategory x y) →
+    ( comp-hom-opposite-Precategory (comp-hom-opposite-Precategory h g) f) ＝
+    ( comp-hom-opposite-Precategory h (comp-hom-opposite-Precategory g f))
+  associative-comp-hom-opposite-Precategory h g f =
+    inv (associative-comp-hom-Precategory C f g h)
+
+  id-hom-opposite-Precategory :
+    {x : obj-opposite-Precategory} → hom-opposite-Precategory x x
+  id-hom-opposite-Precategory = id-hom-Precategory C
+
+  left-unit-law-comp-hom-opposite-Precategory :
+    {x y : obj-opposite-Precategory}
+    (f : hom-opposite-Precategory x y) →
+    comp-hom-opposite-Precategory id-hom-opposite-Precategory f ＝ f
+  left-unit-law-comp-hom-opposite-Precategory =
+    right-unit-law-comp-hom-Precategory C
+
+  right-unit-law-comp-hom-opposite-Precategory :
+    {x y : obj-opposite-Precategory} (f : hom-opposite-Precategory x y) →
+    comp-hom-opposite-Precategory f id-hom-opposite-Precategory ＝ f
+  right-unit-law-comp-hom-opposite-Precategory =
+    left-unit-law-comp-hom-Precategory C
+
   opposite-Precategory : Precategory l1 l2
-  pr1 opposite-Precategory = obj-Precategory C
-  pr1 (pr2 opposite-Precategory) x y = hom-set-Precategory C y x
-  pr1 (pr1 (pr2 (pr2 opposite-Precategory))) f g = comp-hom-Precategory C g f
-  pr2 (pr1 (pr2 (pr2 opposite-Precategory))) f g h =
-    inv (associative-comp-hom-Precategory C h g f)
-  pr1 (pr2 (pr2 (pr2 opposite-Precategory))) x = id-hom-Precategory C {x}
-  pr1 (pr2 (pr2 (pr2 (pr2 opposite-Precategory)))) f =
-    right-unit-law-comp-hom-Precategory C f
-  pr2 (pr2 (pr2 (pr2 (pr2 opposite-Precategory)))) f =
-    left-unit-law-comp-hom-Precategory C f
+  pr1 opposite-Precategory = obj-opposite-Precategory
+  pr1 (pr2 opposite-Precategory) = hom-set-opposite-Precategory
+  pr1 (pr1 (pr2 (pr2 opposite-Precategory))) = comp-hom-opposite-Precategory
+  pr2 (pr1 (pr2 (pr2 opposite-Precategory))) =
+    associative-comp-hom-opposite-Precategory
+  pr1 (pr2 (pr2 (pr2 opposite-Precategory))) x = id-hom-opposite-Precategory {x}
+  pr1 (pr2 (pr2 (pr2 (pr2 opposite-Precategory)))) =
+    left-unit-law-comp-hom-opposite-Precategory
+  pr2 (pr2 (pr2 (pr2 (pr2 opposite-Precategory)))) =
+    right-unit-law-comp-hom-opposite-Precategory
+```
+
+## Properties
+
+### The opposite precategory construction is an involution on the type of precategories
+
+```agda
+is-involution-opposite-Precategory :
+  {l1 l2 : Level} → is-involution (opposite-Precategory {l1} {l2})
+is-involution-opposite-Precategory C =
+  eq-pair-eq-pr2
+    ( eq-pair-eq-pr2
+      ( eq-pair-Σ
+        ( eq-pair-eq-pr2
+          ( eq-is-prop
+            ( is-prop-is-associative-composition-operation-binary-family-Set
+              ( hom-set-Precategory C)
+              ( comp-hom-Precategory C))))
+        ( eq-is-prop
+          ( is-prop-is-unital-composition-operation-binary-family-Set
+            ( hom-set-Precategory C)
+            ( comp-hom-Precategory C)))))
+
+involution-opposite-Precategory :
+  (l1 l2 : Level) → involution (Precategory l1 l2)
+pr1 (involution-opposite-Precategory l1 l2) = opposite-Precategory
+pr2 (involution-opposite-Precategory l1 l2) = is-involution-opposite-Precategory
+
+is-equiv-opposite-Precategory :
+  {l1 l2 : Level} → is-equiv (opposite-Precategory {l1} {l2})
+is-equiv-opposite-Precategory =
+  is-equiv-is-involution is-involution-opposite-Precategory
+
+equiv-opposite-Precategory :
+  (l1 l2 : Level) → Precategory l1 l2 ≃ Precategory l1 l2
+equiv-opposite-Precategory l1 l2 =
+  equiv-involution (involution-opposite-Precategory l1 l2)
+```
+
+### Computing the isomorphism sets of the opposite precategory
+
+```agda
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2) {x y : obj-Precategory C}
+  where
+
+  map-compute-iso-opposite-Precategory :
+    iso-Precategory C x y → iso-Precategory (opposite-Precategory C) y x
+  pr1 (map-compute-iso-opposite-Precategory f) =
+    hom-iso-Precategory C f
+  pr1 (pr2 (map-compute-iso-opposite-Precategory f)) =
+    hom-inv-iso-Precategory C f
+  pr1 (pr2 (pr2 (map-compute-iso-opposite-Precategory f))) =
+    is-retraction-hom-inv-iso-Precategory C f
+  pr2 (pr2 (pr2 (map-compute-iso-opposite-Precategory f))) =
+    is-section-hom-inv-iso-Precategory C f
+
+  map-inv-compute-iso-opposite-Precategory :
+    iso-Precategory (opposite-Precategory C) y x → iso-Precategory C x y
+  pr1 (map-inv-compute-iso-opposite-Precategory f) =
+    hom-iso-Precategory (opposite-Precategory C) f
+  pr1 (pr2 (map-inv-compute-iso-opposite-Precategory f)) =
+    hom-inv-iso-Precategory (opposite-Precategory C) f
+  pr1 (pr2 (pr2 (map-inv-compute-iso-opposite-Precategory f))) =
+    is-retraction-hom-inv-iso-Precategory (opposite-Precategory C) f
+  pr2 (pr2 (pr2 (map-inv-compute-iso-opposite-Precategory f))) =
+    is-section-hom-inv-iso-Precategory (opposite-Precategory C) f
+
+  is-equiv-map-compute-iso-opposite-Precategory :
+    is-equiv (map-compute-iso-opposite-Precategory)
+  pr1 (pr1 is-equiv-map-compute-iso-opposite-Precategory) =
+    map-inv-compute-iso-opposite-Precategory
+  pr2 (pr1 is-equiv-map-compute-iso-opposite-Precategory) = refl-htpy
+  pr1 (pr2 is-equiv-map-compute-iso-opposite-Precategory) =
+    map-inv-compute-iso-opposite-Precategory
+  pr2 (pr2 is-equiv-map-compute-iso-opposite-Precategory) = refl-htpy
+
+  compute-iso-opposite-Precategory :
+    iso-Precategory C x y ≃ iso-Precategory (opposite-Precategory C) y x
+  pr1 compute-iso-opposite-Precategory =
+    map-compute-iso-opposite-Precategory
+  pr2 compute-iso-opposite-Precategory =
+    is-equiv-map-compute-iso-opposite-Precategory
 ```
diff --git a/src/category-theory/opposite-preunivalent-categories.lagda.md b/src/category-theory/opposite-preunivalent-categories.lagda.md
new file mode 100644
index 0000000000..e599c994fb
--- /dev/null
+++ b/src/category-theory/opposite-preunivalent-categories.lagda.md
@@ -0,0 +1,182 @@
+# Opposite preunivalent categories
+
+```agda
+module category-theory.opposite-preunivalent-categories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.isomorphisms-in-precategories
+open import category-theory.opposite-precategories
+open import category-theory.precategories
+open import category-theory.preunivalent-categories
+
+open import foundation.dependent-pair-types
+open import foundation.embeddings
+open import foundation.equivalences
+open import foundation.identity-types
+open import foundation.involutions
+open import foundation.sets
+open import foundation.subtypes
+open import foundation.transport-along-identifications
+open import foundation.universe-levels
+```
+
+</details>
+
+## Idea
+
+Let `C` be a
+[preunivalent category](category-theory.preunivalent-categories.md), its
+**opposite preunivalent category** `Cᵒᵖ` is given by reversing every morphism.
+
+## Lemma
+
+### A precategory is preunivalent if and only if the opposite is preunivalent
+
+```agda
+abstract
+  is-preunivalent-opposite-is-preunivalent-Precategory :
+    {l1 l2 : Level} (C : Precategory l1 l2) →
+    is-preunivalent-Precategory C →
+    is-preunivalent-Precategory (opposite-Precategory C)
+  is-preunivalent-opposite-is-preunivalent-Precategory C is-preunivalent-C x y =
+    is-emb-htpy-emb
+      ( comp-emb
+        ( emb-equiv
+          ( compute-iso-opposite-Precategory C ∘e equiv-inv-iso-Precategory C))
+        ( _ , is-preunivalent-C x y))
+      ( λ where
+        refl →
+          eq-type-subtype
+            ( is-iso-prop-Precategory (opposite-Precategory C))
+            ( refl))
+
+abstract
+  is-preunivalent-is-preunivalent-opposite-Precategory :
+    {l1 l2 : Level} (C : Precategory l1 l2) →
+    is-preunivalent-Precategory (opposite-Precategory C) →
+    is-preunivalent-Precategory C
+  is-preunivalent-is-preunivalent-opposite-Precategory C is-preunivalent-op-C =
+    tr
+      ( is-preunivalent-Precategory)
+      ( is-involution-opposite-Precategory C)
+      ( is-preunivalent-opposite-is-preunivalent-Precategory
+        ( opposite-Precategory C)
+        ( is-preunivalent-op-C))
+```
+
+## Definitions
+
+### The opposite preunivalent category
+
+```agda
+module _
+  {l1 l2 : Level} (C : Preunivalent-Category l1 l2)
+  where
+
+  obj-opposite-Preunivalent-Category : UU l1
+  obj-opposite-Preunivalent-Category =
+    obj-opposite-Precategory (precategory-Preunivalent-Category C)
+
+  hom-set-opposite-Preunivalent-Category :
+    (x y : obj-opposite-Preunivalent-Category) → Set l2
+  hom-set-opposite-Preunivalent-Category =
+    hom-set-opposite-Precategory (precategory-Preunivalent-Category C)
+
+  hom-opposite-Preunivalent-Category :
+    (x y : obj-opposite-Preunivalent-Category) → UU l2
+  hom-opposite-Preunivalent-Category =
+    hom-opposite-Precategory (precategory-Preunivalent-Category C)
+
+  comp-hom-opposite-Preunivalent-Category :
+    {x y z : obj-opposite-Preunivalent-Category} →
+    hom-opposite-Preunivalent-Category y z →
+    hom-opposite-Preunivalent-Category x y →
+    hom-opposite-Preunivalent-Category x z
+  comp-hom-opposite-Preunivalent-Category =
+    comp-hom-opposite-Precategory (precategory-Preunivalent-Category C)
+
+  associative-comp-hom-opposite-Preunivalent-Category :
+    {x y z w : obj-opposite-Preunivalent-Category}
+    (h : hom-opposite-Preunivalent-Category z w)
+    (g : hom-opposite-Preunivalent-Category y z)
+    (f : hom-opposite-Preunivalent-Category x y) →
+    ( comp-hom-opposite-Preunivalent-Category
+      ( comp-hom-opposite-Preunivalent-Category h g) (f)) ＝
+    ( comp-hom-opposite-Preunivalent-Category
+      ( h) (comp-hom-opposite-Preunivalent-Category g f))
+  associative-comp-hom-opposite-Preunivalent-Category =
+    associative-comp-hom-opposite-Precategory
+      ( precategory-Preunivalent-Category C)
+
+  id-hom-opposite-Preunivalent-Category :
+    {x : obj-opposite-Preunivalent-Category} →
+    hom-opposite-Preunivalent-Category x x
+  id-hom-opposite-Preunivalent-Category =
+    id-hom-opposite-Precategory (precategory-Preunivalent-Category C)
+
+  left-unit-law-comp-hom-opposite-Preunivalent-Category :
+    {x y : obj-opposite-Preunivalent-Category}
+    (f : hom-opposite-Preunivalent-Category x y) →
+    comp-hom-opposite-Preunivalent-Category
+      ( id-hom-opposite-Preunivalent-Category)
+      ( f) ＝
+    f
+  left-unit-law-comp-hom-opposite-Preunivalent-Category =
+    left-unit-law-comp-hom-opposite-Precategory
+      ( precategory-Preunivalent-Category C)
+
+  right-unit-law-comp-hom-opposite-Preunivalent-Category :
+    {x y : obj-opposite-Preunivalent-Category}
+    (f : hom-opposite-Preunivalent-Category x y) →
+    comp-hom-opposite-Preunivalent-Category
+      ( f) (id-hom-opposite-Preunivalent-Category) ＝
+    ( f)
+  right-unit-law-comp-hom-opposite-Preunivalent-Category =
+    right-unit-law-comp-hom-opposite-Precategory
+      ( precategory-Preunivalent-Category C)
+
+  precategory-opposite-Preunivalent-Category : Precategory l1 l2
+  precategory-opposite-Preunivalent-Category =
+    opposite-Precategory (precategory-Preunivalent-Category C)
+
+  opposite-Preunivalent-Category : Preunivalent-Category l1 l2
+  pr1 opposite-Preunivalent-Category =
+    precategory-opposite-Preunivalent-Category
+  pr2 opposite-Preunivalent-Category =
+    is-preunivalent-opposite-is-preunivalent-Precategory
+      ( precategory-Preunivalent-Category C)
+      ( is-preunivalent-Preunivalent-Category C)
+```
+
+## Properties
+
+### The opposite preunivalent category construction is an involution on the type of preunivalent categories
+
+```agda
+is-involution-opposite-Preunivalent-Category :
+  {l1 l2 : Level} → is-involution (opposite-Preunivalent-Category {l1} {l2})
+is-involution-opposite-Preunivalent-Category C =
+  eq-type-subtype
+    ( is-preunivalent-prop-Precategory)
+    ( is-involution-opposite-Precategory (precategory-Preunivalent-Category C))
+
+involution-opposite-Preunivalent-Category :
+  (l1 l2 : Level) → involution (Preunivalent-Category l1 l2)
+pr1 (involution-opposite-Preunivalent-Category l1 l2) =
+  opposite-Preunivalent-Category
+pr2 (involution-opposite-Preunivalent-Category l1 l2) =
+  is-involution-opposite-Preunivalent-Category
+
+is-equiv-opposite-Preunivalent-Category :
+  {l1 l2 : Level} → is-equiv (opposite-Preunivalent-Category {l1} {l2})
+is-equiv-opposite-Preunivalent-Category =
+  is-equiv-is-involution is-involution-opposite-Preunivalent-Category
+
+equiv-opposite-Preunivalent-Category :
+  (l1 l2 : Level) → Preunivalent-Category l1 l2 ≃ Preunivalent-Category l1 l2
+equiv-opposite-Preunivalent-Category l1 l2 =
+  equiv-involution (involution-opposite-Preunivalent-Category l1 l2)
+```
diff --git a/src/category-theory/precategories.lagda.md b/src/category-theory/precategories.lagda.md
index eee5a8b052..1df30c30d4 100644
--- a/src/category-theory/precategories.lagda.md
+++ b/src/category-theory/precategories.lagda.md
@@ -16,6 +16,8 @@ open import foundation.function-types
 open import foundation.identity-types
 open import foundation.propositions
 open import foundation.sets
+open import foundation.truncated-types
+open import foundation.truncation-levels
 open import foundation.universe-levels
 ```
 
@@ -167,6 +169,21 @@ module _
     associative-comp-hom-Precategory C
 ```
 
+### The total hom-type of a precategory
+
+```agda
+total-hom-Precategory :
+  {l1 l2 : Level} (C : Precategory l1 l2) → UU (l1 ⊔ l2)
+total-hom-Precategory C =
+  total-hom-Nonunital-Precategory (nonunital-precategory-Precategory C)
+
+obj-total-hom-Precategory :
+  {l1 l2 : Level} (C : Precategory l1 l2) →
+  total-hom-Precategory C → obj-Precategory C × obj-Precategory C
+obj-total-hom-Precategory C =
+  obj-total-hom-Nonunital-Precategory (nonunital-precategory-Precategory C)
+```
+
 ### Equalities induce morphisms
 
 ```agda
@@ -184,21 +201,6 @@ module _
   hom-inv-eq-Precategory x y = hom-eq-Precategory y x ∘ inv
 ```
 
-### The total hom-type of a precategory
-
-```agda
-total-hom-Precategory :
-  {l1 l2 : Level} (C : Precategory l1 l2) → UU (l1 ⊔ l2)
-total-hom-Precategory C =
-  total-hom-Nonunital-Precategory (nonunital-precategory-Precategory C)
-
-obj-total-hom-Precategory :
-  {l1 l2 : Level} (C : Precategory l1 l2) →
-  total-hom-Precategory C → obj-Precategory C × obj-Precategory C
-obj-total-hom-Precategory C =
-  obj-total-hom-Nonunital-Precategory (nonunital-precategory-Precategory C)
-```
-
 ### Pre- and postcomposition by a morphism
 
 ```agda
@@ -214,3 +216,25 @@ postcomp-hom-Precategory :
   hom-Precategory C z x → hom-Precategory C z y
 postcomp-hom-Precategory C f z = comp-hom-Precategory C f
 ```
+
+## If the objects of a precategory are `k`-truncated for non-negative `k`, the total hom-type is `k`-truncated
+
+```agda
+module _
+  {l1 l2 : Level} {k : 𝕋} (C : Precategory l1 l2)
+  where
+
+  is-trunc-total-hom-is-trunc-obj-Precategory :
+    is-trunc (succ-𝕋 (succ-𝕋 k)) (obj-Precategory C) →
+    is-trunc (succ-𝕋 (succ-𝕋 k)) (total-hom-Precategory C)
+  is-trunc-total-hom-is-trunc-obj-Precategory =
+    is-trunc-total-hom-is-trunc-obj-Nonunital-Precategory
+      ( nonunital-precategory-Precategory C)
+
+  total-hom-truncated-type-is-trunc-obj-Precategory :
+    is-trunc (succ-𝕋 (succ-𝕋 k)) (obj-Precategory C) →
+    Truncated-Type (l1 ⊔ l2) (succ-𝕋 (succ-𝕋 k))
+  total-hom-truncated-type-is-trunc-obj-Precategory =
+    total-hom-truncated-type-is-trunc-obj-Nonunital-Precategory
+      ( nonunital-precategory-Precategory C)
+```
diff --git a/src/category-theory/presheaf-categories.lagda.md b/src/category-theory/presheaf-categories.lagda.md
index f5e7ddd193..abf3a474e7 100644
--- a/src/category-theory/presheaf-categories.lagda.md
+++ b/src/category-theory/presheaf-categories.lagda.md
@@ -7,14 +7,13 @@ module category-theory.presheaf-categories where
 <details><summary>Imports</summary>
 
 ```agda
-open import category-theory.category-of-functors-from-small-to-large-categories
+open import category-theory.categories
+open import category-theory.copresheaf-categories
 open import category-theory.large-categories
 open import category-theory.large-precategories
 open import category-theory.opposite-precategories
 open import category-theory.precategories
-open import category-theory.precategory-of-functors-from-small-to-large-precategories
 
-open import foundation.category-of-sets
 open import foundation.universe-levels
 ```
 
@@ -22,63 +21,140 @@ open import foundation.universe-levels
 
 ## Idea
 
-Given any [precategory](category-theory.precategories.md) `C`, we can form its
-**presheaf category** as the
-[large category](category-theory.large-categories.md) of
-[functors](category-theory.functors-from-small-to-large-precategories.md) from
-the [opposite precategory](category-theory.opposite-precategories.md) of `C`,
+Given a [precategory](category-theory.precategories.md) `C`, we can form its
+**presheaf [category](category-theory.large-categories.md)** as the
+[large category of functors](category-theory.functors-from-small-to-large-precategories.md)
+from the [opposite of](category-theory.opposite-precategories.md) `C`, `Cᵒᵖ`,
 into the [large category of sets](foundation.category-of-sets.md)
 
 ```text
   Cᵒᵖ → Set.
 ```
 
-Dually, we can form the **copresheaf category** of `C` by taking the large
-functor category
-
-```text
-  C → Set.
-```
+To this large category, there is an associated
+[small category](category-theory.categories.md) of small presheaves, taking
+values in small [sets](foundation-core.sets.md).
 
 ## Definitions
 
-### The copresheaf category of a precategory
+### The large category of presheaves on a precategory
 
 ```agda
 module _
   {l1 l2 : Level} (C : Precategory l1 l2)
   where
 
-  copresheaf-Large-Precategory :
+  presheaf-Large-Precategory :
     Large-Precategory (λ l → l1 ⊔ l2 ⊔ lsuc l) (λ l l' → l1 ⊔ l2 ⊔ l ⊔ l')
-  copresheaf-Large-Precategory =
-    functor-large-precategory-Small-Large-Precategory C Set-Large-Precategory
+  presheaf-Large-Precategory =
+    copresheaf-Large-Precategory (opposite-Precategory C)
+
+  is-large-category-presheaf-Large-Category :
+    is-large-category-Large-Precategory presheaf-Large-Precategory
+  is-large-category-presheaf-Large-Category =
+    is-large-category-copresheaf-Large-Category (opposite-Precategory C)
 
-  copresheaf-Large-Category :
+  presheaf-Large-Category :
     Large-Category (λ l → l1 ⊔ l2 ⊔ lsuc l) (λ l l' → l1 ⊔ l2 ⊔ l ⊔ l')
-  large-precategory-Large-Category copresheaf-Large-Category =
-    copresheaf-Large-Precategory
-  is-large-category-Large-Category copresheaf-Large-Category =
-    is-large-category-functor-large-precategory-is-large-category-Small-Large-Precategory
-        ( C)
-        ( Set-Large-Precategory)
-        ( is-large-category-Set-Large-Precategory)
+  presheaf-Large-Category = copresheaf-Large-Category (opposite-Precategory C)
 ```
 
-### The presheaf category of a precategory
+We record the components of the large category of presheaves on a precategory.
+
+```agda
+  obj-presheaf-Large-Category =
+    obj-Large-Precategory presheaf-Large-Precategory
+
+  hom-set-presheaf-Large-Category =
+    hom-set-Large-Precategory presheaf-Large-Precategory
+
+  hom-presheaf-Large-Category =
+    hom-Large-Precategory presheaf-Large-Precategory
+
+  comp-hom-presheaf-Large-Category =
+    comp-hom-Large-Precategory presheaf-Large-Precategory
+
+  id-hom-presheaf-Large-Category =
+    id-hom-Large-Precategory presheaf-Large-Precategory
+
+  associative-comp-hom-presheaf-Large-Category =
+    associative-comp-hom-Large-Precategory presheaf-Large-Precategory
+
+  left-unit-law-comp-hom-presheaf-Large-Category =
+    left-unit-law-comp-hom-Large-Precategory presheaf-Large-Precategory
+
+  right-unit-law-comp-hom-presheaf-Large-Category =
+    right-unit-law-comp-hom-Large-Precategory presheaf-Large-Precategory
+```
+
+### The category of small presheaves on a precategory
 
 ```agda
 module _
-  {l1 l2 : Level} (C : Precategory l1 l2)
+  {l1 l2 : Level} (C : Precategory l1 l2) (l : Level)
   where
 
-  presheaf-Large-Precategory :
-    Large-Precategory (λ l → l1 ⊔ l2 ⊔ lsuc l) (λ l l' → l1 ⊔ l2 ⊔ l ⊔ l')
-  presheaf-Large-Precategory =
-    copresheaf-Large-Precategory (opposite-Precategory C)
+  presheaf-Precategory : Precategory (l1 ⊔ l2 ⊔ lsuc l) (l1 ⊔ l2 ⊔ l)
+  presheaf-Precategory =
+    precategory-Large-Precategory (presheaf-Large-Precategory C) l
 
-  presheaf-Large-Category :
-    Large-Category (λ l → l1 ⊔ l2 ⊔ lsuc l) (λ l l' → l1 ⊔ l2 ⊔ l ⊔ l')
-  presheaf-Large-Category =
-    copresheaf-Large-Category (opposite-Precategory C)
+  presheaf-Category : Category (l1 ⊔ l2 ⊔ lsuc l) (l1 ⊔ l2 ⊔ l)
+  presheaf-Category = category-Large-Category (presheaf-Large-Category C) l
+```
+
+We also record the components of the category of small presheaves on a
+precategory.
+
+```agda
+  obj-presheaf-Category =
+    obj-Precategory presheaf-Precategory
+
+  hom-set-presheaf-Category =
+    hom-set-Precategory presheaf-Precategory
+
+  hom-presheaf-Category =
+    hom-Precategory presheaf-Precategory
+
+  comp-hom-presheaf-Category =
+    comp-hom-Precategory presheaf-Precategory
+
+  id-hom-presheaf-Category =
+    id-hom-Precategory presheaf-Precategory
+
+  associative-comp-hom-presheaf-Category =
+    associative-comp-hom-Precategory presheaf-Precategory
+
+  left-unit-law-comp-hom-presheaf-Category =
+    left-unit-law-comp-hom-Precategory presheaf-Precategory
+
+  right-unit-law-comp-hom-presheaf-Category =
+    right-unit-law-comp-hom-Precategory presheaf-Precategory
 ```
+
+### Sections of presheaves
+
+As a choice of universe level must be made to talk about sections of presheaves,
+this notion coincides for the large and small category of presheaves.
+
+```agda
+module _
+  {l1 l2 l3 : Level} (C : Precategory l1 l2)
+  where
+
+  section-presheaf-Category :
+    (F : obj-presheaf-Category C l3) (c : obj-Precategory C) → UU l3
+  section-presheaf-Category =
+    section-copresheaf-Category (opposite-Precategory C)
+```
+
+## See also
+
+- [The Yoneda lemma](category-theory.yoneda-lemma-precategories.md)
+
+## External links
+
+- [Presheaf precategories](https://1lab.dev/Cat.Functor.Base.html#presheaf-precategories)
+  at 1lab
+- [category of presheaves](https://ncatlab.org/nlab/show/category+of+presheaves)
+  at nlab
+- [presheaf](https://ncatlab.org/nlab/show/presheaf) at nlab
diff --git a/src/category-theory/preunivalent-categories.lagda.md b/src/category-theory/preunivalent-categories.lagda.md
index 79e238fea8..718ba007bd 100644
--- a/src/category-theory/preunivalent-categories.lagda.md
+++ b/src/category-theory/preunivalent-categories.lagda.md
@@ -12,6 +12,7 @@ open import category-theory.isomorphisms-in-precategories
 open import category-theory.precategories
 
 open import foundation.1-types
+open import foundation.cartesian-product-types
 open import foundation.dependent-pair-types
 open import foundation.embeddings
 open import foundation.identity-types
@@ -39,11 +40,14 @@ preunivalent categories generalize both
 [strict categories](category-theory.strict-categories.md), which are
 precategories whose objects form a [set](foundation-core.sets.md).
 
-Summarized, the preunivalence condition on precategories states that the type of
-objects is a subgroupoid of the [groupoid](category-theory.groupoids.md) of
-isomorphisms. For univalent categories the groupoid of objects is equivalent to
-the groupoid of isomorphisms, while for strict categories the groupoid of
-objects is discrete.
+The preunivalence condition on precategories states that the type of objects is
+a subgroupoid of the [groupoid](category-theory.groupoids.md) of isomorphisms.
+For univalent categories the groupoid of objects is equivalent to the groupoid
+of isomorphisms, while for strict categories the groupoid of objects is
+discrete. Indeed, in this sense preunivalence provides a generalization of both
+notions of "category", with _no more structure_. This is opposed to the even
+more general notion of precategory, where the homotopy structure on the objects
+can be almost completely unrelated to the homotopy structure of the morphisms.
 
 ## Definitions
 
@@ -151,6 +155,30 @@ module _
   is-preunivalent-Preunivalent-Category :
     is-preunivalent-Precategory precategory-Preunivalent-Category
   is-preunivalent-Preunivalent-Category = pr2 C
+
+  emb-iso-eq-Preunivalent-Category :
+    {x y : obj-Preunivalent-Category} →
+    (x ＝ y) ↪ (iso-Precategory precategory-Preunivalent-Category x y)
+  pr1 (emb-iso-eq-Preunivalent-Category {x} {y}) =
+    iso-eq-Precategory precategory-Preunivalent-Category x y
+  pr2 (emb-iso-eq-Preunivalent-Category {x} {y}) =
+    is-preunivalent-Preunivalent-Category x y
+```
+
+### The total hom-type of a preunivalent category
+
+```agda
+total-hom-Preunivalent-Category :
+  {l1 l2 : Level} (C : Preunivalent-Category l1 l2) → UU (l1 ⊔ l2)
+total-hom-Preunivalent-Category C =
+  total-hom-Precategory (precategory-Preunivalent-Category C)
+
+obj-total-hom-Preunivalent-Category :
+  {l1 l2 : Level} (C : Preunivalent-Category l1 l2) →
+  total-hom-Preunivalent-Category C →
+  obj-Preunivalent-Category C × obj-Preunivalent-Category C
+obj-total-hom-Preunivalent-Category C =
+  obj-total-hom-Precategory (precategory-Preunivalent-Category C)
 ```
 
 ### Equalities induce morphisms
@@ -223,6 +251,27 @@ module _
   pr2 obj-1-type-Preunivalent-Category = is-1-type-obj-Preunivalent-Category
 ```
 
+### The total hom-type of a preunivalent category is a 1-type
+
+```agda
+module _
+  {l1 l2 : Level} (C : Preunivalent-Category l1 l2)
+  where
+
+  is-1-type-total-hom-Preunivalent-Category :
+    is-1-type (total-hom-Preunivalent-Category C)
+  is-1-type-total-hom-Preunivalent-Category =
+    is-trunc-total-hom-is-trunc-obj-Precategory
+      ( precategory-Preunivalent-Category C)
+      ( is-1-type-obj-Preunivalent-Category C)
+
+  total-hom-1-type-Preunivalent-Category : 1-Type (l1 ⊔ l2)
+  total-hom-1-type-Preunivalent-Category =
+    total-hom-truncated-type-is-trunc-obj-Precategory
+      ( precategory-Preunivalent-Category C)
+      ( is-1-type-obj-Preunivalent-Category C)
+```
+
 ## See also
 
 - [The preunivalence axiom](foundation.preunivalence.md)
diff --git a/src/category-theory/products-in-precategories.lagda.md b/src/category-theory/products-in-precategories.lagda.md
index 9933dde857..cb10bb605d 100644
--- a/src/category-theory/products-in-precategories.lagda.md
+++ b/src/category-theory/products-in-precategories.lagda.md
@@ -14,6 +14,7 @@ open import foundation.cartesian-product-types
 open import foundation.contractible-types
 open import foundation.dependent-pair-types
 open import foundation.identity-types
+open import foundation.iterated-dependent-product-types
 open import foundation.propositions
 open import foundation.unique-existence
 open import foundation.universe-levels
@@ -126,7 +127,7 @@ module _
 
   is-prop-is-product-Precategory : is-prop (is-product-Precategory C x y p l r)
   is-prop-is-product-Precategory =
-    is-prop-Π³ (λ z f g → is-property-is-contr)
+    is-prop-iterated-Π 3 (λ z f g → is-property-is-contr)
 
   is-product-prop-Precategory : Prop (l1 ⊔ l2)
   pr1 is-product-prop-Precategory = is-product-Precategory C x y p l r
diff --git a/src/category-theory/pullbacks-in-precategories.lagda.md b/src/category-theory/pullbacks-in-precategories.lagda.md
index 6a5d2efeb8..77bff5be49 100644
--- a/src/category-theory/pullbacks-in-precategories.lagda.md
+++ b/src/category-theory/pullbacks-in-precategories.lagda.md
@@ -14,6 +14,7 @@ open import foundation.cartesian-product-types
 open import foundation.contractible-types
 open import foundation.dependent-pair-types
 open import foundation.identity-types
+open import foundation.iterated-dependent-product-types
 open import foundation.propositions
 open import foundation.unique-existence
 open import foundation.universe-levels
@@ -159,7 +160,8 @@ module _
   is-prop-is-pullback-Precategory :
     is-prop (is-pullback-Precategory C x y z f g w p₁ p₂ α)
   is-prop-is-pullback-Precategory =
-    is-prop-Π³ (λ w' p₁' p₂' → is-prop-function-type is-property-is-contr)
+    is-prop-iterated-Π 3
+      ( λ w' p₁' p₂' → is-prop-function-type is-property-is-contr)
 
   is-pullback-prop-Precategory : Prop (l1 ⊔ l2)
   pr1 is-pullback-prop-Precategory =
diff --git a/src/category-theory/replete-subprecategories.lagda.md b/src/category-theory/replete-subprecategories.lagda.md
new file mode 100644
index 0000000000..f438e35093
--- /dev/null
+++ b/src/category-theory/replete-subprecategories.lagda.md
@@ -0,0 +1,332 @@
+# Replete subprecategories
+
+```agda
+module category-theory.replete-subprecategories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.categories
+open import category-theory.isomorphism-induction-categories
+open import category-theory.isomorphisms-in-precategories
+open import category-theory.isomorphisms-in-subprecategories
+open import category-theory.precategories
+open import category-theory.subprecategories
+
+open import foundation.cartesian-product-types
+open import foundation.dependent-pair-types
+open import foundation.equivalences
+open import foundation.functoriality-dependent-pair-types
+open import foundation.iterated-dependent-product-types
+open import foundation.propositions
+open import foundation.subsingleton-induction
+open import foundation.subtypes
+open import foundation.transport-along-identifications
+open import foundation.type-arithmetic-cartesian-product-types
+open import foundation.type-arithmetic-dependent-pair-types
+open import foundation.universe-levels
+```
+
+</details>
+
+## Idea
+
+A **replete subprecategory** of a [precategory](category-theory.categories.md)
+`C` is a [subprecategory](category-theory.subprecategories.md) `P` that is
+closed under [isomorphisms](category-theory.isomorphisms-in-precategories.md):
+
+Given an object `x` in `P`, then every isomorphism `f : x ≅ y` in `C`, is
+contained in `P`.
+
+## Definitions
+
+### The predicate on a subprecategory of being closed under isomorphic objects
+
+We can define what it means for subprecategories to have objects that are closed
+under isomorphisms. Observe that this is not yet the correct definition of a
+replete subprecategory.
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  where
+
+  contains-iso-obj-Subprecategory : UU (l1 ⊔ l2 ⊔ l3)
+  contains-iso-obj-Subprecategory =
+    (x : obj-Subprecategory C P) (y : obj-Precategory C) →
+    iso-Precategory C (inclusion-obj-Subprecategory C P x) y →
+    is-in-obj-Subprecategory C P y
+
+  is-prop-contains-iso-obj-Subprecategory :
+    is-prop contains-iso-obj-Subprecategory
+  is-prop-contains-iso-obj-Subprecategory =
+    is-prop-iterated-Π 3 (λ x y f → is-prop-is-in-obj-Subprecategory C P y)
+
+  contains-iso-obj-prop-Subprecategory : Prop (l1 ⊔ l2 ⊔ l3)
+  pr1 contains-iso-obj-prop-Subprecategory = contains-iso-obj-Subprecategory
+  pr2 contains-iso-obj-prop-Subprecategory =
+    is-prop-contains-iso-obj-Subprecategory
+```
+
+### The predicate of being a replete subprecategory
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  where
+
+  is-replete-Subprecategory : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4)
+  is-replete-Subprecategory =
+    (x : obj-Subprecategory C P)
+    (y : obj-Precategory C)
+    (f : iso-Precategory C (inclusion-obj-Subprecategory C P x) y) →
+    Σ ( is-in-obj-Subprecategory C P y)
+      ( λ y₀ → is-in-iso-obj-subprecategory-Subprecategory C P {x} {y , y₀} f)
+
+  is-prop-is-replete-Subprecategory :
+    is-prop is-replete-Subprecategory
+  is-prop-is-replete-Subprecategory =
+    is-prop-iterated-Π 3
+      ( λ x y f →
+        is-prop-Σ
+          ( is-prop-is-in-obj-Subprecategory C P y)
+          ( λ _ → is-prop-is-in-iso-obj-subprecategory-Subprecategory C P f))
+
+  is-replete-prop-Subprecategory : Prop (l1 ⊔ l2 ⊔ l3 ⊔ l4)
+  pr1 is-replete-prop-Subprecategory = is-replete-Subprecategory
+  pr2 is-replete-prop-Subprecategory =
+    is-prop-is-replete-Subprecategory
+```
+
+### The type of replete subprecategories
+
+```agda
+Replete-Subprecategory :
+  {l1 l2 : Level} (l3 l4 : Level) (C : Precategory l1 l2) →
+  UU (l1 ⊔ l2 ⊔ lsuc l3 ⊔ lsuc l4)
+Replete-Subprecategory l3 l4 C =
+  Σ (Subprecategory l3 l4 C) (is-replete-Subprecategory C)
+
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Replete-Subprecategory l3 l4 C)
+  where
+
+  subprecategory-Replete-Subprecategory : Subprecategory l3 l4 C
+  subprecategory-Replete-Subprecategory = pr1 P
+
+  is-replete-Replete-Subprecategory :
+    is-replete-Subprecategory C subprecategory-Replete-Subprecategory
+  is-replete-Replete-Subprecategory = pr2 P
+```
+
+## Properties
+
+### A slight reformulation of repleteness
+
+In our main definition of repleteness, the containment proof of the isomorphism
+must be fixed at the left end-point. This is of course not necessary, so we can
+ask for a slighty relaxed proof of repleteness:
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  where
+
+  is-unfixed-replete-Subprecategory : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4)
+  is-unfixed-replete-Subprecategory =
+    (x : obj-Subprecategory C P)
+    (y : obj-Precategory C)
+    (f : iso-Precategory C (inclusion-obj-Subprecategory C P x) y) →
+    is-in-iso-Subprecategory C P f
+
+  is-prop-is-unfixed-replete-Subprecategory :
+    is-prop (is-unfixed-replete-Subprecategory)
+  is-prop-is-unfixed-replete-Subprecategory =
+    is-prop-iterated-Π 3
+      ( λ x y f → is-prop-is-in-iso-Subprecategory C P f)
+
+  is-unfixed-replete-prop-Subprecategory : Prop (l1 ⊔ l2 ⊔ l3 ⊔ l4)
+  pr1 is-unfixed-replete-prop-Subprecategory =
+    is-unfixed-replete-Subprecategory
+  pr2 is-unfixed-replete-prop-Subprecategory =
+    is-prop-is-unfixed-replete-Subprecategory
+
+  is-unfixed-replete-is-replete-Subprecategory :
+    is-replete-Subprecategory C P → is-unfixed-replete-Subprecategory
+  pr1 (is-unfixed-replete-is-replete-Subprecategory replete' (x , x₀) y f) = x₀
+  pr2 (is-unfixed-replete-is-replete-Subprecategory replete' x y f) =
+    replete' x y f
+
+  is-replete-is-unfixed-replete-Subprecategory :
+    is-unfixed-replete-Subprecategory → is-replete-Subprecategory C P
+  is-replete-is-unfixed-replete-Subprecategory is-unfixed-replete-P x y f =
+    ind-subsingleton
+      ( is-prop-is-in-obj-Subprecategory C P (pr1 x))
+      { λ x₀ →
+        Σ ( is-in-obj-Subprecategory C P y)
+          ( λ y₀ →
+            is-in-iso-obj-subprecategory-Subprecategory C P
+              { inclusion-obj-Subprecategory C P x , x₀} {y , y₀} f)}
+      ( pr1 (is-unfixed-replete-P x y f))
+      ( pr2 (is-unfixed-replete-P x y f))
+      ( is-in-obj-inclusion-obj-Subprecategory C P x)
+```
+
+### Isomorphism-sets in replete subprecategories are equivalent to isomorphism-sets in the base precategory
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  (is-replete-P : is-replete-Subprecategory C P)
+  {x y : obj-Subprecategory C P} (f : hom-Subprecategory C P x y)
+  where
+
+  is-iso-is-iso-base-is-replete-Subprecategory :
+    is-iso-Precategory C (inclusion-hom-Subprecategory C P x y f) →
+    is-iso-Subprecategory C P f
+  pr1 (pr1 (is-iso-is-iso-base-is-replete-Subprecategory is-iso-C-f)) =
+    hom-inv-is-iso-Precategory C is-iso-C-f
+  pr2 (pr1 (is-iso-is-iso-base-is-replete-Subprecategory is-iso-C-f)) =
+    ind-subsingleton
+      ( is-prop-is-in-obj-Subprecategory C P (pr1 y))
+      { λ y₀ →
+        is-in-hom-obj-subprecategory-Subprecategory C P (pr1 y , y₀) x
+          ( hom-inv-is-iso-Precategory C is-iso-C-f)}
+      ( pr1 (is-replete-P x (pr1 y) (pr1 f , is-iso-C-f)))
+      ( pr2 (pr2 (is-replete-P x (pr1 y) (pr1 f , is-iso-C-f))))
+      ( pr2 y)
+  pr1 (pr2 (is-iso-is-iso-base-is-replete-Subprecategory is-iso-C-f)) =
+    eq-type-subtype
+      ( subtype-hom-obj-subprecategory-Subprecategory C P y y)
+      ( is-section-hom-inv-is-iso-Precategory C is-iso-C-f)
+  pr2 (pr2 (is-iso-is-iso-base-is-replete-Subprecategory is-iso-C-f)) =
+    eq-type-subtype
+      ( subtype-hom-obj-subprecategory-Subprecategory C P x x)
+      ( is-retraction-hom-inv-is-iso-Precategory C is-iso-C-f)
+
+  is-equiv-is-iso-is-iso-base-is-replete-Subprecategory :
+    is-equiv is-iso-is-iso-base-is-replete-Subprecategory
+  is-equiv-is-iso-is-iso-base-is-replete-Subprecategory =
+    is-equiv-is-prop
+      ( is-prop-is-iso-Precategory C (inclusion-hom-Subprecategory C P x y f))
+      ( is-prop-is-iso-Subprecategory C P f)
+      ( is-iso-base-is-iso-Subprecategory C P)
+
+  equiv-is-iso-is-iso-base-is-replete-Subprecategory :
+    is-iso-Precategory C (inclusion-hom-Subprecategory C P x y f) ≃
+    is-iso-Subprecategory C P f
+  pr1 equiv-is-iso-is-iso-base-is-replete-Subprecategory =
+    is-iso-is-iso-base-is-replete-Subprecategory
+  pr2 equiv-is-iso-is-iso-base-is-replete-Subprecategory =
+    is-equiv-is-iso-is-iso-base-is-replete-Subprecategory
+
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  (is-replete-P : is-replete-Subprecategory C P)
+  (x y : obj-Subprecategory C P)
+  where
+
+  compute-iso-is-replete-Subprecategory :
+    iso-Precategory C
+      ( inclusion-obj-Subprecategory C P x)
+      ( inclusion-obj-Subprecategory C P y) ≃
+    iso-Subprecategory C P x y
+  compute-iso-is-replete-Subprecategory =
+    ( equiv-tot
+      ( equiv-is-iso-is-iso-base-is-replete-Subprecategory
+          C P is-replete-P {x} {y})) ∘e
+    ( inv-associative-Σ _ _ _) ∘e
+    ( equiv-tot
+      ( λ f →
+        ( commutative-prod) ∘e
+        ( inv-right-unit-law-Σ-is-contr
+          ( λ is-iso-C-f → is-proof-irrelevant-is-prop
+            ( is-prop-is-in-hom-obj-subprecategory-Subprecategory C P x y f)
+            ( ind-subsingleton
+              ( is-prop-is-in-obj-Subprecategory C P (pr1 y))
+              { λ y₀ →
+                is-in-hom-obj-subprecategory-Subprecategory
+                  C P x (pr1 y , y₀) f}
+              ( is-replete-P x (pr1 y) (f , is-iso-C-f) .pr1)
+              ( is-replete-P x (pr1 y) (f , is-iso-C-f) .pr2 .pr1)
+              ( pr2 y))))))
+
+  inv-compute-iso-is-replete-Subprecategory :
+    iso-Subprecategory C P x y ≃
+    iso-Precategory C
+      ( inclusion-obj-Subprecategory C P x)
+      ( inclusion-obj-Subprecategory C P y)
+  inv-compute-iso-is-replete-Subprecategory =
+    inv-equiv compute-iso-is-replete-Subprecategory
+```
+
+### Subprecategories of categories are replete
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  (is-category-C : is-category-Precategory C)
+  where
+
+  is-unfixed-replete-subprecategory-is-category-Subprecategory :
+    {x : obj-Subprecategory C P}
+    {y : obj-Precategory C}
+    (f : iso-Precategory C (inclusion-obj-Subprecategory C P x) y) →
+    is-in-iso-Subprecategory C P f
+  is-unfixed-replete-subprecategory-is-category-Subprecategory {x} =
+    ind-iso-Category
+      ( C , is-category-C)
+      ( λ B e → is-in-iso-Subprecategory C P e)
+      ( is-in-iso-id-Subprecategory C P x)
+
+  is-replete-subprecategory-is-category-Subprecategory :
+    is-replete-Subprecategory C P
+  is-replete-subprecategory-is-category-Subprecategory x y =
+    ind-iso-Category
+      ( C , is-category-C)
+      ( λ z e →
+        Σ ( is-in-obj-Subprecategory C P z)
+          ( λ z₀ →
+            is-in-iso-obj-subprecategory-Subprecategory C P {x} {z , z₀} e))
+      ( pr2 (is-in-iso-id-Subprecategory C P x))
+```
+
+### If a full subprecategory is closed under isomorphic objects then it is replete
+
+This remains to be formalized.
+
+### The inclusion functor of a replete subprecategory is pseudomonic
+
+This remains to be formalized.
+
+## See also
+
+- Every [subcategory](category-theory.subcategories.md) is replete.
+
+- Because of universe polymorphism,
+  [large subcategories](category-theory.large-subcategories.md) are not large
+  replete by construction, although they are levelwise replete.
+
+## External links
+
+- [replete subcategory](https://ncatlab.org/nlab/show/replete+replete-subprecategory)
+  at nlab
+- [Isomorphism-closed subcategory](https://en.wikipedia.org/wiki/Isomorphism-closed_subcategory)
+  at Wikipedia
+- [isomorphism-closed subcategory](https://www.wikidata.org/wiki/Q6086096) at
+  Wikidata
diff --git a/src/category-theory/representable-functors-categories.lagda.md b/src/category-theory/representable-functors-categories.lagda.md
index 289bb57e8b..22014d5f9d 100644
--- a/src/category-theory/representable-functors-categories.lagda.md
+++ b/src/category-theory/representable-functors-categories.lagda.md
@@ -38,8 +38,8 @@ associativity and the left unit law for the category `C`.
 representable-functor-Category :
   {l1 l2 : Level} (C : Category l1 l2) (c : obj-Category C) →
   functor-Category C (Set-Category l2)
-representable-functor-Category C c =
-  representable-functor-Precategory (precategory-Category C) c
+representable-functor-Category C =
+  representable-functor-Precategory (precategory-Category C)
 ```
 
 ## Natural transformations between representable functors
@@ -51,7 +51,7 @@ components `hom c x → hom b x` are defined by precomposition with `f`.
 
 ```agda
 representable-natural-transformation-Category :
-  {l1 l2 : Level} (C : Category l1 l2) (b c : obj-Category C)
+  {l1 l2 : Level} (C : Category l1 l2) {b c : obj-Category C}
   (f : hom-Category C b c) →
   natural-transformation-Category
     ( C)
diff --git a/src/category-theory/representable-functors-precategories.lagda.md b/src/category-theory/representable-functors-precategories.lagda.md
index 5015e85c0f..4d7cf174de 100644
--- a/src/category-theory/representable-functors-precategories.lagda.md
+++ b/src/category-theory/representable-functors-precategories.lagda.md
@@ -7,14 +7,18 @@ module category-theory.representable-functors-precategories where
 <details><summary>Imports</summary>
 
 ```agda
+open import category-theory.copresheaf-categories
 open import category-theory.functors-precategories
+open import category-theory.maps-precategories
 open import category-theory.natural-transformations-functors-precategories
+open import category-theory.opposite-precategories
 open import category-theory.precategories
 
 open import foundation.category-of-sets
 open import foundation.dependent-pair-types
 open import foundation.function-extensionality
 open import foundation.homotopies
+open import foundation.sets
 open import foundation.universe-levels
 ```
 
@@ -28,8 +32,8 @@ there is a [functor](category-theory.functors-precategories.md) from `C` to the
 that:
 
 - sends an object `x` of `C` to the [set](foundation-core.sets.md) `hom c x` and
-- sends a morphism `g : hom x y` of `C` to the function `hom c x → hom c y`
-  defined by postcomposition with `g`.
+- sends a morphism `f : hom x y` of `C` to the function `hom c x → hom c y`
+  defined by postcomposition with `f`.
 
 The functoriality axioms follow, by
 [function extensionality](foundation.function-extensionality.md), from
@@ -38,16 +42,47 @@ associativity and the left unit law for the precategory `C`.
 ## Definition
 
 ```agda
-representable-functor-Precategory :
-  {l1 l2 : Level} (C : Precategory l1 l2) (c : obj-Precategory C) →
-  functor-Precategory C (Set-Precategory l2)
-pr1 (representable-functor-Precategory C c) = hom-set-Precategory C c
-pr1 (pr2 (representable-functor-Precategory C c)) g =
-  postcomp-hom-Precategory C g c
-pr1 (pr2 (pr2 (representable-functor-Precategory C c))) h g =
-  eq-htpy (associative-comp-hom-Precategory C h g)
-pr2 (pr2 (pr2 (representable-functor-Precategory C c))) _ =
-  eq-htpy (left-unit-law-comp-hom-Precategory C)
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2) (c : obj-Precategory C)
+  where
+
+  obj-representable-functor-Precategory : obj-Precategory C → Set l2
+  obj-representable-functor-Precategory = hom-set-Precategory C c
+
+  hom-representable-functor-Precategory :
+    {x y : obj-Precategory C} (f : hom-Precategory C x y) →
+    hom-Precategory C c x → hom-Precategory C c y
+  hom-representable-functor-Precategory f = postcomp-hom-Precategory C f c
+
+  representable-map-Precategory : map-Precategory C (Set-Precategory l2)
+  pr1 representable-map-Precategory = obj-representable-functor-Precategory
+  pr2 representable-map-Precategory = hom-representable-functor-Precategory
+
+  preserves-comp-representable-functor-Precategory :
+    preserves-comp-hom-map-Precategory
+      ( C)
+      ( Set-Precategory l2)
+      ( representable-map-Precategory)
+  preserves-comp-representable-functor-Precategory g f =
+    eq-htpy (associative-comp-hom-Precategory C g f)
+
+  preserves-id-representable-functor-Precategory :
+    preserves-id-hom-map-Precategory
+      ( C)
+      ( Set-Precategory l2)
+      ( representable-map-Precategory)
+  preserves-id-representable-functor-Precategory x =
+    eq-htpy (left-unit-law-comp-hom-Precategory C)
+
+  representable-functor-Precategory : functor-Precategory C (Set-Precategory l2)
+  pr1 representable-functor-Precategory =
+    obj-representable-functor-Precategory
+  pr1 (pr2 representable-functor-Precategory) =
+    hom-representable-functor-Precategory
+  pr1 (pr2 (pr2 representable-functor-Precategory)) =
+    preserves-comp-representable-functor-Precategory
+  pr2 (pr2 (pr2 representable-functor-Precategory)) =
+    preserves-id-representable-functor-Precategory
 ```
 
 ## Natural transformations between representable functors
@@ -58,16 +93,59 @@ from the functor represented by `c` to the functor represented by `b`. Its
 components `hom c x → hom b x` are defined by precomposition with `f`.
 
 ```agda
-representable-natural-transformation-Precategory :
-  {l1 l2 : Level} (C : Precategory l1 l2) (b c : obj-Precategory C)
-  (f : hom-Precategory C b c) →
-  natural-transformation-Precategory
-    ( C)
-    ( Set-Precategory l2)
-    ( representable-functor-Precategory C c)
-    ( representable-functor-Precategory C b)
-pr1 (representable-natural-transformation-Precategory C b c f) =
-  precomp-hom-Precategory C f
-pr2 (representable-natural-transformation-Precategory C b c f) h =
-  eq-htpy (inv-htpy (λ g → associative-comp-hom-Precategory C h g f))
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2)
+  {b c : obj-Precategory C} (f : hom-Precategory C b c)
+  where
+
+  hom-family-representable-natural-transformation-Precategory :
+    hom-family-functor-Precategory
+      ( C)
+      ( Set-Precategory l2)
+      ( representable-functor-Precategory C c)
+      ( representable-functor-Precategory C b)
+  hom-family-representable-natural-transformation-Precategory =
+    precomp-hom-Precategory C f
+
+  is-natural-transformation-representable-natural-transformation-Precategory :
+    is-natural-transformation-Precategory
+      ( C)
+      ( Set-Precategory l2)
+      ( representable-functor-Precategory C c)
+      ( representable-functor-Precategory C b)
+      ( hom-family-representable-natural-transformation-Precategory)
+  is-natural-transformation-representable-natural-transformation-Precategory h =
+    eq-htpy (inv-htpy (λ g → associative-comp-hom-Precategory C h g f))
+
+  representable-natural-transformation-Precategory :
+    natural-transformation-Precategory
+      ( C)
+      ( Set-Precategory l2)
+      ( representable-functor-Precategory C c)
+      ( representable-functor-Precategory C b)
+  pr1 (representable-natural-transformation-Precategory) =
+    hom-family-representable-natural-transformation-Precategory
+  pr2 (representable-natural-transformation-Precategory) =
+    is-natural-transformation-representable-natural-transformation-Precategory
+```
+
+## Properties
+
+### Taking representable functors defines a functor into the presheaf category
+
+```agda
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2)
+  where
+
+  map-representable-functor-copresheaf-Precategory :
+    map-Precategory
+      ( opposite-Precategory C)
+      ( copresheaf-Precategory C l2)
+  pr1 map-representable-functor-copresheaf-Precategory =
+    representable-functor-Precategory C
+  pr2 map-representable-functor-copresheaf-Precategory =
+    representable-natural-transformation-Precategory C
 ```
+
+It remains to show that this map is functorial.
diff --git a/src/category-theory/rigid-objects-categories.lagda.md b/src/category-theory/rigid-objects-categories.lagda.md
new file mode 100644
index 0000000000..6b27878c52
--- /dev/null
+++ b/src/category-theory/rigid-objects-categories.lagda.md
@@ -0,0 +1,81 @@
+# Rigid objects in a category
+
+```agda
+module category-theory.rigid-objects-categories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.categories
+open import category-theory.isomorphisms-in-categories
+open import category-theory.rigid-objects-precategories
+
+open import foundation.contractible-types
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.universe-levels
+
+open import group-theory.trivial-groups
+```
+
+</details>
+
+## Idea
+
+A **rigid object** in a [category](category-theory.categories.md) is an object
+whose [automorphism group](group-theory.automorphism-groups.md) is
+[trivial](group-theory.trivial-groups.md).
+
+## Definitions
+
+### The predicate of being rigid
+
+```agda
+module _
+  {l1 l2 : Level} (C : Category l1 l2) (x : obj-Category C)
+  where
+
+  is-rigid-obj-prop-Category : Prop l2
+  is-rigid-obj-prop-Category =
+    is-rigid-obj-prop-Precategory (precategory-Category C) x
+
+  is-rigid-obj-Category : UU l2
+  is-rigid-obj-Category = type-Prop is-rigid-obj-prop-Category
+
+  is-prop-is-rigid-obj-Category : is-prop is-rigid-obj-Category
+  is-prop-is-rigid-obj-Category =
+    is-prop-type-Prop is-rigid-obj-prop-Category
+```
+
+### The type of rigid objects in a category
+
+```agda
+rigid-obj-Category : {l1 l2 : Level} (C : Category l1 l2) → UU (l1 ⊔ l2)
+rigid-obj-Category C =
+    rigid-obj-Precategory (precategory-Category C)
+
+module _
+  {l1 l2 : Level} (C : Category l1 l2)
+  where
+
+  obj-rigid-obj-Category : rigid-obj-Category C → obj-Category C
+  obj-rigid-obj-Category = obj-rigid-obj-Precategory (precategory-Category C)
+
+  is-rigid-rigid-obj-Category :
+    (x : rigid-obj-Category C) →
+    is-rigid-obj-Category C (obj-rigid-obj-Category x)
+  is-rigid-rigid-obj-Category =
+    is-rigid-rigid-obj-Precategory (precategory-Category C)
+```
+
+## See also
+
+- Every object in a category is rigid if and only if it is
+  [gaunt](category-theory.gaunt-categories.md).
+
+## External links
+
+- [rigid object](https://ncatlab.org/nlab/show/rigid+object) at nlab
diff --git a/src/category-theory/rigid-objects-precategories.lagda.md b/src/category-theory/rigid-objects-precategories.lagda.md
new file mode 100644
index 0000000000..6d7a1909c5
--- /dev/null
+++ b/src/category-theory/rigid-objects-precategories.lagda.md
@@ -0,0 +1,72 @@
+# Rigid objects in a precategory
+
+```agda
+module category-theory.rigid-objects-precategories where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import category-theory.isomorphisms-in-precategories
+open import category-theory.precategories
+
+open import foundation.contractible-types
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.universe-levels
+
+open import group-theory.trivial-groups
+```
+
+</details>
+
+## Idea
+
+A **rigid object** in a [precategory](category-theory.precategories.md) is an
+object whose [automorphism group](group-theory.automorphism-groups.md) is
+[trivial](group-theory.trivial-groups.md).
+
+## Definitions
+
+### The predicate of being rigid
+
+```agda
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2) (x : obj-Precategory C)
+  where
+
+  is-rigid-obj-prop-Precategory : Prop l2
+  is-rigid-obj-prop-Precategory = is-contr-Prop (iso-Precategory C x x)
+
+  is-rigid-obj-Precategory : UU l2
+  is-rigid-obj-Precategory = type-Prop is-rigid-obj-prop-Precategory
+
+  is-prop-is-rigid-obj-Precategory : is-prop is-rigid-obj-Precategory
+  is-prop-is-rigid-obj-Precategory =
+    is-prop-type-Prop is-rigid-obj-prop-Precategory
+```
+
+### The type of rigid objects in a precategory
+
+```agda
+rigid-obj-Precategory : {l1 l2 : Level} (C : Precategory l1 l2) → UU (l1 ⊔ l2)
+rigid-obj-Precategory C = Σ (obj-Precategory C) (is-rigid-obj-Precategory C)
+
+module _
+  {l1 l2 : Level} (C : Precategory l1 l2)
+  where
+
+  obj-rigid-obj-Precategory : rigid-obj-Precategory C → obj-Precategory C
+  obj-rigid-obj-Precategory = pr1
+
+  is-rigid-rigid-obj-Precategory :
+    (x : rigid-obj-Precategory C) →
+    is-rigid-obj-Precategory C (obj-rigid-obj-Precategory x)
+  is-rigid-rigid-obj-Precategory = pr2
+```
+
+## External links
+
+- [rigid object](https://ncatlab.org/nlab/show/rigid+object) at nlab
diff --git a/src/category-theory/strict-categories.lagda.md b/src/category-theory/strict-categories.lagda.md
index 90d251a46f..91492df8c8 100644
--- a/src/category-theory/strict-categories.lagda.md
+++ b/src/category-theory/strict-categories.lagda.md
@@ -7,15 +7,15 @@ module category-theory.strict-categories where
 <details><summary>Imports</summary>
 
 ```agda
+open import category-theory.categories
 open import category-theory.composition-operations-on-binary-families-of-sets
 open import category-theory.isomorphisms-in-precategories
 open import category-theory.nonunital-precategories
 open import category-theory.precategories
 open import category-theory.preunivalent-categories
 
-open import foundation.1-types
+open import foundation.cartesian-product-types
 open import foundation.dependent-pair-types
-open import foundation.equivalences
 open import foundation.identity-types
 open import foundation.injective-maps
 open import foundation.propositions
@@ -30,9 +30,10 @@ open import foundation.universe-levels
 
 A **strict category** is a [precategory](category-theory.precategories.md) for
 which the type of objects form a [set](foundation-core.sets.md). Such categories
-are the set-theoretic analogue to (univalent)
-[categories](category-theory.categories.md), and have the defect that strict
-categorical constructions may generally fail to be invariant under isomorphisms.
+are the set-theoretic analogue to
+[(univalent) categories](category-theory.categories.md), and have the defect
+that strict categorical constructions may generally fail to be invariant under
+equivalences.
 
 ## Definitions
 
@@ -48,7 +49,45 @@ module _
     is-set-Prop (obj-Precategory C)
 
   is-strict-category-Precategory : UU l1
-  is-strict-category-Precategory = type-Prop is-strict-category-prop-Precategory
+  is-strict-category-Precategory =
+    type-Prop is-strict-category-prop-Precategory
+```
+
+### The predicate on preunivalent categories of being a strict category
+
+```agda
+module _
+  {l1 l2 : Level} (C : Preunivalent-Category l1 l2)
+  where
+
+  is-strict-category-prop-Preunivalent-Category : Prop l1
+  is-strict-category-prop-Preunivalent-Category =
+    is-strict-category-prop-Precategory (precategory-Preunivalent-Category C)
+
+  is-strict-category-Preunivalent-Category : UU l1
+  is-strict-category-Preunivalent-Category =
+    type-Prop is-strict-category-prop-Preunivalent-Category
+```
+
+### The predicate on categories of being a strict category
+
+We note that [(univalent) categories](category-theory.categories.md) that are
+strict form a very restricted class of strict categories where every
+[isomorphism](category-theory.isomorphisms-in-categories.md)-set is a
+[proposition](foundation-core.propositions.md). Such a category is called
+[gaunt](category-theory.gaunt-categories.md).
+
+```agda
+module _
+  {l1 l2 : Level} (C : Category l1 l2)
+  where
+
+  is-strict-category-prop-Category : Prop l1
+  is-strict-category-prop-Category =
+    is-strict-category-prop-Precategory (precategory-Category C)
+
+  is-strict-category-Category : UU l1
+  is-strict-category-Category = type-Prop is-strict-category-prop-Category
 ```
 
 ### The type of strict categories
@@ -162,6 +201,36 @@ module _
   pr2 preunivalent-category-Strict-Category = is-preunivalent-Strict-Category
 ```
 
+### The total hom-set of a strict category
+
+```agda
+module _
+  {l1 l2 : Level} (C : Strict-Category l1 l2)
+  where
+
+  total-hom-Strict-Category : UU (l1 ⊔ l2)
+  total-hom-Strict-Category =
+    total-hom-Precategory (precategory-Strict-Category C)
+
+  obj-total-hom-Strict-Category :
+    total-hom-Strict-Category → obj-Strict-Category C × obj-Strict-Category C
+  obj-total-hom-Strict-Category =
+    obj-total-hom-Precategory (precategory-Strict-Category C)
+
+  is-set-total-hom-Strict-Category :
+    is-set total-hom-Strict-Category
+  is-set-total-hom-Strict-Category =
+    is-trunc-total-hom-is-trunc-obj-Precategory
+      ( precategory-Strict-Category C)
+      ( is-set-obj-Strict-Category C)
+
+  total-hom-set-Strict-Category : Set (l1 ⊔ l2)
+  total-hom-set-Strict-Category =
+    total-hom-truncated-type-is-trunc-obj-Precategory
+      ( precategory-Strict-Category C)
+      ( is-set-obj-Strict-Category C)
+```
+
 ### Equalities induce morphisms
 
 ```agda
@@ -201,3 +270,13 @@ postcomp-hom-Strict-Category C =
 
 - [Preunivalent categories](category-theory.preunivalent-categories.md) for the
   common generalization of (univalent) categories and strict categories.
+- [Gaunt categories](category-theory.gaunt-categories.md) for the common
+  intersection of (univalent) categories and strict categories.
+
+## External links
+
+- [Strict Precategories](https://1lab.dev/Cat.Strict.html#strict-precategories)
+  at 1lab
+- [strict category](https://ncatlab.org/nlab/show/strict+category) at nlab
+- [Category (mathematics)](<https://en.wikipedia.org/wiki/Category_(mathematics)>)
+  at Wikipedia
diff --git a/src/category-theory/subcategories.lagda.md b/src/category-theory/subcategories.lagda.md
index f359b8bf77..79218bd947 100644
--- a/src/category-theory/subcategories.lagda.md
+++ b/src/category-theory/subcategories.lagda.md
@@ -11,15 +11,25 @@ open import category-theory.categories
 open import category-theory.composition-operations-on-binary-families-of-sets
 open import category-theory.faithful-functors-precategories
 open import category-theory.functors-precategories
+open import category-theory.isomorphisms-in-categories
+open import category-theory.isomorphisms-in-precategories
+open import category-theory.isomorphisms-in-subprecategories
 open import category-theory.maps-precategories
 open import category-theory.precategories
+open import category-theory.replete-subprecategories
 open import category-theory.subprecategories
 
+open import foundation.contractible-types
 open import foundation.dependent-pair-types
 open import foundation.embeddings
+open import foundation.equivalences
+open import foundation.functoriality-dependent-pair-types
+open import foundation.fundamental-theorem-of-identity-types
+open import foundation.homotopies
 open import foundation.identity-types
 open import foundation.propositions
 open import foundation.sets
+open import foundation.subtype-identity-principle
 open import foundation.subtypes
 open import foundation.universe-levels
 ```
@@ -48,7 +58,7 @@ module _
   {l1 l2 l3 l4 : Level}
   (C : Category l1 l2)
   (P₀ : subtype l3 (obj-Category C))
-  (P₁ : (x y : obj-Category C) → subtype l4 (hom-Category C x y))
+  (P₁ : subtype-hom-Precategory l4 (precategory-Category C) P₀)
   where
 
   contains-id-subtype-Category : UU (l1 ⊔ l3 ⊔ l4)
@@ -88,12 +98,11 @@ module _
   {l1 l2 l3 l4 : Level}
   (C : Category l1 l2)
   (P₀ : subtype l3 (obj-Category C))
-  (P₁ : (x y : obj-Category C) → subtype l4 (hom-Category C x y))
+  (P₁ : subtype-hom-Precategory l4 (precategory-Category C) P₀)
   where
 
   is-subcategory-Prop : Prop (l1 ⊔ l2 ⊔ l3 ⊔ l4)
-  is-subcategory-Prop =
-    is-subprecategory-Prop (precategory-Category C) P₀ P₁
+  is-subcategory-Prop = is-subprecategory-Prop (precategory-Category C) P₀ P₁
 
   is-subcategory : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4)
   is-subcategory = type-Prop is-subcategory-Prop
@@ -102,12 +111,16 @@ module _
   is-prop-is-subcategory = is-prop-type-Prop is-subcategory-Prop
 
   contains-id-is-subcategory :
-    is-subcategory → contains-id-subtype-Category C P₀ P₁
-  contains-id-is-subcategory = pr1
+    is-subcategory →
+    contains-id-subtype-Category C P₀ P₁
+  contains-id-is-subcategory =
+    contains-id-is-subprecategory (precategory-Category C) P₀ P₁
 
   is-closed-under-composition-is-subcategory :
-    is-subcategory → is-closed-under-composition-subtype-Category C P₀ P₁
-  is-closed-under-composition-is-subcategory = pr2
+    is-subcategory →
+    is-closed-under-composition-subtype-Category C P₀ P₁
+  is-closed-under-composition-is-subcategory =
+    is-closed-under-composition-is-subprecategory (precategory-Category C) P₀ P₁
 ```
 
 ### Subcategories
@@ -118,7 +131,11 @@ Subcategory :
   (C : Category l1 l2) →
   UU (l1 ⊔ l2 ⊔ lsuc l3 ⊔ lsuc l4)
 Subcategory l3 l4 C = Subprecategory l3 l4 (precategory-Category C)
+```
+
+#### Objects in subcategories
 
+```agda
 module _
   {l1 l2 l3 l4 : Level}
   (C : Category l1 l2)
@@ -126,7 +143,8 @@ module _
   where
 
   subtype-obj-Subcategory : subtype l3 (obj-Category C)
-  subtype-obj-Subcategory = pr1 P
+  subtype-obj-Subcategory =
+    subtype-obj-Subprecategory (precategory-Category C) P
 
   obj-Subcategory : UU (l1 ⊔ l3)
   obj-Subcategory = type-subtype subtype-obj-Subcategory
@@ -139,63 +157,133 @@ module _
 
   is-prop-is-in-obj-Subcategory :
     (x : obj-Category C) → is-prop (is-in-obj-Subcategory x)
-  is-prop-is-in-obj-Subcategory = is-prop-is-in-subtype subtype-obj-Subcategory
+  is-prop-is-in-obj-Subcategory =
+    is-prop-is-in-subtype subtype-obj-Subcategory
 
   is-in-obj-inclusion-obj-Subcategory :
     (x : obj-Subcategory) →
     is-in-obj-Subcategory (inclusion-obj-Subcategory x)
   is-in-obj-inclusion-obj-Subcategory =
     is-in-subtype-inclusion-subtype subtype-obj-Subcategory
+```
 
-  subtype-hom-Subcategory :
-    (x y : obj-Category C) → subtype l4 (hom-Category C x y)
-  subtype-hom-Subcategory = pr1 (pr2 P)
+#### Morphisms in subcategories
 
-  hom-Subcategory : (x y : obj-Subcategory) → UU (l2 ⊔ l4)
-  hom-Subcategory = hom-Subprecategory (precategory-Category C) P
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Category l1 l2)
+  (P : Subcategory l3 l4 C)
+  where
+
+  subtype-hom-Subcategory :
+    subtype-hom-Precategory l4
+      ( precategory-Category C)
+      ( subtype-obj-Subcategory C P)
+  subtype-hom-Subcategory =
+    subtype-hom-Subprecategory (precategory-Category C) P
+
+  subtype-hom-obj-subcategory-Subcategory :
+    (x y : obj-Subcategory C P) →
+    subtype l4
+      ( hom-Category C
+        ( inclusion-obj-Subcategory C P x)
+        ( inclusion-obj-Subcategory C P y))
+  subtype-hom-obj-subcategory-Subcategory =
+    subtype-hom-obj-subprecategory-Subprecategory (precategory-Category C) P
+
+  hom-Subcategory : (x y : obj-Subcategory C P) → UU (l2 ⊔ l4)
+  hom-Subcategory x y =
+    type-subtype (subtype-hom-obj-subcategory-Subcategory x y)
 
   inclusion-hom-Subcategory :
-    (x y : obj-Subcategory) →
+    (x y : obj-Subcategory C P) →
     hom-Subcategory x y →
     hom-Category C
-      ( inclusion-obj-Subcategory x)
-      ( inclusion-obj-Subcategory y)
-  inclusion-hom-Subcategory =
-    inclusion-hom-Subprecategory (precategory-Category C) P
+      ( inclusion-obj-Subcategory C P x)
+      ( inclusion-obj-Subcategory C P y)
+  inclusion-hom-Subcategory x y =
+    inclusion-subtype (subtype-hom-obj-subcategory-Subcategory x y)
+```
 
+The predicate on a morphism between subobjects of being contained in the
+subcategory:
+
+```agda
+  is-in-hom-obj-subcategory-Subcategory :
+    ( x y : obj-Subcategory C P) →
+    hom-Category C
+      ( inclusion-obj-Subcategory C P x)
+      ( inclusion-obj-Subcategory C P y) →
+    UU l4
+  is-in-hom-obj-subcategory-Subcategory x y =
+    is-in-subtype (subtype-hom-obj-subcategory-Subcategory x y)
+
+  is-prop-is-in-hom-obj-subcategory-Subcategory :
+    ( x y : obj-Subcategory C P)
+    ( f :
+      hom-Category C
+        ( inclusion-obj-Subcategory C P x)
+        ( inclusion-obj-Subcategory C P y)) →
+    is-prop (is-in-hom-obj-subcategory-Subcategory x y f)
+  is-prop-is-in-hom-obj-subcategory-Subcategory x y =
+    is-prop-is-in-subtype (subtype-hom-obj-subcategory-Subcategory x y)
+```
+
+The predicate on a morphism between any objects of being contained in the
+subcategory:
+
+```agda
   is-in-hom-Subcategory :
-    (x y : obj-Category C) (f : hom-Category C x y) → UU l4
-  is-in-hom-Subcategory x y = is-in-subtype (subtype-hom-Subcategory x y)
+    (x y : obj-Category C) (f : hom-Category C x y) → UU (l3 ⊔ l4)
+  is-in-hom-Subcategory =
+    is-in-hom-Subprecategory (precategory-Category C) P
 
   is-prop-is-in-hom-Subcategory :
     (x y : obj-Category C) (f : hom-Category C x y) →
     is-prop (is-in-hom-Subcategory x y f)
-  is-prop-is-in-hom-Subcategory x y =
-    is-prop-is-in-subtype (subtype-hom-Subcategory x y)
+  is-prop-is-in-hom-Subcategory =
+    is-prop-is-in-hom-Subprecategory (precategory-Category C) P
+
+  is-in-hom-obj-subcategory-inclusion-hom-Subcategory :
+    (x y : obj-Subcategory C P)
+    (f : hom-Subcategory x y) →
+    is-in-hom-obj-subcategory-Subcategory x y
+      ( inclusion-hom-Subcategory x y f)
+  is-in-hom-obj-subcategory-inclusion-hom-Subcategory =
+    is-in-hom-obj-subprecategory-inclusion-hom-Subprecategory
+      ( precategory-Category C) P
 
   is-in-hom-inclusion-hom-Subcategory :
-    (x y : obj-Subcategory) (f : hom-Subcategory x y) →
+    (x y : obj-Subcategory C P)
+    (f : hom-Subcategory x y) →
     is-in-hom-Subcategory
-      ( inclusion-obj-Subcategory x)
-      ( inclusion-obj-Subcategory y)
+      ( inclusion-obj-Subcategory C P x)
+      ( inclusion-obj-Subcategory C P y)
       ( inclusion-hom-Subcategory x y f)
   is-in-hom-inclusion-hom-Subcategory =
     is-in-hom-inclusion-hom-Subprecategory (precategory-Category C) P
+```
+
+#### Subcategories are subcategories
 
+```agda
   is-subcategory-Subcategory :
-    is-subcategory C subtype-obj-Subcategory subtype-hom-Subcategory
-  is-subcategory-Subcategory = pr2 (pr2 P)
+    is-subcategory C
+      ( subtype-obj-Subcategory C P) (subtype-hom-Subcategory)
+  is-subcategory-Subcategory =
+    is-subprecategory-Subprecategory (precategory-Category C) P
 
   contains-id-Subcategory :
     contains-id-subtype-Category C
-      ( subtype-obj-Subcategory)
+      ( subtype-obj-Subcategory C P)
       ( subtype-hom-Subcategory)
   contains-id-Subcategory =
     contains-id-Subprecategory (precategory-Category C) P
 
   is-closed-under-composition-Subcategory :
     is-closed-under-composition-subtype-Category C
-      ( subtype-obj-Subcategory)
+      ( subtype-obj-Subcategory C P)
       ( subtype-hom-Subcategory)
   is-closed-under-composition-Subcategory =
     is-closed-under-composition-Subprecategory (precategory-Category C) P
@@ -211,23 +299,25 @@ module _
   where
 
   hom-set-Subcategory : (x y : obj-Subcategory C P) → Set (l2 ⊔ l4)
-  hom-set-Subcategory = hom-set-Subprecategory (precategory-Category C) P
+  hom-set-Subcategory =
+    hom-set-Subprecategory (precategory-Category C) P
 
   is-set-hom-Subcategory :
     (x y : obj-Subcategory C P) → is-set (hom-Subcategory C P x y)
-  is-set-hom-Subcategory = is-set-hom-Subprecategory (precategory-Category C) P
+  is-set-hom-Subcategory x y = is-set-type-Set (hom-set-Subcategory x y)
 
   id-hom-Subcategory :
     {x : obj-Subcategory C P} → hom-Subcategory C P x x
-  id-hom-Subcategory {x} = id-hom-Subprecategory (precategory-Category C) P {x}
+  id-hom-Subcategory =
+    id-hom-Subprecategory (precategory-Category C) P
 
   comp-hom-Subcategory :
     {x y z : obj-Subcategory C P} →
     hom-Subcategory C P y z →
     hom-Subcategory C P x y →
     hom-Subcategory C P x z
-  comp-hom-Subcategory {x} {y} {z} =
-    comp-hom-Subprecategory (precategory-Category C) P {x} {y} {z}
+  comp-hom-Subcategory =
+    comp-hom-Subprecategory (precategory-Category C) P
 
   associative-comp-hom-Subcategory :
     {x y z w : obj-Subcategory C P}
@@ -272,10 +362,6 @@ module _
     precategory-Subprecategory (precategory-Category C) P
 ```
 
-### The underlying category of a subcategory
-
-It remains to show that subprecategories of categories are categories.
-
 ### The inclusion functor of a subcategory
 
 ```agda
@@ -303,7 +389,9 @@ module _
   inclusion-Subcategory = inclusion-Subprecategory (precategory-Category C) P
 ```
 
-### Isomorphisms in subcategories
+## Properties
+
+### Subcategories are replete
 
 ```agda
 module _
@@ -312,19 +400,63 @@ module _
   (P : Subcategory l3 l4 C)
   where
 
-  is-iso-Subcategory :
-    {x y : obj-Subcategory C P} → hom-Subcategory C P x y → UU (l2 ⊔ l4)
-  is-iso-Subcategory {x} {y} =
-    is-iso-Subprecategory (precategory-Category C) P {x} {y}
-
-  iso-Subcategory :
-    (x y : obj-Subcategory C P) → UU (l2 ⊔ l4)
-  iso-Subcategory = iso-Subprecategory (precategory-Category C) P
+  is-replete-Subcategory : is-replete-Subprecategory (precategory-Category C) P
+  is-replete-Subcategory =
+    is-replete-subprecategory-is-category-Subprecategory
+      ( precategory-Category C)
+      ( P)
+      ( is-category-Category C)
+
+  compute-iso-Subcategory :
+    {x y : obj-Subcategory C P} →
+    iso-Category C
+      ( inclusion-obj-Subcategory C P x)
+      ( inclusion-obj-Subcategory C P y) ≃
+    iso-Subprecategory (precategory-Category C) P x y
+  compute-iso-Subcategory {x} {y} =
+    compute-iso-is-replete-Subprecategory
+      ( precategory-Category C) P is-replete-Subcategory x y
+
+  inv-compute-iso-Subcategory :
+    {x y : obj-Subcategory C P} →
+    iso-Subprecategory (precategory-Category C) P x y ≃
+    iso-Category C
+      ( inclusion-obj-Subcategory C P x)
+      ( inclusion-obj-Subcategory C P y)
+  inv-compute-iso-Subcategory {x} {y} =
+    inv-compute-iso-is-replete-Subprecategory
+      ( precategory-Category C) P is-replete-Subcategory x y
 ```
 
-## Properties
+### Subcategories are categories
 
-### The inclusion functor is faithful and an embedding on objects
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Category l1 l2)
+  (P : Subcategory l3 l4 C)
+  where
+
+  is-category-Subcategory :
+    is-category-Precategory (precategory-Subcategory C P)
+  is-category-Subcategory x =
+    fundamental-theorem-id
+      ( is-contr-equiv _
+        ( equiv-tot (λ y → inv-compute-iso-Subcategory C P {x} {y}))
+        ( is-torsorial-Eq-subtype
+          ( is-torsorial-iso-Category C (inclusion-obj-Subcategory C P x))
+          ( is-prop-is-in-obj-Subcategory C P)
+          ( inclusion-obj-Subcategory C P x)
+          ( id-iso-Category C)
+          ( is-in-obj-inclusion-obj-Subcategory C P x)))
+      ( iso-eq-Precategory (precategory-Subcategory C P) x)
+
+  category-Subcategory : Category (l1 ⊔ l3) (l2 ⊔ l4)
+  pr1 category-Subcategory = precategory-Subcategory C P
+  pr2 category-Subcategory = is-category-Subcategory
+```
+
+### The inclusion functor is an embedding on objects and hom-sets
 
 ```agda
 module _
@@ -333,20 +465,24 @@ module _
   (P : Subcategory l3 l4 C)
   where
 
-  is-faithful-inclusion-Category :
+  is-faithful-inclusion-Subcategory :
     is-faithful-functor-Precategory
       ( precategory-Subcategory C P)
       ( precategory-Category C)
       ( inclusion-Subcategory C P)
-  is-faithful-inclusion-Category =
+  is-faithful-inclusion-Subcategory =
     is-faithful-inclusion-Subprecategory (precategory-Category C) P
 
-  is-emb-obj-inclusion-Category :
+  is-emb-obj-inclusion-Subcategory :
     is-emb
       ( obj-functor-Precategory
         ( precategory-Subcategory C P)
         ( precategory-Category C)
         ( inclusion-Subcategory C P))
-  is-emb-obj-inclusion-Category =
+  is-emb-obj-inclusion-Subcategory =
     is-emb-obj-inclusion-Subprecategory (precategory-Category C) P
 ```
+
+### The inclusion functor is pseudomonic
+
+This is another consequence of repleteness.
diff --git a/src/category-theory/subprecategories.lagda.md b/src/category-theory/subprecategories.lagda.md
index c5a972b724..fa98a332c9 100644
--- a/src/category-theory/subprecategories.lagda.md
+++ b/src/category-theory/subprecategories.lagda.md
@@ -7,22 +7,18 @@ module category-theory.subprecategories where
 <details><summary>Imports</summary>
 
 ```agda
-open import category-theory.categories
 open import category-theory.composition-operations-on-binary-families-of-sets
 open import category-theory.faithful-functors-precategories
 open import category-theory.functors-precategories
-open import category-theory.isomorphism-induction-categories
-open import category-theory.isomorphisms-in-precategories
 open import category-theory.maps-precategories
 open import category-theory.precategories
 
 open import foundation.dependent-pair-types
 open import foundation.embeddings
-open import foundation.function-types
 open import foundation.identity-types
+open import foundation.iterated-dependent-product-types
 open import foundation.propositions
 open import foundation.sets
-open import foundation.subsingleton-induction
 open import foundation.subtypes
 open import foundation.universe-levels
 ```
@@ -44,24 +40,39 @@ objects in `P₀` and is closed under composition.
 
 ## Definition
 
+### Sub-hom-families
+
+```agda
+subtype-hom-Precategory :
+  {l1 l2 l3 : Level} (l4 : Level)
+  (C : Precategory l1 l2)
+  (P₀ : subtype l3 (obj-Precategory C)) → UU (l1 ⊔ l2 ⊔ l3 ⊔ lsuc l4)
+subtype-hom-Precategory l4 C P₀ =
+  (x y : obj-Precategory C) → is-in-subtype P₀ x → is-in-subtype P₀ y →
+  subtype l4 (hom-Precategory C x y)
+```
+
+### Categorical predicates on sub-hom-families
+
 ```agda
 module _
   {l1 l2 l3 l4 : Level}
   (C : Precategory l1 l2)
   (P₀ : subtype l3 (obj-Precategory C))
-  (P₁ : (x y : obj-Precategory C) → subtype l4 (hom-Precategory C x y))
+  (P₁ : subtype-hom-Precategory l4 C P₀)
   where
 
   contains-id-subtype-Precategory : UU (l1 ⊔ l3 ⊔ l4)
   contains-id-subtype-Precategory =
     (x : obj-Precategory C) →
-    is-in-subtype P₀ x → is-in-subtype (P₁ x x) (id-hom-Precategory C)
+    (x₀ : is-in-subtype P₀ x) →
+    is-in-subtype (P₁ x x x₀ x₀) (id-hom-Precategory C)
 
   is-prop-contains-id-subtype-Precategory :
     is-prop contains-id-subtype-Precategory
   is-prop-contains-id-subtype-Precategory =
-    is-prop-Π²
-      ( λ x _ → is-prop-is-in-subtype (P₁ x x) (id-hom-Precategory C))
+    is-prop-iterated-Π 2
+      ( λ x x₀ → is-prop-is-in-subtype (P₁ x x x₀ x₀) (id-hom-Precategory C))
 
   contains-id-prop-subtype-Precategory : Prop (l1 ⊔ l3 ⊔ l4)
   pr1 contains-id-prop-subtype-Precategory =
@@ -74,19 +85,19 @@ module _
     (x y z : obj-Precategory C) →
     (g : hom-Precategory C y z) →
     (f : hom-Precategory C x y) →
-    is-in-subtype P₀ x →
-    is-in-subtype P₀ y →
-    is-in-subtype P₀ z →
-    is-in-subtype (P₁ y z) g →
-    is-in-subtype (P₁ x y) f →
-    is-in-subtype (P₁ x z) (comp-hom-Precategory C g f)
+    (x₀ : is-in-subtype P₀ x) →
+    (y₀ : is-in-subtype P₀ y) →
+    (z₀ : is-in-subtype P₀ z) →
+    is-in-subtype (P₁ y z y₀ z₀) g →
+    is-in-subtype (P₁ x y x₀ y₀) f →
+    is-in-subtype (P₁ x z x₀ z₀) (comp-hom-Precategory C g f)
 
   is-prop-is-closed-under-composition-subtype-Precategory :
     is-prop is-closed-under-composition-subtype-Precategory
   is-prop-is-closed-under-composition-subtype-Precategory =
-    is-prop-Π¹⁰
-      ( λ x y z g f _ _ _ _ _ →
-        is-prop-is-in-subtype (P₁ x z) (comp-hom-Precategory C g f))
+    is-prop-iterated-Π 10
+      ( λ x y z g f x₀ _ z₀ _ _ →
+        is-prop-is-in-subtype (P₁ x z x₀ z₀) (comp-hom-Precategory C g f))
 
   is-closed-under-composition-prop-subtype-Precategory :
     Prop (l1 ⊔ l2 ⊔ l3 ⊔ l4)
@@ -103,7 +114,7 @@ module _
   {l1 l2 l3 l4 : Level}
   (C : Precategory l1 l2)
   (P₀ : subtype l3 (obj-Precategory C))
-  (P₁ : (x y : obj-Precategory C) → subtype l4 (hom-Precategory C x y))
+  (P₁ : subtype-hom-Precategory l4 C P₀)
   where
 
   is-subprecategory-Prop : Prop (l1 ⊔ l2 ⊔ l3 ⊔ l4)
@@ -137,9 +148,13 @@ Subprecategory :
 Subprecategory l3 l4 C =
   Σ ( subtype l3 (obj-Precategory C))
     ( λ P₀ →
-      Σ ( (x y : obj-Precategory C) → subtype l4 (hom-Precategory C x y))
+      Σ ( subtype-hom-Precategory l4 C P₀)
         ( is-subprecategory C P₀))
+```
 
+#### Objects in subprecategories
+
+```agda
 module _
   {l1 l2 l3 l4 : Level}
   (C : Precategory l1 l2)
@@ -168,73 +183,145 @@ module _
     is-in-obj-Subprecategory (inclusion-obj-Subprecategory x)
   is-in-obj-inclusion-obj-Subprecategory =
     is-in-subtype-inclusion-subtype subtype-obj-Subprecategory
+```
+
+#### Morphisms in subprecategories
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  (C : Precategory l1 l2)
+  (P : Subprecategory l3 l4 C)
+  where
 
   subtype-hom-Subprecategory :
-    (x y : obj-Precategory C) → subtype l4 (hom-Precategory C x y)
+    subtype-hom-Precategory l4 C (subtype-obj-Subprecategory C P)
   subtype-hom-Subprecategory = pr1 (pr2 P)
 
-  hom-Subprecategory : (x y : obj-Subprecategory) → UU (l2 ⊔ l4)
+  subtype-hom-obj-subprecategory-Subprecategory :
+    (x y : obj-Subprecategory C P) →
+    subtype l4
+      ( hom-Precategory C
+        ( inclusion-obj-Subprecategory C P x)
+        ( inclusion-obj-Subprecategory C P y))
+  subtype-hom-obj-subprecategory-Subprecategory x y =
+    subtype-hom-Subprecategory
+      ( inclusion-obj-Subprecategory C P x)
+      ( inclusion-obj-Subprecategory C P y)
+      ( is-in-obj-inclusion-obj-Subprecategory C P x)
+      ( is-in-obj-inclusion-obj-Subprecategory C P y)
+
+  hom-Subprecategory : (x y : obj-Subprecategory C P) → UU (l2 ⊔ l4)
   hom-Subprecategory x y =
-    type-subtype
-      ( subtype-hom-Subprecategory
-        ( inclusion-obj-Subprecategory x)
-        ( inclusion-obj-Subprecategory y))
+    type-subtype (subtype-hom-obj-subprecategory-Subprecategory x y)
 
   inclusion-hom-Subprecategory :
-    (x y : obj-Subprecategory) →
+    (x y : obj-Subprecategory C P) →
     hom-Subprecategory x y →
     hom-Precategory C
-      ( inclusion-obj-Subprecategory x)
-      ( inclusion-obj-Subprecategory y)
+      ( inclusion-obj-Subprecategory C P x)
+      ( inclusion-obj-Subprecategory C P y)
   inclusion-hom-Subprecategory x y =
-    inclusion-subtype
-      ( subtype-hom-Subprecategory
-        ( inclusion-obj-Subprecategory x)
-        ( inclusion-obj-Subprecategory y))
+    inclusion-subtype (subtype-hom-obj-subprecategory-Subprecategory x y)
+```
+
+The predicate on a morphism between subobjects of being contained in the
+subprecategory:
+
+```agda
+  is-in-hom-obj-subprecategory-Subprecategory :
+    ( x y : obj-Subprecategory C P) →
+    hom-Precategory C
+      ( inclusion-obj-Subprecategory C P x)
+      ( inclusion-obj-Subprecategory C P y) →
+    UU l4
+  is-in-hom-obj-subprecategory-Subprecategory x y =
+    is-in-subtype (subtype-hom-obj-subprecategory-Subprecategory x y)
+
+  is-prop-is-in-hom-obj-subprecategory-Subprecategory :
+    ( x y : obj-Subprecategory C P)
+    ( f :
+      hom-Precategory C
+        ( inclusion-obj-Subprecategory C P x)
+        ( inclusion-obj-Subprecategory C P y)) →
+    is-prop (is-in-hom-obj-subprecategory-Subprecategory x y f)
+  is-prop-is-in-hom-obj-subprecategory-Subprecategory x y =
+    is-prop-is-in-subtype (subtype-hom-obj-subprecategory-Subprecategory x y)
+```
+
+The predicate on a morphism between any objects of being contained in the
+subprecategory:
 
+```agda
   is-in-hom-Subprecategory :
-    (x y : obj-Precategory C) (f : hom-Precategory C x y) → UU l4
-  is-in-hom-Subprecategory x y = is-in-subtype (subtype-hom-Subprecategory x y)
+    (x y : obj-Precategory C) (f : hom-Precategory C x y) → UU (l3 ⊔ l4)
+  is-in-hom-Subprecategory x y f =
+    Σ ( is-in-obj-Subprecategory C P x)
+      ( λ x₀ →
+        Σ ( is-in-obj-Subprecategory C P y)
+          ( λ y₀ →
+            is-in-hom-obj-subprecategory-Subprecategory (x , x₀) (y , y₀) f))
 
   is-prop-is-in-hom-Subprecategory :
     (x y : obj-Precategory C) (f : hom-Precategory C x y) →
     is-prop (is-in-hom-Subprecategory x y f)
-  is-prop-is-in-hom-Subprecategory x y =
-    is-prop-is-in-subtype (subtype-hom-Subprecategory x y)
+  is-prop-is-in-hom-Subprecategory x y f =
+    is-prop-Σ
+      ( is-prop-is-in-obj-Subprecategory C P x)
+      ( λ x₀ →
+        is-prop-Σ
+          ( is-prop-is-in-obj-Subprecategory C P y)
+          ( λ y₀ →
+            is-prop-is-in-hom-obj-subprecategory-Subprecategory
+              ( x , x₀) (y , y₀) f))
+
+  is-in-hom-obj-subprecategory-inclusion-hom-Subprecategory :
+    (x y : obj-Subprecategory C P)
+    (f : hom-Subprecategory x y) →
+    is-in-hom-obj-subprecategory-Subprecategory x y
+      ( inclusion-hom-Subprecategory x y f)
+  is-in-hom-obj-subprecategory-inclusion-hom-Subprecategory x y f = pr2 f
 
   is-in-hom-inclusion-hom-Subprecategory :
-    (x y : obj-Subprecategory) (f : hom-Subprecategory x y) →
+    (x y : obj-Subprecategory C P)
+    (f : hom-Subprecategory x y) →
     is-in-hom-Subprecategory
-      ( inclusion-obj-Subprecategory x)
-      ( inclusion-obj-Subprecategory y)
+      ( inclusion-obj-Subprecategory C P x)
+      ( inclusion-obj-Subprecategory C P y)
       ( inclusion-hom-Subprecategory x y f)
-  is-in-hom-inclusion-hom-Subprecategory x y =
-    is-in-subtype-inclusion-subtype
-      ( subtype-hom-Subprecategory
-        ( inclusion-obj-Subprecategory x)
-        ( inclusion-obj-Subprecategory y))
+  pr1 (is-in-hom-inclusion-hom-Subprecategory x y f) =
+    is-in-obj-inclusion-obj-Subprecategory C P x
+  pr1 (pr2 (is-in-hom-inclusion-hom-Subprecategory x y f)) =
+    is-in-obj-inclusion-obj-Subprecategory C P y
+  pr2 (pr2 (is-in-hom-inclusion-hom-Subprecategory x y f)) =
+    is-in-hom-obj-subprecategory-inclusion-hom-Subprecategory x y f
+```
 
+#### Subprecategories are subprecategories
+
+```agda
   is-subprecategory-Subprecategory :
-    is-subprecategory C subtype-obj-Subprecategory subtype-hom-Subprecategory
+    is-subprecategory C
+      ( subtype-obj-Subprecategory C P) (subtype-hom-Subprecategory)
   is-subprecategory-Subprecategory = pr2 (pr2 P)
 
   contains-id-Subprecategory :
     contains-id-subtype-Precategory C
-      ( subtype-obj-Subprecategory)
+      ( subtype-obj-Subprecategory C P)
       ( subtype-hom-Subprecategory)
   contains-id-Subprecategory =
     contains-id-is-subprecategory C
-      ( subtype-obj-Subprecategory)
+      ( subtype-obj-Subprecategory C P)
       ( subtype-hom-Subprecategory)
       ( is-subprecategory-Subprecategory)
 
   is-closed-under-composition-Subprecategory :
     is-closed-under-composition-subtype-Precategory C
-      ( subtype-obj-Subprecategory)
+      ( subtype-obj-Subprecategory C P)
       ( subtype-hom-Subprecategory)
   is-closed-under-composition-Subprecategory =
     is-closed-under-composition-is-subprecategory C
-      ( subtype-obj-Subprecategory)
+      ( subtype-obj-Subprecategory C P)
       ( subtype-hom-Subprecategory)
       ( is-subprecategory-Subprecategory)
 ```
@@ -254,9 +341,7 @@ module _
       ( hom-set-Precategory C
         ( inclusion-obj-Subprecategory C P x)
         ( inclusion-obj-Subprecategory C P y))
-      ( subtype-hom-Subprecategory C P
-        ( inclusion-obj-Subprecategory C P x)
-        ( inclusion-obj-Subprecategory C P y))
+      ( subtype-hom-obj-subprecategory-Subprecategory C P x y)
 
   is-set-hom-Subprecategory :
     (x y : obj-Subprecategory C P) → is-set (hom-Subprecategory C P x y)
@@ -289,8 +374,8 @@ module _
       ( is-in-obj-inclusion-obj-Subprecategory C P x)
       ( is-in-obj-inclusion-obj-Subprecategory C P y)
       ( is-in-obj-inclusion-obj-Subprecategory C P z)
-      ( is-in-hom-inclusion-hom-Subprecategory C P y z g)
-      ( is-in-hom-inclusion-hom-Subprecategory C P x y f)
+      ( pr2 g)
+      ( pr2 f)
 
   associative-comp-hom-Subprecategory :
     {x y z w : obj-Subprecategory C P}
@@ -305,7 +390,9 @@ module _
     eq-type-subtype
       ( subtype-hom-Subprecategory C P
         ( inclusion-obj-Subprecategory C P x)
-        ( inclusion-obj-Subprecategory C P w))
+        ( inclusion-obj-Subprecategory C P w)
+        ( is-in-obj-inclusion-obj-Subprecategory C P x)
+        ( is-in-obj-inclusion-obj-Subprecategory C P w))
       ( associative-comp-hom-Precategory C
         ( inclusion-hom-Subprecategory C P z w h)
         ( inclusion-hom-Subprecategory C P y z g)
@@ -319,7 +406,9 @@ module _
     eq-type-subtype
       ( subtype-hom-Subprecategory C P
         ( inclusion-obj-Subprecategory C P x)
-        ( inclusion-obj-Subprecategory C P y))
+        ( inclusion-obj-Subprecategory C P y)
+        ( is-in-obj-inclusion-obj-Subprecategory C P x)
+        ( is-in-obj-inclusion-obj-Subprecategory C P y))
       ( left-unit-law-comp-hom-Precategory C
         ( inclusion-hom-Subprecategory C P x y f))
 
@@ -331,7 +420,9 @@ module _
     eq-type-subtype
       ( subtype-hom-Subprecategory C P
         ( inclusion-obj-Subprecategory C P x)
-        ( inclusion-obj-Subprecategory C P y))
+        ( inclusion-obj-Subprecategory C P y)
+        ( is-in-obj-inclusion-obj-Subprecategory C P x)
+        ( is-in-obj-inclusion-obj-Subprecategory C P y))
       ( right-unit-law-comp-hom-Precategory C
         ( inclusion-hom-Subprecategory C P x y f))
 
@@ -396,25 +487,6 @@ module _
     is-functor-inclusion-Subprecategory
 ```
 
-### Isomorphisms in subprecategories
-
-```agda
-module _
-  {l1 l2 l3 l4 : Level}
-  (C : Precategory l1 l2)
-  (P : Subprecategory l3 l4 C)
-  where
-
-  is-iso-Subprecategory :
-    {x y : obj-Subprecategory C P} → hom-Subprecategory C P x y → UU (l2 ⊔ l4)
-  is-iso-Subprecategory {x} {y} =
-    is-iso-Precategory (precategory-Subprecategory C P) {x} {y}
-
-  iso-Subprecategory :
-    (x y : obj-Subprecategory C P) → UU (l2 ⊔ l4)
-  iso-Subprecategory = iso-Precategory (precategory-Subprecategory C P)
-```
-
 ## Properties
 
 ### The inclusion functor is an embedding on objects and hom-sets
@@ -435,7 +507,9 @@ module _
     is-emb-inclusion-subtype
       ( subtype-hom-Subprecategory C P
         ( inclusion-obj-Subprecategory C P x)
-        ( inclusion-obj-Subprecategory C P y))
+        ( inclusion-obj-Subprecategory C P y)
+        ( is-in-obj-inclusion-obj-Subprecategory C P x)
+        ( is-in-obj-inclusion-obj-Subprecategory C P y))
 
   is-emb-obj-inclusion-Subprecategory :
     is-emb
@@ -446,47 +520,3 @@ module _
   is-emb-obj-inclusion-Subprecategory =
     is-emb-inclusion-subtype (subtype-obj-Subprecategory C P)
 ```
-
-### Subprecategories of categories are categories
-
-```agda
-module _
-  {l1 l2 l3 l4 : Level}
-  (C : Precategory l1 l2)
-  (P : Subprecategory l3 l4 C)
-  (is-category-C : is-category-Precategory C)
-  {x y : obj-Subprecategory C P}
-  (f : hom-Subprecategory C P x y)
-  (is-iso-f : is-iso-Precategory C (inclusion-hom-Subprecategory C P x y f))
-  where
-
-  contains-is-iso-is-category-Subprecategory : is-iso-Subprecategory C P f
-  contains-is-iso-is-category-Subprecategory =
-    ind-iso-Category (C , is-category-C)
-      ( λ Y e →
-        ( p : is-in-obj-Subprecategory C P Y)
-        ( q :
-          is-in-hom-Subprecategory C P
-            ( inclusion-obj-Subprecategory C P x)
-            ( Y)
-            ( hom-iso-Precategory C e)) →
-        is-iso-Subprecategory C P {x} {Y , p} (hom-iso-Precategory C e , q))
-      ( ( ind-subsingleton
-          ( is-prop-is-in-hom-Subprecategory C P
-            ( inclusion-obj-Subprecategory C P x)
-            ( inclusion-obj-Subprecategory C P x)
-            ( id-hom-Precategory C))
-          ( contains-id-Subprecategory C P
-            ( inclusion-obj-Subprecategory C P x)
-            ( is-in-obj-inclusion-obj-Subprecategory C P x))) ∘
-        ( ind-subsingleton
-          ( is-prop-is-in-obj-Subprecategory C P
-            ( inclusion-obj-Subprecategory C P x))
-          ( is-in-obj-inclusion-obj-Subprecategory C P x)
-          ( is-iso-id-hom-Precategory (precategory-Subprecategory C P) {x})))
-      ( inclusion-hom-Subprecategory C P x y f , is-iso-f)
-      ( is-in-obj-inclusion-obj-Subprecategory C P y)
-      ( is-in-hom-inclusion-hom-Subprecategory C P x y f)
-```
-
-It remains to show that subprecategories of categories indeed are categories.
diff --git a/src/category-theory/terminal-objects-precategories.lagda.md b/src/category-theory/terminal-objects-precategories.lagda.md
index 22d9b360c7..5a1fcb7d9c 100644
--- a/src/category-theory/terminal-objects-precategories.lagda.md
+++ b/src/category-theory/terminal-objects-precategories.lagda.md
@@ -1,4 +1,4 @@
-# Terminal object in a precategory
+# Terminal objects in a precategory
 
 ```agda
 module category-theory.terminal-objects-precategories where
@@ -12,9 +12,8 @@ open import category-theory.precategories
 open import foundation.contractible-types
 open import foundation.dependent-pair-types
 open import foundation.function-types
+open import foundation.identity-types
 open import foundation.universe-levels
-
-open import foundation-core.identity-types
 ```
 
 </details>
diff --git a/src/category-theory/yoneda-lemma-categories.lagda.md b/src/category-theory/yoneda-lemma-categories.lagda.md
index 41533f11f5..87ebe92e2e 100644
--- a/src/category-theory/yoneda-lemma-categories.lagda.md
+++ b/src/category-theory/yoneda-lemma-categories.lagda.md
@@ -8,17 +8,13 @@ module category-theory.yoneda-lemma-categories where
 
 ```agda
 open import category-theory.categories
-open import category-theory.functors-categories
-open import category-theory.natural-transformations-functors-categories
+open import category-theory.copresheaf-categories
+open import category-theory.natural-transformations-functors-from-small-to-large-categories
 open import category-theory.representable-functors-categories
 open import category-theory.yoneda-lemma-precategories
 
 open import foundation.category-of-sets
-open import foundation.dependent-pair-types
 open import foundation.equivalences
-open import foundation.retractions
-open import foundation.sections
-open import foundation.sets
 open import foundation.universe-levels
 ```
 
@@ -28,61 +24,90 @@ open import foundation.universe-levels
 
 Given a [category](category-theory.categories.md) `C`, an object `c`, and a
 [functor](category-theory.functors-categories.md) `F` from `C` to the
-[category of sets](foundation.category-of-sets.md), there is an
-[equivalence](foundation-core.equivalences.md) between the
+[category of sets](foundation.category-of-sets.md)
+
+```text
+  F : C → Set,
+```
+
+there is an [equivalence](foundation-core.equivalences.md) between the
 [set of natural transformations](category-theory.natural-transformations-functors-categories.md)
 from the functor
 [represented](category-theory.representable-functors-categories.md) by `c` to
 `F` and the [set](foundation-core.sets.md) `F c`.
 
+```text
+  Nat(Hom(c , -) , F) ≃ F c
+```
+
 More precisely, the **Yoneda lemma** asserts that the map from the type of
 natural transformations to the type `F c` defined by evaluating the component of
 the natural transformation at the object `c` at the identity arrow on `c` is an
 equivalence.
 
-## Definition
+## Theorem
+
+### The yoneda lemma into the large category of sets
 
 ```agda
 module _
-  {l1 l2 : Level} (C : Category l1 l2) (c : obj-Category C)
-  (F : functor-Category C (Set-Category l2))
+  {l1 l2 l3 : Level} (C : Category l1 l2) (c : obj-Category C)
+  (F : obj-copresheaf-Large-Category (precategory-Category C) l3)
   where
 
-  yoneda-evid-Category :
-    natural-transformation-Category
-      ( C)
-      ( Set-Category l2)
-      ( representable-functor-Category C c)
-      ( F) →
-    type-Set (obj-functor-Category C (Set-Category l2) F c)
-  yoneda-evid-Category = yoneda-evid-Precategory (precategory-Category C) c F
-
-  yoneda-extension-Category :
-    type-Set (obj-functor-Category C (Set-Category l2) F c) →
-    natural-transformation-Category
-      C (Set-Category l2) (representable-functor-Category C c) F
-  yoneda-extension-Category =
-    yoneda-extension-Precategory (precategory-Category C) c F
-
-  section-yoneda-evid-Category :
-    section yoneda-evid-Category
-  section-yoneda-evid-Category =
-    section-yoneda-evid-Precategory (precategory-Category C) c F
-
-  retraction-yoneda-evid-Category :
-    retraction yoneda-evid-Category
-  retraction-yoneda-evid-Category =
-    retraction-yoneda-evid-Precategory (precategory-Category C) c F
-
-  yoneda-lemma-Category : is-equiv yoneda-evid-Category
-  yoneda-lemma-Category = yoneda-lemma-Precategory (precategory-Category C) c F
-
-  equiv-yoneda-lemma-Category :
-    ( natural-transformation-Category
-      ( C)
-      ( Set-Category l2)
-      ( representable-functor-Category C c) (F)) ≃
-    ( type-Set (obj-functor-Category C (Set-Category l2) F c))
-  pr1 equiv-yoneda-lemma-Category = yoneda-evid-Category
-  pr2 equiv-yoneda-lemma-Category = yoneda-lemma-Category
+  map-yoneda-Category :
+    hom-copresheaf-Large-Category
+      ( precategory-Category C) (representable-functor-Category C c) F →
+    section-copresheaf-Category (precategory-Category C) F c
+  map-yoneda-Category =
+    map-yoneda-Precategory (precategory-Category C) c F
+```
+
+The inverse to the Yoneda map:
+
+```agda
+  hom-family-extension-yoneda-Category :
+    (u : section-copresheaf-Category (precategory-Category C) F c) →
+    hom-family-functor-Small-Large-Category
+      C Set-Large-Category (representable-functor-Category C c) F
+  hom-family-extension-yoneda-Category =
+    hom-family-extension-yoneda-Precategory (precategory-Category C) c F
+
+  naturality-extension-yoneda-Category :
+    (u : section-copresheaf-Category (precategory-Category C) F c) →
+    is-natural-transformation-Small-Large-Category
+      C Set-Large-Category (representable-functor-Category C c) F
+      ( hom-family-extension-yoneda-Category u)
+  naturality-extension-yoneda-Category =
+    naturality-extension-yoneda-Precategory (precategory-Category C) c F
+
+  extension-yoneda-Category :
+    section-copresheaf-Category (precategory-Category C) F c →
+    hom-copresheaf-Large-Category
+      ( precategory-Category C) (representable-functor-Category C c) F
+  extension-yoneda-Category =
+    extension-yoneda-Precategory (precategory-Category C) c F
+
+  lemma-yoneda-Category : is-equiv map-yoneda-Category
+  lemma-yoneda-Category = lemma-yoneda-Precategory (precategory-Category C) c F
+
+  equiv-lemma-yoneda-Category :
+    hom-copresheaf-Large-Category
+      ( precategory-Category C) (representable-functor-Category C c) F ≃
+    section-copresheaf-Category (precategory-Category C) F c
+  equiv-lemma-yoneda-Category =
+    equiv-lemma-yoneda-Precategory (precategory-Category C) c F
 ```
+
+## See also
+
+- [Presheaf categories](category-theory.presheaf-categories.md)
+
+## External links
+
+- [The Yoneda embedding](https://1lab.dev/Cat.Functor.Hom.html#the-yoneda-embedding)
+  at 1lab
+- [Yoneda lemma](https://ncatlab.org/nlab/show/Yoneda+lemma) at nlab
+- [The Yoneda lemma](https://www.math3ma.com/blog/the-yoneda-lemma) at Math3ma
+- [Yoneda lemma](https://en.wikipedia.org/wiki/Yoneda_lemma) at Wikipedia
+- [Yoneda lemma](https://www.wikidata.org/wiki/Q320577) at Wikidata
diff --git a/src/category-theory/yoneda-lemma-precategories.lagda.md b/src/category-theory/yoneda-lemma-precategories.lagda.md
index 1c388211fc..e0e445ac2f 100644
--- a/src/category-theory/yoneda-lemma-precategories.lagda.md
+++ b/src/category-theory/yoneda-lemma-precategories.lagda.md
@@ -7,9 +7,13 @@ module category-theory.yoneda-lemma-precategories where
 <details><summary>Imports</summary>
 
 ```agda
+open import category-theory.copresheaf-categories
+open import category-theory.functors-from-small-to-large-precategories
 open import category-theory.functors-precategories
+open import category-theory.natural-transformations-functors-from-small-to-large-precategories
 open import category-theory.natural-transformations-functors-precategories
 open import category-theory.precategories
+open import category-theory.presheaf-categories
 open import category-theory.representable-functors-precategories
 
 open import foundation.action-on-identifications-functions
@@ -17,6 +21,8 @@ open import foundation.category-of-sets
 open import foundation.dependent-pair-types
 open import foundation.equivalences
 open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.homotopies
 open import foundation.identity-types
 open import foundation.retractions
 open import foundation.sections
@@ -31,87 +37,136 @@ open import foundation.universe-levels
 
 Given a [precategory](category-theory.precategories.md) `C`, an object `c`, and
 a [functor](category-theory.functors-precategories.md) `F` from `C` to the
-[precategory of sets](foundation.category-of-sets.md), there is an
-[equivalence](foundation-core.equivalences.md) between the
+[category of sets](foundation.category-of-sets.md)
+
+```text
+  F : C → Set,
+```
+
+there is an [equivalence](foundation-core.equivalences.md) between the
 [set of natural transformations](category-theory.natural-transformations-functors-precategories.md)
 from the functor
 [represented](category-theory.representable-functors-precategories.md) by `c` to
 `F` and the [set](foundation-core.sets.md) `F c`.
 
+```text
+  Nat(Hom(c , -) , F) ≃ F c
+```
+
 More precisely, the **Yoneda lemma** asserts that the map from the type of
 natural transformations to the type `F c` defined by evaluating the component of
 the natural transformation at the object `c` at the identity arrow on `c` is an
 equivalence.
 
-## Definition
+## Theorem
+
+### The yoneda lemma into the large category of sets
 
 ```agda
 module _
-  {l1 l2 : Level} (C : Precategory l1 l2) (c : obj-Precategory C)
-  (F : functor-Precategory C (Set-Precategory l2))
+  {l1 l2 l3 : Level} (C : Precategory l1 l2) (c : obj-Precategory C)
+  (F : obj-copresheaf-Large-Category C l3)
   where
 
-  yoneda-evid-Precategory :
-    natural-transformation-Precategory
-      ( C)
-      ( Set-Precategory l2)
-      ( representable-functor-Precategory C c)
-      ( F) →
-    type-Set (obj-functor-Precategory C (Set-Precategory l2) F c)
-  yoneda-evid-Precategory α =
-    hom-family-natural-transformation-Precategory
+  map-yoneda-Precategory :
+    hom-copresheaf-Large-Category C (representable-functor-Precategory C c) F →
+    section-copresheaf-Category C F c
+  map-yoneda-Precategory σ =
+    hom-family-natural-transformation-Small-Large-Precategory
       ( C)
-      ( Set-Precategory l2)
+      ( Set-Large-Precategory)
       ( representable-functor-Precategory C c)
       ( F)
-      ( α)
+      ( σ)
       ( c)
       ( id-hom-Precategory C)
+```
 
-  yoneda-extension-Precategory :
-    type-Set (obj-functor-Precategory C (Set-Precategory l2) F c) →
-    natural-transformation-Precategory
-      C (Set-Precategory l2) (representable-functor-Precategory C c) F
-  pr1 (yoneda-extension-Precategory u) x f =
-    hom-functor-Precategory C (Set-Precategory l2) F f u
-  pr2 (yoneda-extension-Precategory u) g =
+The inverse to the Yoneda map:
+
+```agda
+  hom-family-extension-yoneda-Precategory :
+    (u : section-copresheaf-Category C F c) →
+    hom-family-functor-Small-Large-Precategory
+      C Set-Large-Precategory (representable-functor-Precategory C c) F
+  hom-family-extension-yoneda-Precategory u x f =
+    hom-functor-Small-Large-Precategory C Set-Large-Precategory F f u
+
+  naturality-extension-yoneda-Precategory :
+    (u : section-copresheaf-Category C F c) →
+    is-natural-transformation-Small-Large-Precategory
+      C Set-Large-Precategory (representable-functor-Precategory C c) F
+      ( hom-family-extension-yoneda-Precategory u)
+  naturality-extension-yoneda-Precategory u g =
     eq-htpy
       ( λ f →
         htpy-eq
           ( inv
-            ( preserves-comp-functor-Precategory C (Set-Precategory l2) F g f))
+            ( preserves-comp-functor-Small-Large-Precategory
+                C Set-Large-Precategory F g f))
           ( u))
 
-  section-yoneda-evid-Precategory :
-    section yoneda-evid-Precategory
-  pr1 section-yoneda-evid-Precategory = yoneda-extension-Precategory
-  pr2 section-yoneda-evid-Precategory =
-    htpy-eq (preserves-id-functor-Precategory C (Set-Precategory l2) F c)
+  extension-yoneda-Precategory :
+    section-copresheaf-Category C F c →
+    hom-copresheaf-Large-Category C (representable-functor-Precategory C c) F
+  pr1 (extension-yoneda-Precategory u) =
+    hom-family-extension-yoneda-Precategory u
+  pr2 (extension-yoneda-Precategory u) =
+    naturality-extension-yoneda-Precategory u
+```
 
-  retraction-yoneda-evid-Precategory :
-    retraction yoneda-evid-Precategory
-  pr1 retraction-yoneda-evid-Precategory = yoneda-extension-Precategory
-  pr2 retraction-yoneda-evid-Precategory α =
+The inverse is an inverse:
+
+```agda
+  is-section-extension-yoneda-Precategory :
+    ( map-yoneda-Precategory ∘
+      extension-yoneda-Precategory) ~
+    id
+  is-section-extension-yoneda-Precategory =
+    htpy-eq
+      ( preserves-id-functor-Small-Large-Precategory
+          C Set-Large-Precategory F c)
+
+  is-retraction-extension-yoneda-Precategory :
+    ( extension-yoneda-Precategory ∘
+      map-yoneda-Precategory) ~
+    id
+  is-retraction-extension-yoneda-Precategory σ =
     eq-type-subtype
-      ( is-natural-transformation-prop-Precategory
-        ( C) (Set-Precategory l2) (representable-functor-Precategory C c) F)
+      ( is-natural-transformation-prop-Small-Large-Precategory
+        ( C) Set-Large-Precategory (representable-functor-Precategory C c) F)
       ( eq-htpy
         ( λ x →
           eq-htpy
             ( λ f →
               ( htpy-eq
-                ( (pr2 α) f)
-                ( (id-hom-Precategory C))) ∙
-              ( ap (pr1 α x) (right-unit-law-comp-hom-Precategory C f)))))
-
-  yoneda-lemma-Precategory : is-equiv yoneda-evid-Precategory
-  pr1 yoneda-lemma-Precategory = section-yoneda-evid-Precategory
-  pr2 yoneda-lemma-Precategory = retraction-yoneda-evid-Precategory
-
-  equiv-yoneda-lemma-Precategory :
-    ( natural-transformation-Precategory C (Set-Precategory l2)
-      ( representable-functor-Precategory C c) (F)) ≃
-    ( type-Set (obj-functor-Precategory C (Set-Precategory l2) F c))
-  pr1 equiv-yoneda-lemma-Precategory = yoneda-evid-Precategory
-  pr2 equiv-yoneda-lemma-Precategory = yoneda-lemma-Precategory
+                ( pr2 σ f)
+                ( id-hom-Precategory C)) ∙
+              ( ap (pr1 σ x) (right-unit-law-comp-hom-Precategory C f)))))
+
+  lemma-yoneda-Precategory : is-equiv map-yoneda-Precategory
+  lemma-yoneda-Precategory =
+    is-equiv-is-invertible
+      ( extension-yoneda-Precategory)
+      ( is-section-extension-yoneda-Precategory)
+      ( is-retraction-extension-yoneda-Precategory)
+
+  equiv-lemma-yoneda-Precategory :
+    hom-copresheaf-Large-Category C (representable-functor-Precategory C c) F ≃
+    section-copresheaf-Category C F c
+  pr1 equiv-lemma-yoneda-Precategory = map-yoneda-Precategory
+  pr2 equiv-lemma-yoneda-Precategory = lemma-yoneda-Precategory
 ```
+
+## See also
+
+- [Presheaf categories](category-theory.presheaf-categories.md)
+
+## External links
+
+- [The Yoneda embedding](https://1lab.dev/Cat.Functor.Hom.html#the-yoneda-embedding)
+  at 1lab
+- [Yoneda lemma](https://ncatlab.org/nlab/show/Yoneda+lemma) at nlab
+- [The Yoneda lemma](https://www.math3ma.com/blog/the-yoneda-lemma) at Math3ma
+- [Yoneda lemma](https://en.wikipedia.org/wiki/Yoneda_lemma) at Wikipedia
+- [Yoneda lemma](https://www.wikidata.org/wiki/Q320577) at Wikidata
diff --git a/src/elementary-number-theory/peano-arithmetic.lagda.md b/src/elementary-number-theory/peano-arithmetic.lagda.md
index cb43d0bc30..ef15756228 100644
--- a/src/elementary-number-theory/peano-arithmetic.lagda.md
+++ b/src/elementary-number-theory/peano-arithmetic.lagda.md
@@ -41,7 +41,8 @@ peano-1-ℕ = zero-ℕ
 
 ## Peano's 2nd axiom
 
-The identity relation on the natural numbers is reflexive.
+The identity relation on the natural numbers is reflexive. I.e. for every
+natural number `x`, it is true that `x ＝ x`.
 
 ```agda
 peano-axiom-2 : {l : Level} → UU l → UU l
@@ -53,7 +54,8 @@ peano-2-ℕ x = refl
 
 ### Peano's 3rd axiom
 
-The identity relation on the natural numbers is symmetric.
+The identity relation on the natural numbers is symmetric. I.e. if `x ＝ y`,
+then `y ＝ x`.
 
 ```agda
 peano-axiom-3 : {l : Level} → UU l → UU l
@@ -65,7 +67,8 @@ peano-3-ℕ x y = inv
 
 ### Peano's 4th axiom
 
-The identity relation on the natural numbers is transitive.
+The identity relation on the natural numbers is transitive. I.e. if `y ＝ z` and
+`x ＝ y`, then `x ＝ z`.
 
 ```agda
 peano-axiom-4 : {l : Level} → UU l → UU l
@@ -80,7 +83,8 @@ peano-4-ℕ x y z = concat' x
 The 5th axiom of peano's arithmetic states that for every `x` and `y`, if
 `x ＝ y` and `y` is a natural number, then `x` is a natural number. This axiom
 does not make sense in type theory, as every element by definition lives in a
-specified type.
+specified type. To even pose the question of whether two elements are equal, we
+must already know that they are elements of the same type.
 
 ### Peano's 6th axiom
 
diff --git a/src/foundation-core/1-types.lagda.md b/src/foundation-core/1-types.lagda.md
index f38795650c..79ac7bd491 100644
--- a/src/foundation-core/1-types.lagda.md
+++ b/src/foundation-core/1-types.lagda.md
@@ -7,13 +7,15 @@ module foundation-core.1-types where
 <details><summary>Imports</summary>
 
 ```agda
+open import foundation.contractible-types
 open import foundation.dependent-pair-types
+open import foundation.truncated-types
 open import foundation.universe-levels
 
 open import foundation-core.equivalences
 open import foundation-core.identity-types
+open import foundation-core.propositions
 open import foundation-core.sets
-open import foundation-core.truncated-types
 open import foundation-core.truncation-levels
 ```
 
@@ -52,9 +54,36 @@ pr2 (Id-Set X x y) = is-1-type-type-1-Type X x y
 ### Any set is a 1-type
 
 ```agda
+abstract
+  is-1-type-is-set :
+    {l : Level} {A : UU l} → is-set A → is-1-type A
+  is-1-type-is-set = is-trunc-succ-is-trunc zero-𝕋
+
 1-type-Set :
   {l : Level} → Set l → 1-Type l
-1-type-Set A = truncated-type-succ-Truncated-Type zero-𝕋 A
+1-type-Set = truncated-type-succ-Truncated-Type zero-𝕋
+```
+
+### Any proposition is a 1-type
+
+```agda
+abstract
+  is-1-type-is-prop :
+    {l : Level} {P : UU l} → is-prop P → is-1-type P
+  is-1-type-is-prop = is-trunc-iterated-succ-is-trunc neg-one-𝕋 2
+
+1-type-Prop :
+  {l : Level} → Prop l → 1-Type l
+1-type-Prop P = truncated-type-iterated-succ-Truncated-Type neg-one-𝕋 2 P
+```
+
+### Any contractible type is a 1-type
+
+```agda
+abstract
+  is-1-type-is-contr :
+    {l : Level} {A : UU l} → is-contr A → is-1-type A
+  is-1-type-is-contr = is-trunc-is-contr one-𝕋
 ```
 
 ### The 1-types are closed under equivalences
diff --git a/src/foundation-core/equality-dependent-pair-types.lagda.md b/src/foundation-core/equality-dependent-pair-types.lagda.md
index 4b812e58ea..9cf8a462d2 100644
--- a/src/foundation-core/equality-dependent-pair-types.lagda.md
+++ b/src/foundation-core/equality-dependent-pair-types.lagda.md
@@ -60,17 +60,17 @@ module _
   eq-pair-Σ' : {s t : Σ A B} → Eq-Σ s t → s ＝ t
   eq-pair-Σ' p = eq-pair-Σ (pr1 p) (pr2 p)
 
-  eq-pair-Σ-eq-pr1 :
+  eq-pair-eq-pr1 :
     {x y : A} {s : B x} (p : x ＝ y) → (x , s) ＝ (y , tr B p s)
-  eq-pair-Σ-eq-pr1 refl = refl
+  eq-pair-eq-pr1 refl = refl
 
-  eq-pair-Σ-eq-pr1' :
+  eq-pair-eq-pr1' :
     {x y : A} {t : B y} (p : x ＝ y) → (x , tr B (inv p) t) ＝ (y , t)
-  eq-pair-Σ-eq-pr1' refl = refl
+  eq-pair-eq-pr1' refl = refl
 
-  eq-pair-Σ-eq-pr2 :
+  eq-pair-eq-pr2 :
     {x : A} {s t : B x} → s ＝ t → (x , s) ＝ (x , t)
-  eq-pair-Σ-eq-pr2 {x} = ap {B = Σ A B} (pair x)
+  eq-pair-eq-pr2 {x} = ap {B = Σ A B} (pair x)
 
   is-retraction-pair-eq-Σ :
     (s t : Σ A B) →
diff --git a/src/foundation-core/identity-types.lagda.md b/src/foundation-core/identity-types.lagda.md
index 5fd87e8523..236c8d76ea 100644
--- a/src/foundation-core/identity-types.lagda.md
+++ b/src/foundation-core/identity-types.lagda.md
@@ -132,24 +132,24 @@ module _
     ((p ∙ q) ∙ r) ＝ (p ∙ (q ∙ r))
   assoc refl q r = refl
 
-  left-unit : {x y : A} {p : x ＝ y} → (refl ∙ p) ＝ p
+  left-unit : {x y : A} {p : x ＝ y} → refl ∙ p ＝ p
   left-unit = refl
 
-  right-unit : {x y : A} {p : x ＝ y} → (p ∙ refl) ＝ p
+  right-unit : {x y : A} {p : x ＝ y} → p ∙ refl ＝ p
   right-unit {p = refl} = refl
 
-  left-inv : {x y : A} (p : x ＝ y) → ((inv p) ∙ p) ＝ refl
+  left-inv : {x y : A} (p : x ＝ y) → inv p ∙ p ＝ refl
   left-inv refl = refl
 
-  right-inv : {x y : A} (p : x ＝ y) → (p ∙ (inv p)) ＝ refl
+  right-inv : {x y : A} (p : x ＝ y) → p ∙ (inv p) ＝ refl
   right-inv refl = refl
 
-  inv-inv : {x y : A} (p : x ＝ y) → (inv (inv p)) ＝ p
+  inv-inv : {x y : A} (p : x ＝ y) → inv (inv p) ＝ p
   inv-inv refl = refl
 
   distributive-inv-concat :
     {x y : A} (p : x ＝ y) {z : A} (q : y ＝ z) →
-    (inv (p ∙ q)) ＝ ((inv q) ∙ (inv p))
+    inv (p ∙ q) ＝ inv q ∙ inv p
   distributive-inv-concat refl refl = refl
 ```
 
diff --git a/src/foundation-core/path-split-maps.lagda.md b/src/foundation-core/path-split-maps.lagda.md
index 126b395ea6..66ae437fa4 100644
--- a/src/foundation-core/path-split-maps.lagda.md
+++ b/src/foundation-core/path-split-maps.lagda.md
@@ -90,8 +90,7 @@ module _
 
 1. Univalent Foundations Project, _Homotopy Type Theory – Univalent Foundations
    of Mathematics_ (2013) ([website](https://homotopytypetheory.org/book/),
-   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729),
-   [DOI:10.48550](https://doi.org/10.48550/arXiv.1308.0729))
+   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729))
 2. Mike Shulman, _Universal properties without function extensionality_
    (November 2014)
    ([HoTT Blog](https://homotopytypetheory.org/2014/11/02/universal-properties-without-function-extensionality/))
diff --git a/src/foundation-core/propositions.lagda.md b/src/foundation-core/propositions.lagda.md
index 1b394e0c5a..a7f898320f 100644
--- a/src/foundation-core/propositions.lagda.md
+++ b/src/foundation-core/propositions.lagda.md
@@ -270,229 +270,6 @@ pr1 (Π-Prop' A P) = type-Π-Prop' A P
 pr2 (Π-Prop' A P) = is-prop-Π' (λ x → is-prop-type-Prop (P x))
 ```
 
-For convenience, we also record repeated applications of the above.
-
-#### Higher order products of families of propositions are propositions
-
-```agda
-is-prop-Π² :
-  {l1 l2 l3 : Level}
-  {A1 : UU l1} {A2 : A1 → UU l2} {A3 : (x1 : A1) (x2 : A2 x1) → UU l3} →
-  ((x1 : A1) (x2 : A2 x1) → is-prop (A3 x1 x2)) →
-  is-prop ((x1 : A1) (x2 : A2 x1) → A3 x1 x2)
-is-prop-Π² H = is-prop-Π (is-prop-Π ∘ H)
-
-is-prop-Π³ :
-  {l1 l2 l3 l4 : Level}
-  {A1 : UU l1}
-  {A2 : A1 → UU l2}
-  {A3 : (x1 : A1) (x2 : A2 x1) → UU l3}
-  {A4 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → UU l4} →
-  ((x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → is-prop (A4 x1 x2 x3)) →
-  is-prop ((x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → A4 x1 x2 x3)
-is-prop-Π³ H = is-prop-Π (is-prop-Π² ∘ H)
-
-is-prop-Π⁴ :
-  {l1 l2 l3 l4 l5 : Level}
-  {A1 : UU l1}
-  {A2 : A1 → UU l2}
-  {A3 : (x1 : A1) (x2 : A2 x1) → UU l3}
-  {A4 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → UU l4}
-  {A5 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) → UU l5} →
-  ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) →
-    is-prop (A5 x1 x2 x3 x4)) →
-  is-prop
-    ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) →
-      A5 x1 x2 x3 x4)
-is-prop-Π⁴ H = is-prop-Π (is-prop-Π³ ∘ H)
-
-is-prop-Π⁵ :
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A1 : UU l1}
-  {A2 : A1 → UU l2}
-  {A3 : (x1 : A1) (x2 : A2 x1) → UU l3}
-  {A4 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → UU l4}
-  {A5 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) → UU l5} →
-  {A6 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) →
-    UU l6} →
-  ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) →
-    is-prop (A6 x1 x2 x3 x4 x5)) →
-  is-prop
-    ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-      (x5 : A5 x1 x2 x3 x4) →
-      A6 x1 x2 x3 x4 x5)
-is-prop-Π⁵ H = is-prop-Π (is-prop-Π⁴ ∘ H)
-
-is-prop-Π⁶ :
-  {l1 l2 l3 l4 l5 l6 l7 : Level}
-  {A1 : UU l1}
-  {A2 : A1 → UU l2}
-  {A3 : (x1 : A1) (x2 : A2 x1) → UU l3}
-  {A4 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → UU l4}
-  {A5 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) → UU l5} →
-  {A6 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) → UU l6} →
-  {A7 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5) → UU l7} →
-  ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5) →
-    is-prop (A7 x1 x2 x3 x4 x5 x6)) →
-  is-prop
-    ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-      (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5) →
-      A7 x1 x2 x3 x4 x5 x6)
-is-prop-Π⁶ H = is-prop-Π (is-prop-Π⁵ ∘ H)
-
-is-prop-Π⁷ :
-  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
-  {A1 : UU l1}
-  {A2 : A1 → UU l2}
-  {A3 : (x1 : A1) (x2 : A2 x1) → UU l3}
-  {A4 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → UU l4}
-  {A5 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) → UU l5} →
-  {A6 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) → UU l6} →
-  {A7 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5) → UU l7} →
-  {A8 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) → UU l8} →
-  ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) →
-    is-prop (A8 x1 x2 x3 x4 x5 x6 x7)) →
-  is-prop
-    ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-      (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-      (x7 : A7 x1 x2 x3 x4 x5 x6) →
-      A8 x1 x2 x3 x4 x5 x6 x7)
-is-prop-Π⁷ H = is-prop-Π (is-prop-Π⁶ ∘ H)
-
-is-prop-Π⁸ :
-  {l1 l2 l3 l4 l5 l6 l7 l8 l9 : Level}
-  {A1 : UU l1}
-  {A2 : A1 → UU l2}
-  {A3 : (x1 : A1) (x2 : A2 x1) → UU l3}
-  {A4 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → UU l4}
-  {A5 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) → UU l5}
-  {A6 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) → UU l6} →
-  {A7 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5) → UU l7}
-  {A8 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) → UU l8}
-  {A9 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7) → UU l9} →
-  ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7) →
-    is-prop (A9 x1 x2 x3 x4 x5 x6 x7 x8)) →
-  is-prop
-    ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-      (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-      (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7) →
-      A9 x1 x2 x3 x4 x5 x6 x7 x8)
-is-prop-Π⁸ H = is-prop-Π (is-prop-Π⁷ ∘ H)
-
-is-prop-Π⁹ :
-  {l1 l2 l3 l4 l5 l6 l7 l8 l9 l10 : Level}
-  {A1 : UU l1}
-  {A2 : A1 → UU l2}
-  {A3 : (x1 : A1) (x2 : A2 x1) → UU l3}
-  {A4 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → UU l4}
-  {A5 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) → UU l5}
-  {A6 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) → UU l6} →
-  {A7 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5) → UU l7}
-  {A8 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) → UU l8}
-  {A9 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7) → UU l9} →
-  {A10 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7)
-    (x9 : A9 x1 x2 x3 x4 x5 x6 x7 x8) → UU l10} →
-  ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7)
-    (x9 : A9 x1 x2 x3 x4 x5 x6 x7 x8) →
-    is-prop (A10 x1 x2 x3 x4 x5 x6 x7 x8 x9)) →
-  is-prop
-    ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-      (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-      (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7)
-      (x9 : A9 x1 x2 x3 x4 x5 x6 x7 x8) →
-      A10 x1 x2 x3 x4 x5 x6 x7 x8 x9)
-is-prop-Π⁹ H = is-prop-Π (is-prop-Π⁸ ∘ H)
-
-is-prop-Π¹⁰ :
-  {l1 l2 l3 l4 l5 l6 l7 l8 l9 l10 l11 : Level}
-  {A1 : UU l1}
-  {A2 : A1 → UU l2}
-  {A3 : (x1 : A1) (x2 : A2 x1) → UU l3}
-  {A4 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) → UU l4}
-  {A5 : (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3) → UU l5}
-  {A6 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) → UU l6} →
-  {A7 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5) → UU l7}
-  {A8 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) → UU l8}
-  {A9 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7) → UU l9} →
-  {A10 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7)
-    (x9 : A9 x1 x2 x3 x4 x5 x6 x7 x8) → UU l10}
-  {A11 :
-    (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7)
-    (x9 : A9 x1 x2 x3 x4 x5 x6 x7 x8) (x10 : A10 x1 x2 x3 x4 x5 x6 x7 x8 x9) →
-    UU l11} →
-  ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-    (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-    (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7)
-    (x9 : A9 x1 x2 x3 x4 x5 x6 x7 x8) (x10 : A10 x1 x2 x3 x4 x5 x6 x7 x8 x9) →
-    is-prop (A11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10)) →
-  is-prop
-    ( (x1 : A1) (x2 : A2 x1) (x3 : A3 x1 x2) (x4 : A4 x1 x2 x3)
-      (x5 : A5 x1 x2 x3 x4) (x6 : A6 x1 x2 x3 x4 x5)
-      (x7 : A7 x1 x2 x3 x4 x5 x6) (x8 : A8 x1 x2 x3 x4 x5 x6 x7)
-      (x9 : A9 x1 x2 x3 x4 x5 x6 x7 x8) (x10 : A10 x1 x2 x3 x4 x5 x6 x7 x8 x9) →
-      A11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10)
-is-prop-Π¹⁰ H = is-prop-Π (is-prop-Π⁹ ∘ H)
-```
-
 ### The type of functions into a proposition is a proposition
 
 ```agda
diff --git a/src/foundation-core/pullbacks.lagda.md b/src/foundation-core/pullbacks.lagda.md
index 4573e9cffc..e047eee49c 100644
--- a/src/foundation-core/pullbacks.lagda.md
+++ b/src/foundation-core/pullbacks.lagda.md
@@ -298,8 +298,8 @@ inv-inv-map-commutative-standard-pullback :
   ( map-commutative-standard-pullback f g ∘
     map-commutative-standard-pullback g f) ~ id
 inv-inv-map-commutative-standard-pullback f g x =
-  eq-pair-Σ-eq-pr2
-    ( eq-pair-Σ-eq-pr2
+  eq-pair-eq-pr2
+    ( eq-pair-eq-pr2
       ( inv-inv (coherence-square-standard-pullback x)))
 
 abstract
@@ -522,7 +522,7 @@ triangle-map-prod-cone :
   ( gap (map-prod f f') (map-prod g g') (prod-cone f g f' g' c c')) ~
   ( map-prod-cone f g f' g' ∘ map-prod (gap f g c) (gap f' g' c'))
 triangle-map-prod-cone f g c f' g' c' z =
-  eq-pair-Σ-eq-pr2 (eq-pair-Σ-eq-pr2 right-unit)
+  eq-pair-eq-pr2 (eq-pair-eq-pr2 right-unit)
 
 abstract
   is-equiv-map-prod-cone :
@@ -688,8 +688,8 @@ module _
     ( gap f g c ∘ map-equiv-total-fiber (pr1 c)) ~
     ( tot (λ a → tot (λ b → inv)) ∘ tot (map-fiber-cone f g c))
   square-tot-map-fiber-cone (.(vertical-map-cone f g c x) , x , refl) =
-    eq-pair-Σ-eq-pr2
-      ( eq-pair-Σ-eq-pr2
+    eq-pair-eq-pr2
+      ( eq-pair-eq-pr2
         ( inv (ap inv right-unit ∙ inv-inv (coherence-square-cone f g c x))))
 
   abstract
diff --git a/src/foundation-core/truncated-types.lagda.md b/src/foundation-core/truncated-types.lagda.md
index bb510df533..942900bcbe 100644
--- a/src/foundation-core/truncated-types.lagda.md
+++ b/src/foundation-core/truncated-types.lagda.md
@@ -159,7 +159,7 @@ abstract
     is-trunc-is-equiv' k A f is-equiv-f
 ```
 
-### If a type embeds into a `k+1`-truncated type, then it is (k+1)-truncated
+### If a type embeds into a `k+1`-truncated type, then it is `k+1`-truncated
 
 ```agda
 abstract
diff --git a/src/foundation-core/truncation-levels.lagda.md b/src/foundation-core/truncation-levels.lagda.md
index 00874df41c..ef346ace6e 100644
--- a/src/foundation-core/truncation-levels.lagda.md
+++ b/src/foundation-core/truncation-levels.lagda.md
@@ -14,16 +14,24 @@ open import foundation.universe-levels
 
 ## Idea
 
-The type of truncation levels is a type similar to the type of natural numbers,
-but starting the count at -2, so that sets have truncation level 0.
+The type of **truncation levels** is a type similar to the type of
+[natural numbers](elementary-number-theory.natural-numbers.md), but starting the
+count at -2, so that [sets](foundation-core.sets.md) have
+[truncation](foundation-core.truncated-types.md) level 0.
 
-## Definition
+## Definitions
+
+### The type of truncation levels
 
 ```agda
 data 𝕋 : UU lzero where
   neg-two-𝕋 : 𝕋
   succ-𝕋 : 𝕋 → 𝕋
+```
 
+### Aliases for common truncation levels
+
+```agda
 neg-one-𝕋 : 𝕋
 neg-one-𝕋 = succ-𝕋 neg-two-𝕋
 
diff --git a/src/foundation.lagda.md b/src/foundation.lagda.md
index 3568a211d2..33279e54bb 100644
--- a/src/foundation.lagda.md
+++ b/src/foundation.lagda.md
@@ -46,6 +46,7 @@ open import foundation.commuting-3-simplices-of-homotopies public
 open import foundation.commuting-3-simplices-of-maps public
 open import foundation.commuting-cubes-of-maps public
 open import foundation.commuting-hexagons-of-identifications public
+open import foundation.commuting-pentagons-of-identifications public
 open import foundation.commuting-squares-of-homotopies public
 open import foundation.commuting-squares-of-identifications public
 open import foundation.commuting-squares-of-maps public
diff --git a/src/foundation/1-types.lagda.md b/src/foundation/1-types.lagda.md
index db5068c076..bba84b193b 100644
--- a/src/foundation/1-types.lagda.md
+++ b/src/foundation/1-types.lagda.md
@@ -11,15 +11,15 @@ open import foundation-core.1-types public
 ```agda
 open import foundation.dependent-pair-types
 open import foundation.subuniverses
+open import foundation.truncated-types
 open import foundation.universe-levels
 
-open import foundation-core.contractible-types
+open import foundation-core.cartesian-product-types
 open import foundation-core.equivalences
 open import foundation-core.identity-types
 open import foundation-core.propositions
 open import foundation-core.subtypes
 open import foundation-core.torsorial-type-families
-open import foundation-core.truncated-types
 open import foundation-core.truncation-levels
 ```
 
@@ -35,8 +35,17 @@ abstract
 
 is-1-type-Prop :
   {l : Level} → UU l → Prop l
-pr1 (is-1-type-Prop A) = is-1-type A
-pr2 (is-1-type-Prop A) = is-prop-is-1-type A
+is-1-type-Prop = is-trunc-Prop one-𝕋
+```
+
+### The type of all 1-types in a universe is a 2-type
+
+```agda
+is-trunc-1-Type : {l : Level} → is-trunc two-𝕋 (1-Type l)
+is-trunc-1-Type = is-trunc-Truncated-Type one-𝕋
+
+1-Type-Truncated-Type : (l : Level) → Truncated-Type (lsuc l) two-𝕋
+1-Type-Truncated-Type l = Truncated-Type-Truncated-Type l one-𝕋
 ```
 
 ### Products of families of 1-types are 1-types
@@ -66,19 +75,17 @@ pr2 (Π-1-Type' A B) = is-1-type-type-Π-1-Type' A B
 type-Π-1-Type :
   {l1 l2 : Level} (A : 1-Type l1) (B : type-1-Type A → 1-Type l2) →
   UU (l1 ⊔ l2)
-type-Π-1-Type A B = type-Π-1-Type' (type-1-Type A) B
+type-Π-1-Type A = type-Π-1-Type' (type-1-Type A)
 
 is-1-type-type-Π-1-Type :
   {l1 l2 : Level} (A : 1-Type l1) (B : type-1-Type A → 1-Type l2) →
   is-1-type (type-Π-1-Type A B)
-is-1-type-type-Π-1-Type A B =
-  is-1-type-type-Π-1-Type' (type-1-Type A) B
+is-1-type-type-Π-1-Type A = is-1-type-type-Π-1-Type' (type-1-Type A)
 
 Π-1-Type :
   {l1 l2 : Level} (A : 1-Type l1) (B : type-1-Type A → 1-Type l2) →
   1-Type (l1 ⊔ l2)
-pr1 (Π-1-Type A B) = type-Π-1-Type A B
-pr2 (Π-1-Type A B) = is-1-type-type-Π-1-Type A B
+Π-1-Type = Π-Truncated-Type one-𝕋
 ```
 
 ### The type of functions into a 1-type is a 1-type
@@ -102,8 +109,35 @@ is-1-type-type-hom-1-Type A B =
 
 hom-1-Type :
   {l1 l2 : Level} (A : 1-Type l1) (B : 1-Type l2) → 1-Type (l1 ⊔ l2)
-pr1 (hom-1-Type A B) = type-hom-1-Type A B
-pr2 (hom-1-Type A B) = is-1-type-type-hom-1-Type A B
+hom-1-Type = hom-Truncated-Type one-𝕋
+```
+
+### 1-Types are closed under dependent pair types
+
+```agda
+abstract
+  is-1-type-Σ :
+    {l1 l2 : Level} {A : UU l1} {B : A → UU l2} →
+    is-1-type A → ((x : A) → is-1-type (B x)) → is-1-type (Σ A B)
+  is-1-type-Σ = is-trunc-Σ {k = one-𝕋}
+
+Σ-1-Type :
+  {l1 l2 : Level} (A : 1-Type l1) (B : pr1 A → 1-Type l2) → 1-Type (l1 ⊔ l2)
+Σ-1-Type = Σ-Truncated-Type
+```
+
+### 1-Types are closed under cartesian product types
+
+```agda
+abstract
+  is-1-type-prod :
+    {l1 l2 : Level} {A : UU l1} {B : UU l2} →
+    is-1-type A → is-1-type B → is-1-type (A × B)
+  is-1-type-prod = is-trunc-prod one-𝕋
+
+prod-1-Type :
+  {l1 l2 : Level} (A : 1-Type l1) (B : 1-Type l2) → 1-Type (l1 ⊔ l2)
+prod-1-Type A B = Σ-1-Type A (λ x → B)
 ```
 
 ### Subtypes of 1-types are 1-types
diff --git a/src/foundation/binary-relations.lagda.md b/src/foundation/binary-relations.lagda.md
index a8d57fb25c..e798315750 100644
--- a/src/foundation/binary-relations.lagda.md
+++ b/src/foundation/binary-relations.lagda.md
@@ -17,7 +17,6 @@ open import foundation.univalence
 open import foundation.universe-levels
 
 open import foundation-core.cartesian-product-types
-open import foundation-core.contractible-types
 open import foundation-core.equivalences
 open import foundation-core.identity-types
 open import foundation-core.torsorial-type-families
@@ -111,7 +110,7 @@ module _
 
   is-prop-is-transitive-Relation-Prop : is-prop is-transitive-Relation-Prop
   is-prop-is-transitive-Relation-Prop =
-    is-prop-Π³
+    is-prop-iterated-Π 3
       ( λ x y z →
         is-prop-function-type
           ( is-prop-function-type (is-prop-type-Relation-Prop R x z)))
diff --git a/src/foundation/cantor-schroder-bernstein-escardo.lagda.md b/src/foundation/cantor-schroder-bernstein-escardo.lagda.md
index 1e526d26bd..4419efd46b 100644
--- a/src/foundation/cantor-schroder-bernstein-escardo.lagda.md
+++ b/src/foundation/cantor-schroder-bernstein-escardo.lagda.md
@@ -175,6 +175,6 @@ module _
 
 - Martín H. Escardó, _The Cantor–Schröder–Bernstein Theorem for ∞-groupoids_,
   Journal of Homotopy and Related Structures, Volume 16, Issue 3, 2021
-  ([arXiv:2002.07079](https://arxiv.org/abs/2002.07079),[DOI:10.1007](https://doi.org/10.1007/s40062-021-00284-6))
+  ([arXiv:2002.07079](https://arxiv.org/abs/2002.07079),[DOI:10.1007/S40062-021-00284-6](https://doi.org/10.1007/s40062-021-00284-6))
   - <https://www.cs.bham.ac.uk/~mhe/TypeTopology/CantorSchroederBernstein.md>
   - <https://github.com/martinescardo/TypeTopology>
diff --git a/src/foundation/category-of-sets.lagda.md b/src/foundation/category-of-sets.lagda.md
index e8ee374ea4..efeaa27838 100644
--- a/src/foundation/category-of-sets.lagda.md
+++ b/src/foundation/category-of-sets.lagda.md
@@ -29,8 +29,10 @@ open import foundation-core.identity-types
 
 ## Idea
 
-The **category of sets** consists of sets and functions. There is a category of
-sets for each universe level, and there is a large category of sets.
+The **category of [sets](foundation-core.sets.md)** consists of sets and
+functions. There is a [category](category-theory.categories.md) of sets for each
+universe level, and there is a
+[large category](category-theory.large-categories.md) of sets.
 
 ## Definitions
 
@@ -96,3 +98,19 @@ is-category-Set-Precategory :
 is-category-Set-Precategory l =
   is-category-Category (Set-Category l)
 ```
+
+## Comments
+
+Since sets are equivalent to their set-truncations, the category of sets forms a
+[full subprecategory](category-theory.full-large-subprecategories.md) of the
+homotopy precategory of types.
+
+## See also
+
+- [Presheaf categories](category-theory.presheaf-categories.md)
+
+## External links
+
+- [Set](https://ncatlab.org/nlab/show/Set) at nlab
+- [Category of sets](https://en.wikipedia.org/wiki/Category_of_sets) at
+  Wikipedia
diff --git a/src/foundation/commuting-cubes-of-maps.lagda.md b/src/foundation/commuting-cubes-of-maps.lagda.md
index 8f3fc76293..909c12b017 100644
--- a/src/foundation/commuting-cubes-of-maps.lagda.md
+++ b/src/foundation/commuting-cubes-of-maps.lagda.md
@@ -35,7 +35,7 @@ that the cube is presented as a lattice
         /   |   \
        B'   A    C'
        |\ /   \ /|
-       | \     ‌/ |
+       | \     / |
        |/ \   / \|
        B    D'   C'
         \   |   /
diff --git a/src/foundation/commuting-pentagons-of-identifications.lagda.md b/src/foundation/commuting-pentagons-of-identifications.lagda.md
new file mode 100644
index 0000000000..eaf01a0440
--- /dev/null
+++ b/src/foundation/commuting-pentagons-of-identifications.lagda.md
@@ -0,0 +1,54 @@
+# Commuting pentagons of identifications
+
+```agda
+module foundation.commuting-pentagons-of-identifications where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import foundation.universe-levels
+
+open import foundation-core.identity-types
+```
+
+</details>
+
+## Idea
+
+A pentagon of [identifications](foundation-core.identity-types.md)
+
+```text
+             top
+           x --- y
+top-left  /       \ top-right
+         /         \
+        z           w
+          \       /
+bottom-left \   / bottom-right
+              v
+```
+
+is said to **commute** if there is an identification
+
+```text
+  top-left ∙ bottom-left ＝ (top ∙ top-right) ∙ bottom-right.
+```
+
+Such an identification is called a **coherence** of the pentagon.
+
+## Definition
+
+```agda
+module _
+  {l : Level} {A : UU l} {x y z w v : A}
+  where
+
+  coherence-pentagon-identifications :
+    (top : x ＝ y)
+    (top-left : x ＝ z) (top-right : y ＝ w)
+    (bottom-left : z ＝ v) (bottom-right : w ＝ v) → UU l
+  coherence-pentagon-identifications
+    top top-left top-right bottom-left bottom-right =
+    top-left ∙ bottom-left ＝ (top ∙ top-right) ∙ bottom-right
+```
diff --git a/src/foundation/decidable-embeddings.lagda.md b/src/foundation/decidable-embeddings.lagda.md
index d13990b6db..2607d8a258 100644
--- a/src/foundation/decidable-embeddings.lagda.md
+++ b/src/foundation/decidable-embeddings.lagda.md
@@ -222,7 +222,7 @@ abstract
     is-prop-is-inhabited
       ( λ H →
         is-prop-prod
-          ( is-prop-is-emb f)
+          ( is-property-is-emb f)
           ( is-prop-Π
             ( λ y → is-prop-is-decidable (is-prop-map-is-emb (pr1 H) y))))
 ```
diff --git a/src/foundation/decidable-equality.lagda.md b/src/foundation/decidable-equality.lagda.md
index c61914611a..aba53c004a 100644
--- a/src/foundation/decidable-equality.lagda.md
+++ b/src/foundation/decidable-equality.lagda.md
@@ -35,8 +35,8 @@ open import foundation-core.transport-along-identifications
 
 ## Definition
 
-A type `A` is said to have decidable equality if `Id x y` is a decidable type
-for every `x y : A`.
+A type `A` is said to have **decidable equality** if `x ＝ y` is a
+[decidable type](foundation.decidable-types.md) for every `x y : A`.
 
 ```agda
 has-decidable-equality : {l : Level} (A : UU l) → UU l
@@ -274,7 +274,7 @@ abstract
             ( is-set-has-decidable-equality dA (pr1 t) x)))
 ```
 
-### If B is a family of types with decidable equality, the total space has decidable equality, and B has a section, then the base type has decidable equality
+### If `B` is a family of types with decidable equality, the total space has decidable equality, and `B` has a section, then the base type has decidable equality
 
 ```agda
 abstract
diff --git a/src/foundation/double-negation-modality.lagda.md b/src/foundation/double-negation-modality.lagda.md
index c62d92e0b0..2bd03a7af5 100644
--- a/src/foundation/double-negation-modality.lagda.md
+++ b/src/foundation/double-negation-modality.lagda.md
@@ -69,4 +69,4 @@ This proof follows Example 1.9 in _Modalities in homotopy type theory_.
 - Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
   theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
   ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-  [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+  [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
diff --git a/src/foundation/embeddings.lagda.md b/src/foundation/embeddings.lagda.md
index 5ee493c330..ca25414087 100644
--- a/src/foundation/embeddings.lagda.md
+++ b/src/foundation/embeddings.lagda.md
@@ -44,13 +44,13 @@ module _
   {l1 l2 : Level} {A : UU l1} {B : UU l2}
   where
 
-  is-prop-is-emb : (f : A → B) → is-prop (is-emb f)
-  is-prop-is-emb f =
+  is-property-is-emb : (f : A → B) → is-prop (is-emb f)
+  is-property-is-emb f =
     is-prop-Π (λ x → is-prop-Π (λ y → is-property-is-equiv (ap f)))
 
   is-emb-Prop : (A → B) → Prop (l1 ⊔ l2)
   pr1 (is-emb-Prop f) = is-emb f
-  pr2 (is-emb-Prop f) = is-prop-is-emb f
+  pr2 (is-emb-Prop f) = is-property-is-emb f
 ```
 
 ### Embeddings are closed under homotopies
diff --git a/src/foundation/equality-dependent-function-types.lagda.md b/src/foundation/equality-dependent-function-types.lagda.md
index 963b0063ed..bd8b9c4386 100644
--- a/src/foundation/equality-dependent-function-types.lagda.md
+++ b/src/foundation/equality-dependent-function-types.lagda.md
@@ -15,7 +15,6 @@ open import foundation.universe-levels
 
 open import foundation-core.contractible-types
 open import foundation-core.equivalences
-open import foundation-core.functoriality-dependent-function-types
 open import foundation-core.functoriality-dependent-pair-types
 open import foundation-core.identity-types
 open import foundation-core.torsorial-type-families
diff --git a/src/foundation/functoriality-fibers-of-maps.lagda.md b/src/foundation/functoriality-fibers-of-maps.lagda.md
index 96c0770060..48b82c08ac 100644
--- a/src/foundation/functoriality-fibers-of-maps.lagda.md
+++ b/src/foundation/functoriality-fibers-of-maps.lagda.md
@@ -65,7 +65,7 @@ module _
     ( map-fiber-cone j h c (i x) ∘ map-fiber-cone i (pr1 c) d x)
   map-fiber-pasting-horizontal-cone
     (g , q , K) (f , p , H) .(f a) (a , refl) =
-    eq-pair-Σ-eq-pr2
+    eq-pair-eq-pr2
       ( ( ap
           ( concat' (h (q (p a))) refl)
           ( distributive-inv-concat (ap j (H a)) (K (p a)))) ∙
@@ -97,7 +97,7 @@ module _
   map-fiber-pasting-vertical-cone
     (p , q , H) (p' , q' , H') .(p (p' a))
     ((.(p' a) , refl) , (a , refl)) =
-    eq-pair-Σ-eq-pr2
+    eq-pair-eq-pr2
       ( ( right-unit) ∙
         ( distributive-inv-concat (H (p' a)) (ap g (H' a))) ∙
         ( ap
diff --git a/src/foundation/identity-types.lagda.md b/src/foundation/identity-types.lagda.md
index 2d48de1898..b15cec9771 100644
--- a/src/foundation/identity-types.lagda.md
+++ b/src/foundation/identity-types.lagda.md
@@ -11,6 +11,7 @@ open import foundation-core.identity-types public
 ```agda
 open import foundation.action-on-identifications-functions
 open import foundation.binary-equivalences
+open import foundation.commuting-pentagons-of-identifications
 open import foundation.dependent-pair-types
 open import foundation.equivalence-extensionality
 open import foundation.function-extensionality
@@ -44,17 +45,17 @@ identifications in arbitrary types.
 ### The Mac Lane pentagon for identity types
 
 ```agda
-Mac-Lane-pentagon :
+mac-lane-pentagon :
   {l : Level} {A : UU l} {a b c d e : A}
   (p : a ＝ b) (q : b ＝ c) (r : c ＝ d) (s : d ＝ e) →
-  let α₁ = (ap (λ t → t ∙ s) (assoc p q r))
+  let α₁ = (ap (_∙ s) (assoc p q r))
       α₂ = (assoc p (q ∙ r) s)
-      α₃ = (ap (λ t → p ∙ t) (assoc q r s))
+      α₃ = (ap (p ∙_) (assoc q r s))
       α₄ = (assoc (p ∙ q) r s)
       α₅ = (assoc p q (r ∙ s))
   in
-  ((α₁ ∙ α₂) ∙ α₃) ＝ (α₄ ∙ α₅)
-Mac-Lane-pentagon refl refl refl refl = refl
+    coherence-pentagon-identifications α₁ α₄ α₂ α₅ α₃
+mac-lane-pentagon refl refl refl refl = refl
 ```
 
 ### The groupoidal operations on identity types are equivalences
diff --git a/src/foundation/locally-small-types.lagda.md b/src/foundation/locally-small-types.lagda.md
index f16321383d..a4835728c8 100644
--- a/src/foundation/locally-small-types.lagda.md
+++ b/src/foundation/locally-small-types.lagda.md
@@ -244,8 +244,7 @@ is-locally-small-inhabited-subtype H =
 ## References
 
 - Egbert Rijke, Theorem 4.6 in _The join construction_, 2017
-  ([arXiv:1701.07538](https://arxiv.org/abs/1701.07538),
-  [DOI:10.48550](https://doi.org/10.48550/arXiv.1701.07538))
+  ([arXiv:1701.07538](https://arxiv.org/abs/1701.07538))
 - Marc Bezem, Ulrik Buchholtz, Pierre Cagne, Bjørn Ian Dundas, and Daniel R.
   Grayson, Section 2.19 of _Symmetry_
   ([draft](https://unimath.github.io/SymmetryBook/book.pdf),
diff --git a/src/foundation/multivariable-homotopies.lagda.md b/src/foundation/multivariable-homotopies.lagda.md
index 780ebd4274..a5aaf2529f 100644
--- a/src/foundation/multivariable-homotopies.lagda.md
+++ b/src/foundation/multivariable-homotopies.lagda.md
@@ -11,11 +11,11 @@ open import foundation.telescopes public
 ```agda
 open import elementary-number-theory.natural-numbers
 
+open import foundation.equivalences
 open import foundation.function-extensionality
 open import foundation.iterated-dependent-product-types
 open import foundation.universe-levels
 
-open import foundation-core.equivalences
 open import foundation-core.functoriality-dependent-function-types
 open import foundation-core.identity-types
 ```
diff --git a/src/foundation/path-split-maps.lagda.md b/src/foundation/path-split-maps.lagda.md
index 9397e307b2..2d2df1f55e 100644
--- a/src/foundation/path-split-maps.lagda.md
+++ b/src/foundation/path-split-maps.lagda.md
@@ -84,8 +84,7 @@ module _
 
 1. Univalent Foundations Project, _Homotopy Type Theory – Univalent Foundations
    of Mathematics_ (2013) ([website](https://homotopytypetheory.org/book/),
-   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729),
-   [DOI:10.48550](https://doi.org/10.48550/arXiv.1308.0729))
+   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729))
 2. Mike Shulman, _Universal properties without function extensionality_
    (November 2014)
    ([HoTT Blog](https://homotopytypetheory.org/2014/11/02/universal-properties-without-function-extensionality/))
diff --git a/src/foundation/preidempotent-maps.lagda.md b/src/foundation/preidempotent-maps.lagda.md
index 8599010dd5..0e3a918a15 100644
--- a/src/foundation/preidempotent-maps.lagda.md
+++ b/src/foundation/preidempotent-maps.lagda.md
@@ -48,7 +48,6 @@ is-prop-is-preidempotent-is-set is-set-A f =
 
 - Mike Shulman, _Idempotents in intensional type theory_, Logical Methods in
   Computer Science, Volume 12, Issue 3, 2017
-  ([arXiv:1507.03634](https://arxiv.org/abs/1507.03634),
-  [DOI:10.48550](https://doi.org/10.48550/arXiv.1507.03634))
+  ([arXiv:1507.03634](https://arxiv.org/abs/1507.03634))
 - Mike Shulman, _Splitting Idempotents_,
   <https://homotopytypetheory.org/2014/12/08/splitting-idempotents/>
diff --git a/src/foundation/propositions.lagda.md b/src/foundation/propositions.lagda.md
index 87c24471d8..563e24e52f 100644
--- a/src/foundation/propositions.lagda.md
+++ b/src/foundation/propositions.lagda.md
@@ -11,6 +11,7 @@ open import foundation-core.propositions public
 ```agda
 open import foundation.contractible-types
 open import foundation.dependent-pair-types
+open import foundation.embeddings
 open import foundation.universe-levels
 
 open import foundation-core.retractions
@@ -45,3 +46,18 @@ module _
   is-prop-retract-of : A retract-of B → is-prop B → is-prop A
   is-prop-retract-of = is-trunc-retract-of
 ```
+
+### If a type embeds into a proposition, then it is a proposition
+
+```agda
+abstract
+  is-prop-is-emb :
+    {l1 l2 : Level} {A : UU l1} {B : UU l2} (f : A → B) →
+    is-emb f → is-prop B → is-prop A
+  is-prop-is-emb = is-trunc-is-emb neg-two-𝕋
+
+abstract
+  is-prop-emb :
+    {l1 l2 : Level} {A : UU l1} {B : UU l2} (f : A ↪ B) → is-prop B → is-prop A
+  is-prop-emb = is-trunc-emb neg-two-𝕋
+```
diff --git a/src/foundation/pullbacks.lagda.md b/src/foundation/pullbacks.lagda.md
index 4be90935f3..679af1bdf8 100644
--- a/src/foundation/pullbacks.lagda.md
+++ b/src/foundation/pullbacks.lagda.md
@@ -99,8 +99,8 @@ triangle-map-standard-pullback-exponent :
       ( exponent-cone T f g c)))
 triangle-map-standard-pullback-exponent
   {A = A} {B} T f g c h =
-  eq-pair-Σ-eq-pr2
-    ( eq-pair-Σ-eq-pr2
+  eq-pair-eq-pr2
+    ( eq-pair-eq-pr2
       ( inv (is-section-eq-htpy (coherence-square-cone f g c ·r h))))
 
 abstract
@@ -186,7 +186,7 @@ cone-Id' :
   cone (const unit (A × A) t) (diagonal A) (pr1 t ＝ pr2 t)
 pr1 (cone-Id' {A = A} (x , y)) = const (x ＝ y) unit star
 pr1 (pr2 (cone-Id' {A = A} (x , y))) = const (x ＝ y) A x
-pr2 (pr2 (cone-Id' {A = A} (x , y))) p = eq-pair-Σ-eq-pr2 (inv p)
+pr2 (pr2 (cone-Id' {A = A} (x , y))) p = eq-pair-eq-pr2 (inv p)
 
 inv-gap-cone-Id' :
   {l : Level} {A : UU l} (t : A × A) →
diff --git a/src/foundation/replacement.lagda.md b/src/foundation/replacement.lagda.md
index 8283b21027..23bf1e829f 100644
--- a/src/foundation/replacement.lagda.md
+++ b/src/foundation/replacement.lagda.md
@@ -57,8 +57,7 @@ replacement' f = replacement f is-small'
 ## References
 
 - Egbert Rijke, Theorem 4.6 in _The join construction_, 2017
-  ([arXiv:1701.07538](https://arxiv.org/abs/1701.07538),
-  [DOI:10.48550](https://doi.org/10.48550/arXiv.1701.07538))
+  ([arXiv:1701.07538](https://arxiv.org/abs/1701.07538))
 - Marc Bezem, Ulrik Buchholtz, Pierre Cagne, Bjørn Ian Dundas, and Daniel R.
   Grayson, Section 2.19 of _Symmetry_
   ([newest version](https://unimath.github.io/SymmetryBook/book.pdf),
diff --git a/src/foundation/sets.lagda.md b/src/foundation/sets.lagda.md
index 27bdece44f..a43ea60edd 100644
--- a/src/foundation/sets.lagda.md
+++ b/src/foundation/sets.lagda.md
@@ -13,6 +13,7 @@ open import foundation.contractible-types
 open import foundation.dependent-pair-types
 open import foundation.subuniverses
 open import foundation.truncated-types
+open import foundation.truncation-levels
 open import foundation.universe-levels
 
 open import foundation-core.1-types
@@ -24,7 +25,6 @@ open import foundation-core.identity-types
 open import foundation-core.propositional-maps
 open import foundation-core.propositions
 open import foundation-core.torsorial-type-families
-open import foundation-core.truncation-levels
 ```
 
 </details>
@@ -241,9 +241,25 @@ abstract
 
 ```agda
 module _
-  {l1 l2 : Level} {A : UU l1} {B : UU l2} where
+  {l1 l2 : Level} {A : UU l1} {B : UU l2}
+  where
 
   is-emb-is-prop-is-set : is-prop A → is-set B → {f : A → B} → is-emb f
   is-emb-is-prop-is-set is-prop-A is-set-B {f} =
     is-emb-is-prop-map (λ b → is-prop-Σ is-prop-A (λ a → is-set-B (f a) b))
 ```
+
+### Sets are `k+2`-truncated for any `k`
+
+```agda
+is-trunc-is-set :
+  {l : Level} (k : 𝕋) {A : UU l} → is-set A → is-trunc (succ-𝕋 (succ-𝕋 k)) A
+is-trunc-is-set neg-two-𝕋 is-set-A = is-set-A
+is-trunc-is-set (succ-𝕋 k) is-set-A =
+  is-trunc-succ-is-trunc (succ-𝕋 (succ-𝕋 k)) (is-trunc-is-set k is-set-A)
+
+set-Truncated-Type :
+  {l : Level} (k : 𝕋) → Set l → Truncated-Type l (succ-𝕋 (succ-𝕋 k))
+pr1 (set-Truncated-Type k A) = type-Set A
+pr2 (set-Truncated-Type k A) = is-trunc-is-set k (is-set-type-Set A)
+```
diff --git a/src/foundation/surjective-maps.lagda.md b/src/foundation/surjective-maps.lagda.md
index e51675cf33..84827e97d5 100644
--- a/src/foundation/surjective-maps.lagda.md
+++ b/src/foundation/surjective-maps.lagda.md
@@ -721,7 +721,7 @@ module _
             ( ap
               ( concat' (g (i a)) (M (f a)))
               ( is-section-map-inv-is-equiv
-                ( K (i a) ((j (f a))))
+                ( K (i a) (j (f a)))
                 ( L a ∙ inv (M (f a))))) ∙
             ( is-section-inv-concat' (g (i a)) (M (f a)) (L a)))))
     where
diff --git a/src/foundation/transport-along-higher-identifications.lagda.md b/src/foundation/transport-along-higher-identifications.lagda.md
index babae89b03..e4d361e0c1 100644
--- a/src/foundation/transport-along-higher-identifications.lagda.md
+++ b/src/foundation/transport-along-higher-identifications.lagda.md
@@ -9,7 +9,6 @@ module foundation.transport-along-higher-identifications where
 ```agda
 open import foundation.action-on-identifications-functions
 open import foundation.commuting-squares-of-identifications
-open import foundation.dependent-pair-types
 open import foundation.homotopies
 open import foundation.identity-types
 open import foundation.path-algebra
diff --git a/src/foundation/transport-along-identifications.lagda.md b/src/foundation/transport-along-identifications.lagda.md
index 12cf640e41..134e8ff91d 100644
--- a/src/foundation/transport-along-identifications.lagda.md
+++ b/src/foundation/transport-along-identifications.lagda.md
@@ -10,17 +10,13 @@ open import foundation-core.transport-along-identifications public
 
 ```agda
 open import foundation.action-on-identifications-functions
-open import foundation.commuting-squares-of-identifications
 open import foundation.dependent-pair-types
 open import foundation.homotopies
-open import foundation.path-algebra
-open import foundation.transport-along-higher-identifications
 open import foundation.universe-levels
 
 open import foundation-core.equivalences
 open import foundation-core.function-types
 open import foundation-core.identity-types
-open import foundation-core.whiskering-homotopies
 ```
 
 </details>
diff --git a/src/foundation/truncated-types.lagda.md b/src/foundation/truncated-types.lagda.md
index 2043af39ba..b9385ca2b3 100644
--- a/src/foundation/truncated-types.lagda.md
+++ b/src/foundation/truncated-types.lagda.md
@@ -9,18 +9,19 @@ open import foundation-core.truncated-types public
 <details><summary>Imports</summary>
 
 ```agda
+open import elementary-number-theory.natural-numbers
+
 open import foundation.dependent-pair-types
 open import foundation.subtype-identity-principle
+open import foundation.truncation-levels
 open import foundation.univalence
 open import foundation.universe-levels
 
-open import foundation-core.contractible-types
 open import foundation-core.embeddings
 open import foundation-core.equivalences
 open import foundation-core.identity-types
 open import foundation-core.subtypes
 open import foundation-core.torsorial-type-families
-open import foundation-core.truncation-levels
 ```
 
 </details>
@@ -72,3 +73,23 @@ pr2 (Truncated-Type-Truncated-Type l k) = is-trunc-Truncated-Type k
 emb-type-Truncated-Type : (l : Level) (k : 𝕋) → Truncated-Type l k ↪ UU l
 emb-type-Truncated-Type l k = emb-subtype (is-trunc-Prop k)
 ```
+
+### If a type is `k`-truncated, then it is `k+r`-truncated
+
+```agda
+abstract
+  is-trunc-iterated-succ-is-trunc :
+    (k : 𝕋) (r : ℕ) {l : Level} {A : UU l} →
+    is-trunc k A → is-trunc (iterated-succ-𝕋' k r) A
+  is-trunc-iterated-succ-is-trunc k zero-ℕ is-trunc-A = is-trunc-A
+  is-trunc-iterated-succ-is-trunc k (succ-ℕ r) is-trunc-A =
+    is-trunc-iterated-succ-is-trunc (succ-𝕋 k) r
+      ( is-trunc-succ-is-trunc k is-trunc-A)
+
+truncated-type-iterated-succ-Truncated-Type :
+  (k : 𝕋) (r : ℕ) {l : Level} →
+  Truncated-Type l k → Truncated-Type l (iterated-succ-𝕋' k r)
+pr1 (truncated-type-iterated-succ-Truncated-Type k r A) = type-Truncated-Type A
+pr2 (truncated-type-iterated-succ-Truncated-Type k r A) =
+  is-trunc-iterated-succ-is-trunc k r (is-trunc-type-Truncated-Type A)
+```
diff --git a/src/foundation/truncation-levels.lagda.md b/src/foundation/truncation-levels.lagda.md
index d2421c55b4..9b45dff830 100644
--- a/src/foundation/truncation-levels.lagda.md
+++ b/src/foundation/truncation-levels.lagda.md
@@ -36,6 +36,14 @@ truncation-level-ℕ : ℕ → 𝕋
 truncation-level-ℕ = succ-𝕋 ∘ truncation-level-minus-one-ℕ
 ```
 
+### The inclusion of double successors of truncation levels into the natural numbers
+
+```agda
+nat-succ-succ-𝕋 : 𝕋 → ℕ
+nat-succ-succ-𝕋 neg-two-𝕋 = zero-ℕ
+nat-succ-succ-𝕋 (succ-𝕋 k) = succ-ℕ (nat-succ-succ-𝕋 k)
+```
+
 ### Addition of truncation levels
 
 ```agda
@@ -52,6 +60,21 @@ infixl 35 _+𝕋_
 _+𝕋_ = add-𝕋
 ```
 
+### Iterated successor functions on truncation levels
+
+Although we can define an addition operation on truncation levels, when it comes
+to doing induction on them, it is more natural to speak in terms of an iterated
+successor:
+
+```agda
+iterated-succ-𝕋 : ℕ → 𝕋 → 𝕋
+iterated-succ-𝕋 zero-ℕ x = x
+iterated-succ-𝕋 (succ-ℕ n) x = iterated-succ-𝕋 n (succ-𝕋 x)
+
+iterated-succ-𝕋' : 𝕋 → ℕ → 𝕋
+iterated-succ-𝕋' x n = iterated-succ-𝕋 n x
+```
+
 ## Properties
 
 ### Unit laws for addition of truncation levels
diff --git a/src/foundation/type-arithmetic-dependent-pair-types.lagda.md b/src/foundation/type-arithmetic-dependent-pair-types.lagda.md
index c3b789a3cc..4e4bbb8561 100644
--- a/src/foundation/type-arithmetic-dependent-pair-types.lagda.md
+++ b/src/foundation/type-arithmetic-dependent-pair-types.lagda.md
@@ -41,24 +41,22 @@ module _
   where
 
   map-inv-left-unit-law-Σ-is-contr : B a → Σ A B
-  map-inv-left-unit-law-Σ-is-contr b = pair a b
+  pr1 (map-inv-left-unit-law-Σ-is-contr b) = a
+  pr2 (map-inv-left-unit-law-Σ-is-contr b) = b
 
   map-left-unit-law-Σ-is-contr : Σ A B → B a
   map-left-unit-law-Σ-is-contr =
-    ind-Σ
-      ( ind-singleton a C
-        ( λ x → B x → B a)
-        ( id))
+    ind-Σ (ind-singleton a C (λ x → B x → B a) (id))
 
   is-section-map-inv-left-unit-law-Σ-is-contr :
-    ( map-left-unit-law-Σ-is-contr ∘ map-inv-left-unit-law-Σ-is-contr) ~ id
+    map-left-unit-law-Σ-is-contr ∘ map-inv-left-unit-law-Σ-is-contr ~ id
   is-section-map-inv-left-unit-law-Σ-is-contr b =
     ap
       ( λ (f : B a → B a) → f b)
       ( compute-ind-singleton a C (λ x → B x → B a) id)
 
   is-retraction-map-inv-left-unit-law-Σ-is-contr :
-    ( map-inv-left-unit-law-Σ-is-contr ∘ map-left-unit-law-Σ-is-contr) ~ id
+    map-inv-left-unit-law-Σ-is-contr ∘ map-left-unit-law-Σ-is-contr ~ id
   is-retraction-map-inv-left-unit-law-Σ-is-contr =
     ind-Σ
       ( ind-singleton a C
@@ -67,8 +65,8 @@ module _
             Id
               ( ( map-inv-left-unit-law-Σ-is-contr ∘
                   map-left-unit-law-Σ-is-contr)
-                ( pair x y))
-              ( pair x y))
+                ( x , y))
+              ( x , y))
         ( λ y → ap
           ( map-inv-left-unit-law-Σ-is-contr)
           ( ap
@@ -138,12 +136,12 @@ module _
 
   is-section-map-inv-right-unit-law-Σ-is-contr :
     (H : (a : A) → is-contr (B a)) →
-    ( pr1 ∘ map-inv-right-unit-law-Σ-is-contr H) ~ id
+    pr1 ∘ map-inv-right-unit-law-Σ-is-contr H ~ id
   is-section-map-inv-right-unit-law-Σ-is-contr H = refl-htpy
 
   is-retraction-map-inv-right-unit-law-Σ-is-contr :
     (H : (a : A) → is-contr (B a)) →
-    ( map-inv-right-unit-law-Σ-is-contr H ∘ pr1) ~ id
+    map-inv-right-unit-law-Σ-is-contr H ∘ pr1 ~ id
   is-retraction-map-inv-right-unit-law-Σ-is-contr H (a , b) =
     eq-pair-Σ refl (eq-is-contr (H a))
 
@@ -173,23 +171,23 @@ module _
   {l1 l2 l3 : Level} (A : UU l1) (B : A → UU l2) (C : Σ A B → UU l3)
   where
 
-  map-associative-Σ : Σ (Σ A B) C → Σ A (λ x → Σ (B x) (λ y → C (pair x y)))
+  map-associative-Σ : Σ (Σ A B) C → Σ A (λ x → Σ (B x) (λ y → C (x , y)))
   pr1 (map-associative-Σ ((x , y) , z)) = x
   pr1 (pr2 (map-associative-Σ ((x , y) , z))) = y
   pr2 (pr2 (map-associative-Σ ((x , y) , z))) = z
 
-  map-inv-associative-Σ : Σ A (λ x → Σ (B x) (λ y → C (pair x y))) → Σ (Σ A B) C
+  map-inv-associative-Σ : Σ A (λ x → Σ (B x) (λ y → C (x , y))) → Σ (Σ A B) C
   pr1 (pr1 (map-inv-associative-Σ (x , y , z))) = x
   pr2 (pr1 (map-inv-associative-Σ (x , y , z))) = y
   pr2 (map-inv-associative-Σ (x , y , z)) = z
 
   is-retraction-map-inv-associative-Σ :
-    (map-inv-associative-Σ ∘ map-associative-Σ) ~ id
-  is-retraction-map-inv-associative-Σ (pair (pair x y) z) = refl
+    map-inv-associative-Σ ∘ map-associative-Σ ~ id
+  is-retraction-map-inv-associative-Σ ((x , y) , z) = refl
 
   is-section-map-inv-associative-Σ :
-    (map-associative-Σ ∘ map-inv-associative-Σ) ~ id
-  is-section-map-inv-associative-Σ (pair x (pair y z)) = refl
+    map-associative-Σ ∘ map-inv-associative-Σ ~ id
+  is-section-map-inv-associative-Σ (x , (y , z)) = refl
 
   abstract
     is-equiv-map-associative-Σ : is-equiv map-associative-Σ
@@ -199,11 +197,11 @@ module _
         is-section-map-inv-associative-Σ
         is-retraction-map-inv-associative-Σ
 
-  associative-Σ : Σ (Σ A B) C ≃ Σ A (λ x → Σ (B x) (λ y → C (pair x y)))
+  associative-Σ : Σ (Σ A B) C ≃ Σ A (λ x → Σ (B x) (λ y → C (x , y)))
   pr1 associative-Σ = map-associative-Σ
   pr2 associative-Σ = is-equiv-map-associative-Σ
 
-  inv-associative-Σ : Σ A (λ x → Σ (B x) (λ y → C (pair x y))) ≃ Σ (Σ A B) C
+  inv-associative-Σ : Σ A (λ x → Σ (B x) (λ y → C (x , y))) ≃ Σ (Σ A B) C
   pr1 inv-associative-Σ = map-inv-associative-Σ
   pr2 inv-associative-Σ =
     is-equiv-is-invertible
@@ -232,12 +230,12 @@ module _
   pr2 (map-inv-associative-Σ' (x , y , z)) = z
 
   is-section-map-inv-associative-Σ' :
-    (map-associative-Σ' ∘ map-inv-associative-Σ') ~ id
-  is-section-map-inv-associative-Σ' (pair x (pair y z)) = refl
+    map-associative-Σ' ∘ map-inv-associative-Σ' ~ id
+  is-section-map-inv-associative-Σ' (x , (y , z)) = refl
 
   is-retraction-map-inv-associative-Σ' :
-    ( map-inv-associative-Σ' ∘ map-associative-Σ') ~ id
-  is-retraction-map-inv-associative-Σ' (pair (pair x y) z) = refl
+    map-inv-associative-Σ' ∘ map-associative-Σ' ~ id
+  is-retraction-map-inv-associative-Σ' ((x , y) , z) = refl
 
   is-equiv-map-associative-Σ' : is-equiv map-associative-Σ'
   is-equiv-map-associative-Σ' =
@@ -265,7 +263,7 @@ module _
 
 ```agda
 module _
-  { l1 l2 l3 l4 : Level} { A : UU l1} {B : A → UU l2} {C : A → UU l3}
+  { l1 l2 l3 l4 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
   ( D : (x : A) → B x → C x → UU l4)
   where
 
@@ -286,12 +284,12 @@ module _
   pr2 (pr2 (map-inv-interchange-Σ-Σ t)) = pr2 (pr2 t)
 
   is-section-map-inv-interchange-Σ-Σ :
-    ( map-interchange-Σ-Σ ∘ map-inv-interchange-Σ-Σ) ~ id
-  is-section-map-inv-interchange-Σ-Σ (pair (pair a c) (pair b d)) = refl
+    map-interchange-Σ-Σ ∘ map-inv-interchange-Σ-Σ ~ id
+  is-section-map-inv-interchange-Σ-Σ ((a , c) , (b , d)) = refl
 
   is-retraction-map-inv-interchange-Σ-Σ :
-    ( map-inv-interchange-Σ-Σ ∘ map-interchange-Σ-Σ) ~ id
-  is-retraction-map-inv-interchange-Σ-Σ (pair (pair a b) (pair c d)) = refl
+    map-inv-interchange-Σ-Σ ∘ map-interchange-Σ-Σ ~ id
+  is-retraction-map-inv-interchange-Σ-Σ ((a , b) , (c , d)) = refl
 
   abstract
     is-equiv-map-interchange-Σ-Σ : is-equiv map-interchange-Σ-Σ
@@ -335,11 +333,11 @@ module _
   pr2 (pr2 (map-inv-left-swap-Σ (b , a , c))) = c
 
   is-retraction-map-inv-left-swap-Σ :
-    (map-inv-left-swap-Σ ∘ map-left-swap-Σ) ~ id
-  is-retraction-map-inv-left-swap-Σ (pair a (pair b c)) = refl
+    map-inv-left-swap-Σ ∘ map-left-swap-Σ ~ id
+  is-retraction-map-inv-left-swap-Σ (a , (b , c)) = refl
 
-  is-section-map-inv-left-swap-Σ : (map-left-swap-Σ ∘ map-inv-left-swap-Σ) ~ id
-  is-section-map-inv-left-swap-Σ (pair b (pair a c)) = refl
+  is-section-map-inv-left-swap-Σ : map-left-swap-Σ ∘ map-inv-left-swap-Σ ~ id
+  is-section-map-inv-left-swap-Σ (b , (a , c)) = refl
 
   abstract
     is-equiv-map-left-swap-Σ : is-equiv map-left-swap-Σ
@@ -372,12 +370,12 @@ module _
   pr2 (map-inv-right-swap-Σ ((a , c) , b)) = c
 
   is-section-map-inv-right-swap-Σ :
-    (map-right-swap-Σ ∘ map-inv-right-swap-Σ) ~ id
-  is-section-map-inv-right-swap-Σ (pair (pair x y) z) = refl
+    map-right-swap-Σ ∘ map-inv-right-swap-Σ ~ id
+  is-section-map-inv-right-swap-Σ ((x , y) , z) = refl
 
   is-retraction-map-inv-right-swap-Σ :
-    (map-inv-right-swap-Σ ∘ map-right-swap-Σ) ~ id
-  is-retraction-map-inv-right-swap-Σ (pair (pair x z) y) = refl
+    map-inv-right-swap-Σ ∘ map-right-swap-Σ ~ id
+  is-retraction-map-inv-right-swap-Σ ((x , z) , y) = refl
 
   is-equiv-map-right-swap-Σ : is-equiv map-right-swap-Σ
   is-equiv-map-right-swap-Σ =
diff --git a/src/group-theory/automorphism-groups.lagda.md b/src/group-theory/automorphism-groups.lagda.md
index 6c7cc48feb..66a609eded 100644
--- a/src/group-theory/automorphism-groups.lagda.md
+++ b/src/group-theory/automorphism-groups.lagda.md
@@ -33,7 +33,8 @@ open import structured-types.pointed-types
 
 ## Idea
 
-The automorphim group of `a : A` is the group of symmetries of `a` in `A`.
+The **automorphim group** of `a : A` is the [group](group-theory.groups.md) of
+symmetries of `a` in `A`.
 
 ## Definitions
 
diff --git a/src/group-theory/concrete-monoids.lagda.md b/src/group-theory/concrete-monoids.lagda.md
index e8c280734b..702c2b25d3 100644
--- a/src/group-theory/concrete-monoids.lagda.md
+++ b/src/group-theory/concrete-monoids.lagda.md
@@ -58,7 +58,7 @@ Given a monoid, we can define its associated concrete monoid. The type of
 objects is the [classifying type](group-theory.concrete-groups.md) of the
 [core](group-theory.cores-monoids.md) of the monoid. Moreover, we must take care
 in how we define the family of homomorphisms. They cannot simply be the constant
-family, as [transporting](foundation.transport-along-identifications.md) along
+family, as [transporting along](foundation.transport-along-identifications.md)
 an [invertible element](group-theory.invertible-elements-monoids.md) should
 correspond to multiplying by the element in the family.
 
diff --git a/src/group-theory/torsors.lagda.md b/src/group-theory/torsors.lagda.md
index 0a00390f75..5516169b25 100644
--- a/src/group-theory/torsors.lagda.md
+++ b/src/group-theory/torsors.lagda.md
@@ -9,7 +9,6 @@ module group-theory.torsors where
 ```agda
 open import foundation.0-connected-types
 open import foundation.action-on-identifications-functions
-open import foundation.contractible-types
 open import foundation.dependent-pair-types
 open import foundation.equivalences
 open import foundation.function-types
@@ -42,8 +41,9 @@ open import higher-group-theory.higher-groups
 
 ## Idea
 
-A torsor of `G` is a group action wich merely equivalent to the principal group
-action of `G`.
+A **torsor** of `G` is a [group action](group-theory.group-actions.md) which is
+[merely equivalent](foundation.mere-equivalences.md) to the
+[principal group action](group-theory.principal-group-actions.md) of `G`.
 
 ## Definitions
 
diff --git a/src/order-theory/large-posets.lagda.md b/src/order-theory/large-posets.lagda.md
index ccd905d046..fd55dfa299 100644
--- a/src/order-theory/large-posets.lagda.md
+++ b/src/order-theory/large-posets.lagda.md
@@ -174,7 +174,7 @@ module _
   is-large-category-Large-Poset {l} x y =
     is-equiv-is-prop
       ( is-set-type-Large-Poset P x y)
-      ( is-prop-iso-Precategory
+      ( is-prop-iso-is-prop-hom-Precategory
         ( precategory-Large-Poset l)
         ( is-prop-leq-Large-Poset P x y))
       ( λ f →
diff --git a/src/order-theory/posets.lagda.md b/src/order-theory/posets.lagda.md
index 1a3c6eb992..8b9ee2314c 100644
--- a/src/order-theory/posets.lagda.md
+++ b/src/order-theory/posets.lagda.md
@@ -157,7 +157,8 @@ module _
   is-category-precategory-Poset x y =
     is-equiv-is-prop
       ( is-set-type-Poset X x y)
-      ( is-prop-iso-Precategory precategory-Poset (is-prop-leq-Poset X x y))
+      ( is-prop-iso-is-prop-hom-Precategory precategory-Poset
+        ( is-prop-leq-Poset X x y))
       ( λ f →
         antisymmetric-leq-Poset X x y
           ( hom-iso-Precategory precategory-Poset f)
@@ -169,8 +170,7 @@ module _
 
 module _
   {l1 l2 : Level} (C : Category l1 l2)
-  ( is-prop-hom-C :
-    (x y : obj-Category C) → is-prop (hom-Category C x y))
+  (is-prop-hom-C : (x y : obj-Category C) → is-prop (hom-Category C x y))
   where
 
   preorder-is-prop-hom-Category : Preorder l1 l2
diff --git a/src/orthogonal-factorization-systems/closed-modalities.lagda.md b/src/orthogonal-factorization-systems/closed-modalities.lagda.md
index d8b6f9a452..d39203d1c0 100644
--- a/src/orthogonal-factorization-systems/closed-modalities.lagda.md
+++ b/src/orthogonal-factorization-systems/closed-modalities.lagda.md
@@ -122,4 +122,4 @@ module _
 - Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
   theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
   ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-  [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+  [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
diff --git a/src/orthogonal-factorization-systems/higher-modalities.lagda.md b/src/orthogonal-factorization-systems/higher-modalities.lagda.md
index 24b4ee3b68..26554e0958 100644
--- a/src/orthogonal-factorization-systems/higher-modalities.lagda.md
+++ b/src/orthogonal-factorization-systems/higher-modalities.lagda.md
@@ -354,4 +354,4 @@ The equivalent notions of
 - Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
   theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
   ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-  [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+  [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
diff --git a/src/orthogonal-factorization-systems/localizations-maps.lagda.md b/src/orthogonal-factorization-systems/localizations-maps.lagda.md
index c904c96be9..afdb8a9d4b 100644
--- a/src/orthogonal-factorization-systems/localizations-maps.lagda.md
+++ b/src/orthogonal-factorization-systems/localizations-maps.lagda.md
@@ -92,7 +92,6 @@ It remains to construct a converse.
 1. Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
    theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
    ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-   [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+   [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
 2. <a name="classifying-types"></a>Egbert Rijke, _Classifying Types_
-   ([arXiv:1906.09435](https://arxiv.org/abs/1906.09435),
-   [doi:10.48550](https://doi.org/10.48550/arXiv.1906.09435))
+   ([arXiv:1906.09435](https://arxiv.org/abs/1906.09435))
diff --git a/src/orthogonal-factorization-systems/localizations-subuniverses.lagda.md b/src/orthogonal-factorization-systems/localizations-subuniverses.lagda.md
index b48b595c6a..d5903a78da 100644
--- a/src/orthogonal-factorization-systems/localizations-subuniverses.lagda.md
+++ b/src/orthogonal-factorization-systems/localizations-subuniverses.lagda.md
@@ -119,7 +119,6 @@ This is Proposition 5.1.2 in _Classifying Types_, and remains to be formalized.
 1. Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
    theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
    ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-   [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+   [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
 2. <a name="classifying-types"></a>Egbert Rijke, _Classifying Types_
-   ([arXiv:1906.09435](https://arxiv.org/abs/1906.09435),
-   [doi:10.48550](https://doi.org/10.48550/arXiv.1906.09435))
+   ([arXiv:1906.09435](https://arxiv.org/abs/1906.09435))
diff --git a/src/orthogonal-factorization-systems/modal-operators.lagda.md b/src/orthogonal-factorization-systems/modal-operators.lagda.md
index ea6b4b64dc..d178089800 100644
--- a/src/orthogonal-factorization-systems/modal-operators.lagda.md
+++ b/src/orthogonal-factorization-systems/modal-operators.lagda.md
@@ -147,4 +147,4 @@ module _
 - Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
   theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
   ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-  [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+  [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
diff --git a/src/orthogonal-factorization-systems/orthogonal-factorization-systems.lagda.md b/src/orthogonal-factorization-systems/orthogonal-factorization-systems.lagda.md
index 328d0a5873..e59c641fc3 100644
--- a/src/orthogonal-factorization-systems/orthogonal-factorization-systems.lagda.md
+++ b/src/orthogonal-factorization-systems/orthogonal-factorization-systems.lagda.md
@@ -189,4 +189,4 @@ This remains to be shown.
 - Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
   theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
   ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-  [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+  [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
diff --git a/src/orthogonal-factorization-systems/reflective-subuniverses.lagda.md b/src/orthogonal-factorization-systems/reflective-subuniverses.lagda.md
index 49057ab99b..d2f588bdd1 100644
--- a/src/orthogonal-factorization-systems/reflective-subuniverses.lagda.md
+++ b/src/orthogonal-factorization-systems/reflective-subuniverses.lagda.md
@@ -187,12 +187,10 @@ module _
 
 1. Univalent Foundations Project, _Homotopy Type Theory – Univalent Foundations
    of Mathematics_ (2013) ([website](https://homotopytypetheory.org/book/),
-   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729),
-   [DOI:10.48550](https://doi.org/10.48550/arXiv.1308.0729))
+   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729))
 2. Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
    theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
    ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-   [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+   [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
 3. Egbert Rijke, _Classifying Types_
-   ([arXiv:1906.09435](https://arxiv.org/abs/1906.09435),
-   [doi:10.48550](https://doi.org/10.48550/arXiv.1906.09435))
+   ([arXiv:1906.09435](https://arxiv.org/abs/1906.09435))
diff --git a/src/orthogonal-factorization-systems/separated-types.lagda.md b/src/orthogonal-factorization-systems/separated-types.lagda.md
index 7402a89313..d773fc900e 100644
--- a/src/orthogonal-factorization-systems/separated-types.lagda.md
+++ b/src/orthogonal-factorization-systems/separated-types.lagda.md
@@ -38,5 +38,4 @@ module _
 ## References
 
 1. Egbert Rijke, _Classifying Types_
-   ([arXiv:1906.09435](https://arxiv.org/abs/1906.09435),
-   [doi:10.48550](https://doi.org/10.48550/arXiv.1906.09435))
+   ([arXiv:1906.09435](https://arxiv.org/abs/1906.09435))
diff --git a/src/orthogonal-factorization-systems/sigma-closed-reflective-subuniverses.lagda.md b/src/orthogonal-factorization-systems/sigma-closed-reflective-subuniverses.lagda.md
index 5b037b7ed8..1f845ce440 100644
--- a/src/orthogonal-factorization-systems/sigma-closed-reflective-subuniverses.lagda.md
+++ b/src/orthogonal-factorization-systems/sigma-closed-reflective-subuniverses.lagda.md
@@ -52,4 +52,4 @@ The equivalent notions of
 - Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
   theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
   ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-  [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+  [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
diff --git a/src/orthogonal-factorization-systems/stable-orthogonal-factorization-systems.lagda.md b/src/orthogonal-factorization-systems/stable-orthogonal-factorization-systems.lagda.md
index fad1c15f29..da36de111e 100644
--- a/src/orthogonal-factorization-systems/stable-orthogonal-factorization-systems.lagda.md
+++ b/src/orthogonal-factorization-systems/stable-orthogonal-factorization-systems.lagda.md
@@ -50,4 +50,4 @@ The equivalent notions of
 - Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
   theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
   ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-  [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+  [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
diff --git a/src/orthogonal-factorization-systems/uniquely-eliminating-modalities.lagda.md b/src/orthogonal-factorization-systems/uniquely-eliminating-modalities.lagda.md
index f01cf72205..76f7bdfd1c 100644
--- a/src/orthogonal-factorization-systems/uniquely-eliminating-modalities.lagda.md
+++ b/src/orthogonal-factorization-systems/uniquely-eliminating-modalities.lagda.md
@@ -203,4 +203,4 @@ The equivalent notions of
 - Egbert Rijke, Michael Shulman, Bas Spitters, _Modalities in homotopy type
   theory_, Logical Methods in Computer Science, Volume 16, Issue 1, 2020
   ([arXiv:1706.07526](https://arxiv.org/abs/1706.07526),
-  [doi:10.23638](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
+  [DOI:10.23638/LMCS-16(1:2)2020](https://doi.org/10.23638/LMCS-16%281%3A2%292020))
diff --git a/src/set-theory/cumulative-hierarchy.lagda.md b/src/set-theory/cumulative-hierarchy.lagda.md
index 7dae074724..95866ae5ba 100644
--- a/src/set-theory/cumulative-hierarchy.lagda.md
+++ b/src/set-theory/cumulative-hierarchy.lagda.md
@@ -764,8 +764,7 @@ needed.
 
 1. Univalent Foundations Project, _Homotopy Type Theory – Univalent Foundations
    of Mathematics_ (2013) ([website](https://homotopytypetheory.org/book/),
-   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729),
-   [DOI:10.48550](https://doi.org/10.48550/arXiv.1308.0729))
+   [arXiv:1308.0729](https://arxiv.org/abs/1308.0729))
 2. Tom de Jong, in collaboration with Nicolai Kraus, Fredrik Nordvall Forsberg
    and Chuangjie Xu.
    <https://www.cs.bham.ac.uk/~mhe/agda/UF.CumulativeHierarchy.html>
diff --git a/src/synthetic-homotopy-theory/joins-of-types.lagda.md b/src/synthetic-homotopy-theory/joins-of-types.lagda.md
index b1bf34beb5..4da4766e1e 100644
--- a/src/synthetic-homotopy-theory/joins-of-types.lagda.md
+++ b/src/synthetic-homotopy-theory/joins-of-types.lagda.md
@@ -361,5 +361,4 @@ module _
 ## References
 
 - Egbert Rijke, _The join construction_, 2017
-  ([arXiv:1701.07538](https://arxiv.org/abs/1701.07538),
-  [DOI:10.48550](https://doi.org/10.48550/arXiv.1701.07538))
+  ([arXiv:1701.07538](https://arxiv.org/abs/1701.07538))