From 37afbe6bee4edcdf9f28265edb5e4c34038d99d0 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 5 Jun 2024 18:21:03 +0200
Subject: [PATCH 01/33] WIP zigzags identity types

---
 .../descent-data-pushouts.lagda.md            |   7 +
 .../pushouts.lagda.md                         |  26 +
 ...nstruction-identity-type-pushouts.lagda.md | 450 ++++++++++++++++++
 3 files changed, 483 insertions(+)
 create mode 100644 src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md

diff --git a/src/synthetic-homotopy-theory/descent-data-pushouts.lagda.md b/src/synthetic-homotopy-theory/descent-data-pushouts.lagda.md
index 020d2dcefb..80fd5e1b19 100644
--- a/src/synthetic-homotopy-theory/descent-data-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/descent-data-pushouts.lagda.md
@@ -106,6 +106,13 @@ module _
   map-family-descent-data-pushout s =
     map-equiv (equiv-family-descent-data-pushout s)
 
+  inv-map-family-descent-data-pushout :
+    (s : spanning-type-span-diagram 𝒮) →
+    right-family-descent-data-pushout (right-map-span-diagram 𝒮 s) →
+    left-family-descent-data-pushout (left-map-span-diagram 𝒮 s)
+  inv-map-family-descent-data-pushout s =
+    map-inv-equiv (equiv-family-descent-data-pushout s)
+
   is-equiv-map-family-descent-data-pushout :
     (s : spanning-type-span-diagram 𝒮) →
     is-equiv (map-family-descent-data-pushout s)
diff --git a/src/synthetic-homotopy-theory/pushouts.lagda.md b/src/synthetic-homotopy-theory/pushouts.lagda.md
index 1b5112681f..768276d97f 100644
--- a/src/synthetic-homotopy-theory/pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/pushouts.lagda.md
@@ -21,6 +21,7 @@ open import foundation.identity-types
 open import foundation.propositions
 open import foundation.retractions
 open import foundation.sections
+open import foundation.span-diagrams
 open import foundation.transport-along-homotopies
 open import foundation.transport-along-identifications
 open import foundation.universe-levels
@@ -124,6 +125,31 @@ cocone-pushout :
 pr1 (cocone-pushout f g) = inl-pushout f g
 pr1 (pr2 (cocone-pushout f g)) = inr-pushout f g
 pr2 (pr2 (cocone-pushout f g)) = glue-pushout f g
+
+module _
+  {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
+  where
+
+  standard-pushout : UU (l1 ⊔ l2 ⊔ l3)
+  standard-pushout =
+    pushout (left-map-span-diagram 𝒮) (right-map-span-diagram 𝒮)
+
+  inl-standard-pushout : domain-span-diagram 𝒮 → standard-pushout
+  inl-standard-pushout =
+    inl-pushout (left-map-span-diagram 𝒮) (right-map-span-diagram 𝒮)
+
+  inr-standard-pushout : codomain-span-diagram 𝒮 → standard-pushout
+  inr-standard-pushout =
+    inr-pushout (left-map-span-diagram 𝒮) (right-map-span-diagram 𝒮)
+
+  glue-standard-pushout :
+    coherence-square-maps
+      ( right-map-span-diagram 𝒮)
+      ( left-map-span-diagram 𝒮)
+      ( inr-standard-pushout)
+      ( inl-standard-pushout)
+  glue-standard-pushout =
+    glue-pushout (left-map-span-diagram 𝒮) (right-map-span-diagram 𝒮)
 ```
 
 ### The dependent cogap map
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
new file mode 100644
index 0000000000..1360026804
--- /dev/null
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -0,0 +1,450 @@
+# The zigzag construction of identity types of pushouts
+
+```agda
+{-# OPTIONS --lossy-unification #-}
+
+module synthetic-homotopy-theory.zigzag-construction-identity-type-pushouts where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+-- open import foundation.commuting-squares-of-maps
+-- open import foundation.contractible-types
+open import foundation.cartesian-product-types
+open import foundation.dependent-pair-types
+open import foundation.empty-types
+open import foundation.equivalences
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+-- open import foundation.fundamental-theorem-of-identity-types
+-- open import foundation.homotopies
+-- open import foundation.identity-systems
+open import foundation.identity-types
+-- open import foundation.sections
+-- open import foundation.singleton-induction
+open import foundation.raising-universe-levels
+open import foundation.span-diagrams
+open import foundation.transport-along-identifications
+-- open import foundation.torsorial-type-families
+-- open import foundation.transposition-identifications-along-equivalences
+-- open import foundation.universal-property-dependent-pair-types
+-- open import foundation.universal-property-identity-types
+open import foundation.universe-levels
+
+open import synthetic-homotopy-theory.cocones-under-spans
+-- open import synthetic-homotopy-theory.dependent-universal-property-pushouts
+-- open import synthetic-homotopy-theory.descent-data-equivalence-types-over-pushouts
+-- open import synthetic-homotopy-theory.descent-data-identity-types-over-pushouts
+open import synthetic-homotopy-theory.dependent-cocones-under-sequential-diagrams
+open import synthetic-homotopy-theory.dependent-cocones-under-spans
+open import synthetic-homotopy-theory.descent-data-pushouts
+open import synthetic-homotopy-theory.functoriality-sequential-colimits
+open import synthetic-homotopy-theory.identity-systems-descent-data-pushouts
+-- open import synthetic-homotopy-theory.descent-property-pushouts
+-- open import synthetic-homotopy-theory.equivalences-descent-data-pushouts
+-- open import synthetic-homotopy-theory.families-descent-data-pushouts
+open import synthetic-homotopy-theory.flattening-lemma-pushouts
+-- open import synthetic-homotopy-theory.morphisms-descent-data-pushouts
+open import synthetic-homotopy-theory.pushouts
+open import synthetic-homotopy-theory.sequential-colimits
+open import synthetic-homotopy-theory.sequential-diagrams
+open import synthetic-homotopy-theory.shifts-sequential-diagrams
+open import synthetic-homotopy-theory.sections-descent-data-pushouts
+open import synthetic-homotopy-theory.universal-property-pushouts
+open import synthetic-homotopy-theory.zigzags-sequential-diagrams
+```
+
+</details>
+
+## Idea
+
+TODO
+
+## Definitions
+
+### TODO
+
+```agda
+module _
+  {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
+  where
+
+  type-stage-zigzag-construction-id-pushout : UU (lsuc (l1 ⊔ l2 ⊔ l3))
+  type-stage-zigzag-construction-id-pushout =
+    Σ ( codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
+      ( λ Path-to-b →
+        Σ ( domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
+          ( λ Path-to-a →
+            ( (s : spanning-type-span-diagram 𝒮) →
+              Path-to-b (right-map-span-diagram 𝒮 s) →
+              Path-to-a (left-map-span-diagram 𝒮 s))))
+
+module _
+  {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
+  (a₀ : domain-span-diagram 𝒮)
+  where
+
+  stage-zigzag-construction-id-pushout :
+    ℕ → type-stage-zigzag-construction-id-pushout 𝒮
+  stage-zigzag-construction-id-pushout zero-ℕ =
+    Path-to-b ,
+    Path-to-a ,
+    ( λ s → raise-ex-falso _) -- ,
+    -- ( λ s p → inr-pushout _ _ (s , refl , p))
+    where
+    Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+    Path-to-b _ = raise-empty _
+    Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+    Path-to-a a = raise (l2 ⊔ l3) (a₀ ＝ a)
+  stage-zigzag-construction-id-pushout (succ-ℕ n) =
+    Path-to-b ,
+    Path-to-a ,
+    ( λ s p → inr-pushout _ _ (s , refl , p)) -- ,
+    -- ( λ s p → inr-pushout _ _ (s , refl , p))
+    where
+    span-diagram-B :
+      codomain-span-diagram 𝒮 →
+      span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
+    span-diagram-B b =
+      make-span-diagram
+        ( pr2 ∘ pr2)
+        ( tot
+          ( λ s →
+            tot
+              ( λ r (p : pr1 (stage-zigzag-construction-id-pushout n) b) →
+                pr2
+                  ( pr2 (stage-zigzag-construction-id-pushout n))
+                  ( s)
+                  ( tr (pr1 (stage-zigzag-construction-id-pushout n)) r p))))
+    Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+    Path-to-b b = standard-pushout (span-diagram-B b)
+    span-diagram-A :
+      domain-span-diagram 𝒮 →
+      span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
+    span-diagram-A a =
+      make-span-diagram
+        ( pr2 ∘ pr2)
+        ( tot
+          ( λ s →
+            tot
+              ( λ r (p : pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a) →
+                inr-standard-pushout
+                  ( span-diagram-B (right-map-span-diagram 𝒮 s))
+                  ( ( s) ,
+                    ( refl) ,
+                    ( tr
+                      (pr1 (pr2 (stage-zigzag-construction-id-pushout n)))
+                      ( r)
+                      ( p))))))
+    Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+    Path-to-a a = standard-pushout (span-diagram-A a)
+
+  Path-to-b : codomain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
+  Path-to-b b n = pr1 (stage-zigzag-construction-id-pushout n) b
+
+  Path-to-a : domain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
+  Path-to-a a n = pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a
+
+  concat-inv-s :
+    (s : spanning-type-span-diagram 𝒮) →
+    (n : ℕ) →
+    Path-to-b (right-map-span-diagram 𝒮 s) n →
+    Path-to-a (left-map-span-diagram 𝒮 s) n
+  concat-inv-s s n = pr2 (pr2 (stage-zigzag-construction-id-pushout n)) s
+
+  concat-s :
+    (s : spanning-type-span-diagram 𝒮) →
+    (n : ℕ) →
+    Path-to-a (left-map-span-diagram 𝒮 s) n →
+    Path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n)
+  concat-s s n p = inr-pushout _ _ (s , refl , p)
+
+  right-sequential-diagram-zigzag-id-pushout :
+    codomain-span-diagram 𝒮 →
+    sequential-diagram (l1 ⊔ l2 ⊔ l3)
+  pr1 (right-sequential-diagram-zigzag-id-pushout b) n = Path-to-b b n
+  pr2 (right-sequential-diagram-zigzag-id-pushout b) n = inl-pushout _ _
+
+  left-sequential-diagram-zigzag-id-pushout :
+    domain-span-diagram 𝒮 →
+    sequential-diagram (l1 ⊔ l2 ⊔ l3)
+  pr1 (left-sequential-diagram-zigzag-id-pushout a) n = Path-to-a a n
+  pr2 (left-sequential-diagram-zigzag-id-pushout a) n = inl-pushout _ _
+
+  zigzag-sequential-diagram-zigzag-id-pushout :
+    (s : spanning-type-span-diagram 𝒮) →
+    zigzag-sequential-diagram
+      ( left-sequential-diagram-zigzag-id-pushout
+        ( left-map-span-diagram 𝒮 s))
+      ( shift-once-sequential-diagram
+        ( right-sequential-diagram-zigzag-id-pushout
+          ( right-map-span-diagram 𝒮 s)))
+  pr1 (zigzag-sequential-diagram-zigzag-id-pushout s) n =
+    concat-s s n
+  pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s)) n =
+    concat-inv-s s (succ-ℕ n)
+  pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
+    glue-pushout _ _ (s , refl , p)
+  pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
+    glue-pushout _ _ (s , refl , p)
+
+--   -- zigzag-sequential-diagram-zigzag-id-pushout' :
+--   --   (s : spanning-type-span-diagram 𝒮) →
+--   --   zigzag-sequential-diagram
+--   --     ( right-sequential-diagram-zigzag-id-pushout
+--   --       ( right-map-span-diagram 𝒮 s))
+--   --     ( left-sequential-diagram-zigzag-id-pushout
+--   --       ( left-map-span-diagram 𝒮 s))
+--   -- pr1 (zigzag-sequential-diagram-zigzag-id-pushout' s) n =
+--   --   pr1 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
+--   -- pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s)) n =
+--   --   pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
+--   -- pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s)))
+--   --   zero-ℕ (map-raise ())
+--   -- pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s))) (succ-ℕ n) p =
+--   --   glue-pushout _ _ (s , refl , p)
+--   -- pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s))) n p =
+--   --   glue-pushout _ _ (s , refl , p)
+
+  left-id-pushout : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+  left-id-pushout a =
+    standard-sequential-colimit (left-sequential-diagram-zigzag-id-pushout a)
+
+  refl-id-pushout : left-id-pushout a₀
+  refl-id-pushout =
+    map-cocone-standard-sequential-colimit 0 (map-raise refl)
+
+  right-id-pushout : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+  right-id-pushout b =
+    standard-sequential-colimit (right-sequential-diagram-zigzag-id-pushout b)
+
+  equiv-id-pushout :
+    (s : spanning-type-span-diagram 𝒮) →
+    left-id-pushout (left-map-span-diagram 𝒮 s) ≃
+    right-id-pushout (right-map-span-diagram 𝒮 s)
+  equiv-id-pushout s =
+    equiv-colimit-zigzag-sequential-diagram _ _
+      ( up-standard-sequential-colimit)
+      ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+      ( zigzag-sequential-diagram-zigzag-id-pushout s)
+
+  descent-data-zigzag-id-pushout : descent-data-pushout 𝒮 (l1 ⊔ l2 ⊔ l3)
+  pr1 descent-data-zigzag-id-pushout = left-id-pushout
+  pr1 (pr2 descent-data-zigzag-id-pushout) = right-id-pushout
+  pr2 (pr2 descent-data-zigzag-id-pushout) = equiv-id-pushout
+```
+
+## Theorem
+
+### TODO
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level} {𝒮 : span-diagram l1 l2 l3}
+  {X : UU l4} {c : cocone-span-diagram 𝒮 X}
+  (up-c : universal-property-pushout _ _ c)
+  (a₀ : domain-span-diagram 𝒮)
+  where
+
+  type-stage-ind-singleton-zigzag-id-pushout :
+    {l5 : Level}
+    (R : descent-data-pushout
+      ( span-diagram-flattening-descent-data-pushout
+        ( descent-data-zigzag-id-pushout 𝒮 a₀))
+      ( l5))
+    (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀)) →
+    UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
+  type-stage-ind-singleton-zigzag-id-pushout R r₀ =
+    Σ ( (a : domain-span-diagram 𝒮) →
+        dependent-cocone-sequential-diagram
+          ( cocone-standard-sequential-colimit
+            ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
+          ( λ p → left-family-descent-data-pushout R (a , p)))
+      ( λ dep-cocone-left →
+        (b : codomain-span-diagram 𝒮) →
+        dependent-cocone-sequential-diagram
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit
+              ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b)))
+          ( λ p → right-family-descent-data-pushout R (b , p)))
+
+  module _
+    {l5 : Level}
+    (R : descent-data-pushout
+      ( span-diagram-flattening-descent-data-pushout
+        ( descent-data-zigzag-id-pushout 𝒮 a₀))
+      ( l5))
+    (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
+    where
+
+    type-stage-map-ind-singleton-zigzag-id-pushout :
+      (n : ℕ) →
+      UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
+    type-stage-map-ind-singleton-zigzag-id-pushout n =
+      Σ ( (b : codomain-span-diagram 𝒮) (p : Path-to-b 𝒮 a₀ b n) →
+          right-family-descent-data-pushout R
+            (b , map-cocone-standard-sequential-colimit n p))
+        ( λ tB →
+          Σ ( (a : domain-span-diagram 𝒮) (p : Path-to-a 𝒮 a₀ a n) →
+              left-family-descent-data-pushout R
+                (a , map-cocone-standard-sequential-colimit n p))
+            ( λ tA →
+              (s : spanning-type-span-diagram 𝒮)
+              (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+              {!tB (right-map-span-diagram 𝒮 s)
+                ?!} ＝
+                {!tr
+                  ( )!}))
+              -- map-family-descent-data-pushout R
+              --   ( s , map-cocone-standard-sequential-colimit n p)
+              --   ( tA (left-map-span-diagram 𝒮 s) p)))
+
+    stage-map-ind-singleton-zigzag-id-pushout :
+      (n : ℕ) → type-stage-map-ind-singleton-zigzag-id-pushout n
+    stage-map-ind-singleton-zigzag-id-pushout zero-ℕ =
+      map-b ,
+      map-a ,
+      {!!}
+      where
+      map-b :
+        (b : codomain-span-diagram 𝒮) (p : Path-to-b 𝒮 a₀ b 0) →
+        right-family-descent-data-pushout R
+          ( b , map-cocone-standard-sequential-colimit 0 p)
+      map-b b (map-raise ())
+      map-a :
+        (a : domain-span-diagram 𝒮) (p : Path-to-a 𝒮 a₀ a 0) →
+        left-family-descent-data-pushout R
+          ( a , map-cocone-standard-sequential-colimit 0 p)
+      map-a a (map-raise refl) = r₀
+    stage-map-ind-singleton-zigzag-id-pushout (succ-ℕ n) =
+      map-b ,
+      map-a ,
+      {!!}
+      where
+      dep-cocone-b :
+        (b : codomain-span-diagram 𝒮) →
+        dependent-cocone _ _
+          ( cocone-pushout _ _)
+          ( λ p →
+            right-family-descent-data-pushout R
+              ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+      pr1 (dep-cocone-b b) p =
+        tr
+          ( ev-pair (right-family-descent-data-pushout R) b)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( pr1 (stage-map-ind-singleton-zigzag-id-pushout n) b p)
+      pr1 (pr2 (dep-cocone-b b)) (s , refl , p) =
+        tr
+          ( ev-pair (right-family-descent-data-pushout R) b)
+          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+            ( up-standard-sequential-colimit)
+            ( shift-once-cocone-sequential-diagram
+              ( cocone-standard-sequential-colimit
+                ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b)))
+            ( hom-diagram-zigzag-sequential-diagram
+              ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+            ( n)
+            ( p))
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit n p)
+            ( pr1
+              ( pr2 ( stage-map-ind-singleton-zigzag-id-pushout n))
+              ( left-map-span-diagram 𝒮 s)
+              ( p)))
+      pr2 (pr2 (dep-cocone-b b)) (s , refl , p) = {!!}
+      map-b :
+        (b : codomain-span-diagram 𝒮) (p : Path-to-b 𝒮 a₀ b (succ-ℕ n)) →
+        right-family-descent-data-pushout R
+          ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
+      map-b b = dependent-cogap _ _ (dep-cocone-b b)
+      dep-cocone-a :
+        (a : domain-span-diagram 𝒮) →
+        dependent-cocone _ _
+          ( cocone-pushout _ _)
+          ( λ p →
+            left-family-descent-data-pushout R
+              ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+      pr1 (dep-cocone-a a) p =
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( coherence-cocone-standard-sequential-colimit n p)
+        ( pr1 (pr2 (stage-map-ind-singleton-zigzag-id-pushout n)) a p)
+      pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+            ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+            ( shift-once-cocone-sequential-diagram
+              ( cocone-standard-sequential-colimit
+                ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a)))
+            ( inv-hom-diagram-zigzag-sequential-diagram
+              ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+            ( n)
+            ( p))
+          ( inv-map-family-descent-data-pushout R
+            ( s ,
+              map-inv-equiv
+                ( equiv-id-pushout 𝒮 a₀ s)
+                ( map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+            ( tr
+              ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+              ( inv
+                ( is-section-map-inv-equiv
+                  ( equiv-id-pushout 𝒮 a₀ s)
+                  ( map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
+              ( map-b (right-map-span-diagram 𝒮 s) p)))
+      pr2 (pr2 (dep-cocone-a a)) (s , refl , p) = {!!}
+      map-a :
+        (a : domain-span-diagram 𝒮) (p : Path-to-a 𝒮 a₀ a (succ-ℕ n)) →
+        left-family-descent-data-pushout R
+          ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
+      map-a a = dependent-cogap _ _ (dep-cocone-a a)
+
+  ind-singleton-zigzag-id-pushout :
+    {l5 : Level}
+    (R :
+      descent-data-pushout
+        ( span-diagram-flattening-descent-data-pushout
+          ( descent-data-zigzag-id-pushout 𝒮 a₀))
+        ( l5))
+    (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀)) →
+    section-descent-data-pushout R
+  ind-singleton-zigzag-id-pushout R r₀ =
+    ind-Σ (λ a → dependent-cogap-standard-sequential-colimit (dep-cocone-a a)) ,
+    ind-Σ (λ b → dependent-cogap-standard-sequential-colimit (dep-cocone-b b)) ,
+    ind-Σ {!!}
+    where
+      dep-cocone-a :
+        ( a : domain-span-diagram 𝒮) →
+        dependent-cocone-sequential-diagram
+          ( cocone-standard-sequential-colimit
+            ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
+          ( λ p → left-family-descent-data-pushout R (a , p))
+      pr1 (dep-cocone-a a) n =
+        pr1 (pr2 (stage-map-ind-singleton-zigzag-id-pushout R r₀ n)) a
+      pr2 (dep-cocone-a a) n =
+        {!!}
+      dep-cocone-b :
+        (b : codomain-span-diagram 𝒮) →
+        dependent-cocone-sequential-diagram
+          ( cocone-standard-sequential-colimit
+            ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b))
+          ( λ p → right-family-descent-data-pushout R (b , p))
+      pr1 (dep-cocone-b b) n =
+        pr1 (stage-map-ind-singleton-zigzag-id-pushout R r₀ n) b
+      pr2 (dep-cocone-b b) n =
+        {!!}
+
+  is-identity-system-zigzag-id-pushout :
+    is-identity-system-descent-data-pushout
+      ( descent-data-zigzag-id-pushout 𝒮 a₀)
+      ( refl-id-pushout 𝒮 a₀)
+  is-identity-system-zigzag-id-pushout =
+    is-identity-system-descent-data-pushout-ind-singleton up-c
+      ( descent-data-zigzag-id-pushout 𝒮 a₀)
+      ( refl-id-pushout 𝒮 a₀)
+      ( ind-singleton-zigzag-id-pushout)
+```

From ab80307cf49e49c440b078f1eee6a72fefae1cd5 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 12 Jun 2024 18:07:58 +0200
Subject: [PATCH 02/33] WIP interleaved mutual

---
 ...nstruction-identity-type-pushouts.lagda.md | 161 +++++++++++++++++-
 1 file changed, 155 insertions(+), 6 deletions(-)

diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index 1360026804..1ac3f31058 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -148,6 +148,14 @@ module _
   Path-to-a : domain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
   Path-to-a a n = pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a
 
+  inl-Path-to-b :
+    (b : codomain-span-diagram 𝒮) (n : ℕ) → Path-to-b b n → Path-to-b b (succ-ℕ n)
+  inl-Path-to-b b n = inl-pushout _ _
+
+  inl-Path-to-a :
+    (a : domain-span-diagram 𝒮) (n : ℕ) → Path-to-a a n → Path-to-a a (succ-ℕ n)
+  inl-Path-to-a a n = inl-pushout _ _
+
   concat-inv-s :
     (s : spanning-type-span-diagram 𝒮) →
     (n : ℕ) →
@@ -165,14 +173,14 @@ module _
   right-sequential-diagram-zigzag-id-pushout :
     codomain-span-diagram 𝒮 →
     sequential-diagram (l1 ⊔ l2 ⊔ l3)
-  pr1 (right-sequential-diagram-zigzag-id-pushout b) n = Path-to-b b n
-  pr2 (right-sequential-diagram-zigzag-id-pushout b) n = inl-pushout _ _
+  pr1 (right-sequential-diagram-zigzag-id-pushout b) = Path-to-b b
+  pr2 (right-sequential-diagram-zigzag-id-pushout b) = inl-Path-to-b b
 
   left-sequential-diagram-zigzag-id-pushout :
     domain-span-diagram 𝒮 →
     sequential-diagram (l1 ⊔ l2 ⊔ l3)
-  pr1 (left-sequential-diagram-zigzag-id-pushout a) n = Path-to-a a n
-  pr2 (left-sequential-diagram-zigzag-id-pushout a) n = inl-pushout _ _
+  pr1 (left-sequential-diagram-zigzag-id-pushout a) = Path-to-a a
+  pr2 (left-sequential-diagram-zigzag-id-pushout a) = inl-Path-to-a a
 
   zigzag-sequential-diagram-zigzag-id-pushout :
     (s : spanning-type-span-diagram 𝒮) →
@@ -182,8 +190,8 @@ module _
       ( shift-once-sequential-diagram
         ( right-sequential-diagram-zigzag-id-pushout
           ( right-map-span-diagram 𝒮 s)))
-  pr1 (zigzag-sequential-diagram-zigzag-id-pushout s) n =
-    concat-s s n
+  pr1 (zigzag-sequential-diagram-zigzag-id-pushout s) =
+    concat-s s
   pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s)) n =
     concat-inv-s s (succ-ℕ n)
   pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
@@ -231,6 +239,20 @@ module _
       ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
       ( zigzag-sequential-diagram-zigzag-id-pushout s)
 
+  concat-inv-s-inf :
+    (s : spanning-type-span-diagram 𝒮) →
+    right-id-pushout (right-map-span-diagram 𝒮 s) →
+    left-id-pushout (left-map-span-diagram 𝒮 s)
+  concat-inv-s-inf s =
+    map-inv-equiv (equiv-id-pushout s)
+
+  concat-s-inf :
+    (s : spanning-type-span-diagram 𝒮) →
+    left-id-pushout (left-map-span-diagram 𝒮 s) →
+    right-id-pushout (right-map-span-diagram 𝒮 s)
+  concat-s-inf s =
+    map-equiv (equiv-id-pushout s)
+
   descent-data-zigzag-id-pushout : descent-data-pushout 𝒮 (l1 ⊔ l2 ⊔ l3)
   pr1 descent-data-zigzag-id-pushout = left-id-pushout
   pr1 (pr2 descent-data-zigzag-id-pushout) = right-id-pushout
@@ -280,6 +302,133 @@ module _
     (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
     where
 
+    interleaved mutual
+      cocone-tA :
+        (a : domain-span-diagram 𝒮) →
+        (n : ℕ) →
+        dependent-cocone-span-diagram
+          ( cocone-pushout _ _)
+          ( λ p →
+            left-family-descent-data-pushout R
+              ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+      cocone-tB :
+        (b : codomain-span-diagram 𝒮) →
+        (n : ℕ) →
+        dependent-cocone-span-diagram
+          ( cocone-pushout _ _)
+          ( λ p →
+            right-family-descent-data-pushout R
+              ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+      cocone-tAA :
+        (a : domain-span-diagram 𝒮) →
+        dependent-cocone-sequential-diagram
+          ( cocone-standard-sequential-colimit
+            ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
+          ( λ p → left-family-descent-data-pushout R (a , p))
+      cocone-tBB :
+        (b : codomain-span-diagram 𝒮) →
+        dependent-cocone-sequential-diagram
+          ( cocone-standard-sequential-colimit
+            ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b))
+          ( λ p → right-family-descent-data-pushout R (b , p))
+      tA :
+        (a : domain-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ a n) →
+        left-family-descent-data-pushout R
+          ( a , map-cocone-standard-sequential-colimit n p)
+      tAA :
+        (a : domain-span-diagram 𝒮) →
+        (p : left-id-pushout 𝒮 a₀ a) →
+        left-family-descent-data-pushout R (a , p)
+      kA :
+        (a : domain-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ a n) →
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tA a n p) ＝
+        tA a (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p)
+      tB :
+        (b : codomain-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-b 𝒮 a₀ b n) →
+        right-family-descent-data-pushout R
+          ( b , map-cocone-standard-sequential-colimit n p)
+      tBB :
+        (b : codomain-span-diagram 𝒮) →
+        (p : right-id-pushout 𝒮 a₀ b) →
+        right-family-descent-data-pushout R (b , p)
+      kB :
+        (b : codomain-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-b 𝒮 a₀ b n) →
+        tr
+          ( ev-pair (right-family-descent-data-pushout R) b)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tB b n p) ＝
+        tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p)
+      tR :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p)
+          ( tAA
+            ( left-map-span-diagram 𝒮 s)
+            ( map-cocone-standard-sequential-colimit n p)) ＝
+        tBB
+          ( right-map-span-diagram 𝒮 s)
+          ( concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
+      tRR :
+        (s : spanning-type-span-diagram 𝒮) →
+        (p : left-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s)) →
+        map-family-descent-data-pushout R
+          ( s , p)
+          ( tAA (left-map-span-diagram 𝒮 s) p) ＝
+        tBB
+          ( right-map-span-diagram 𝒮 s)
+          ( concat-s-inf 𝒮 a₀ s p)
+
+      tA a zero-ℕ (map-raise refl) = r₀
+      tA a (succ-ℕ n) = dependent-cogap _ _ (cocone-tA a n)
+      tB b zero-ℕ (map-raise ())
+      tB b (succ-ℕ n) = dependent-cogap _ _ (cocone-tB b n)
+      tAA a = dependent-cogap-standard-sequential-colimit (cocone-tAA a)
+      tBB b = dependent-cogap-standard-sequential-colimit (cocone-tBB b)
+
+      pr1 (cocone-tA a n) p =
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tA a n p)
+      pr1 (pr2 (cocone-tA a n)) (s , refl , p) = {!!}
+      pr2 (pr2 (cocone-tA a n)) (s , refl , p) = {!!}
+
+      pr1 (cocone-tB b n) p =
+        tr
+          ( ev-pair (right-family-descent-data-pushout R) b)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tB b n p)
+      pr1 (pr2 (cocone-tB b n)) (s , refl , p) =
+        tr
+          ( ev-pair (right-family-descent-data-pushout R) b)
+          ( {!!})
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit n p)
+            ( tA (left-map-span-diagram 𝒮 s) n p))
+      pr2 (pr2 (cocone-tB b n)) (s , refl , p) = {!!}
+
+      kA a n p = inv (compute-inl-dependent-cogap _ _ (cocone-tA a n) p)
+      kB b n p = inv (compute-inl-dependent-cogap _ _ (cocone-tB b n) p)
+
+      pr1 (cocone-tAA a) = tA a
+      pr2 (cocone-tAA a) = kA a
+
+      pr1 (cocone-tBB b) = tB b
+      pr2 (cocone-tBB b) = kB b
+
     type-stage-map-ind-singleton-zigzag-id-pushout :
       (n : ℕ) →
       UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)

From fc34c9dc837b582b3654c49ff1142205a5be4a2c Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Thu, 13 Jun 2024 16:29:03 +0200
Subject: [PATCH 03/33] Work

---
 ...nstruction-identity-type-pushouts.lagda.md | 362 ++++++++----------
 1 file changed, 155 insertions(+), 207 deletions(-)

diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index 1ac3f31058..cc2fd5192b 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -13,6 +13,7 @@ open import elementary-number-theory.natural-numbers
 
 -- open import foundation.commuting-squares-of-maps
 -- open import foundation.contractible-types
+open import foundation.action-on-identifications-dependent-functions
 open import foundation.cartesian-product-types
 open import foundation.dependent-pair-types
 open import foundation.empty-types
@@ -40,6 +41,7 @@ open import synthetic-homotopy-theory.cocones-under-spans
 -- open import synthetic-homotopy-theory.descent-data-identity-types-over-pushouts
 open import synthetic-homotopy-theory.dependent-cocones-under-sequential-diagrams
 open import synthetic-homotopy-theory.dependent-cocones-under-spans
+open import synthetic-homotopy-theory.dependent-universal-property-sequential-colimits
 open import synthetic-homotopy-theory.descent-data-pushouts
 open import synthetic-homotopy-theory.functoriality-sequential-colimits
 open import synthetic-homotopy-theory.identity-systems-descent-data-pushouts
@@ -302,7 +304,50 @@ module _
     (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
     where
 
+    private
+      CA :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+        concat-inv-s-inf 𝒮 a₀ s
+          ( map-cocone-standard-sequential-colimit (succ-ℕ n) p) ＝
+        map-cocone-standard-sequential-colimit (succ-ℕ n)
+          ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)
+      CA s =
+        htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+          ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit
+              ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s))))
+          ( inv-hom-diagram-zigzag-sequential-diagram
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+
+      CB :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        concat-s-inf 𝒮 a₀ s
+          ( map-cocone-standard-sequential-colimit n p) ＝
+        map-cocone-standard-sequential-colimit (succ-ℕ n)
+          ( concat-s 𝒮 a₀ s n p)
+      CB s =
+        htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+          ( up-standard-sequential-colimit)
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit
+              ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
+          ( hom-diagram-zigzag-sequential-diagram
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+
     interleaved mutual
+      -- left section part tⁿ_A a
+      tA :
+        (a : domain-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ a n) →
+        left-family-descent-data-pushout R
+          ( a , map-cocone-standard-sequential-colimit n p)
+      -- definition of tⁿ⁺¹_A a (pattern matching on Pⁿ⁺¹_A a)
       cocone-tA :
         (a : domain-span-diagram 𝒮) →
         (n : ℕ) →
@@ -311,6 +356,14 @@ module _
           ( λ p →
             left-family-descent-data-pushout R
               ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+      -- right section part tⁿ_B b
+      tB :
+        (b : codomain-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-b 𝒮 a₀ b n) →
+        right-family-descent-data-pushout R
+          ( b , map-cocone-standard-sequential-colimit n p)
+      -- definition of tⁿ⁺¹_B b (pattern matching on Pⁿ⁺¹_B b)
       cocone-tB :
         (b : codomain-span-diagram 𝒮) →
         (n : ℕ) →
@@ -319,69 +372,44 @@ module _
           ( λ p →
             right-family-descent-data-pushout R
               ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+      -- section coherence part tⁿ_S
+      tS :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        tr
+          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+          ( CB s n p)
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit n p)
+            ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+        tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
+      -- left section t_A a
+      tAA :
+        (a : domain-span-diagram 𝒮) →
+        (p : left-id-pushout 𝒮 a₀ a) →
+        left-family-descent-data-pushout R (a , p)
+      -- definition of t_A a (pattern matching on Pᵒᵒ_A a)
       cocone-tAA :
         (a : domain-span-diagram 𝒮) →
         dependent-cocone-sequential-diagram
           ( cocone-standard-sequential-colimit
             ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
           ( λ p → left-family-descent-data-pushout R (a , p))
+      -- right section t_B b
+      tBB :
+        (b : codomain-span-diagram 𝒮) →
+        (p : right-id-pushout 𝒮 a₀ b) →
+        right-family-descent-data-pushout R (b , p)
+      -- definition of t_B b (pattern matching on Pᵒᵒ_B b)
       cocone-tBB :
         (b : codomain-span-diagram 𝒮) →
         dependent-cocone-sequential-diagram
           ( cocone-standard-sequential-colimit
             ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b))
           ( λ p → right-family-descent-data-pushout R (b , p))
-      tA :
-        (a : domain-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-a 𝒮 a₀ a n) →
-        left-family-descent-data-pushout R
-          ( a , map-cocone-standard-sequential-colimit n p)
-      tAA :
-        (a : domain-span-diagram 𝒮) →
-        (p : left-id-pushout 𝒮 a₀ a) →
-        left-family-descent-data-pushout R (a , p)
-      kA :
-        (a : domain-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-a 𝒮 a₀ a n) →
-        tr
-          ( ev-pair (left-family-descent-data-pushout R) a)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tA a n p) ＝
-        tA a (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p)
-      tB :
-        (b : codomain-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-b 𝒮 a₀ b n) →
-        right-family-descent-data-pushout R
-          ( b , map-cocone-standard-sequential-colimit n p)
-      tBB :
-        (b : codomain-span-diagram 𝒮) →
-        (p : right-id-pushout 𝒮 a₀ b) →
-        right-family-descent-data-pushout R (b , p)
-      kB :
-        (b : codomain-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-b 𝒮 a₀ b n) →
-        tr
-          ( ev-pair (right-family-descent-data-pushout R) b)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tB b n p) ＝
-        tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p)
-      tR :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p)
-          ( tAA
-            ( left-map-span-diagram 𝒮 s)
-            ( map-cocone-standard-sequential-colimit n p)) ＝
-        tBB
-          ( right-map-span-diagram 𝒮 s)
-          ( concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
-      tRR :
+      -- section coherence t_S s
+      tSS :
         (s : spanning-type-span-diagram 𝒮) →
         (p : left-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s)) →
         map-family-descent-data-pushout R
@@ -390,8 +418,23 @@ module _
         tBB
           ( right-map-span-diagram 𝒮 s)
           ( concat-s-inf 𝒮 a₀ s p)
+      -- definition of t_S s (pattern matching on Pᵒᵒ_A a)
+      cocone-tSS :
+        (s : spanning-type-span-diagram 𝒮) →
+        dependent-cocone-sequential-diagram
+          ( cocone-standard-sequential-colimit
+            ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+              ( left-map-span-diagram 𝒮 s)))
+          ( λ p →
+            map-family-descent-data-pushout R
+              ( s , p)
+              ( tAA (left-map-span-diagram 𝒮 s) p) ＝
+            tBB (right-map-span-diagram 𝒮 s) (concat-s-inf 𝒮 a₀ s p))
 
       tA a zero-ℕ (map-raise refl) = r₀
+      -- tA (n+1) needs coconeA n, which needs tA n and tB (n+1),
+      -- which needs coconeB n, which only needs tB n and tA n,
+      -- so it terminates
       tA a (succ-ℕ n) = dependent-cogap _ _ (cocone-tA a n)
       tB b zero-ℕ (map-raise ())
       tB b (succ-ℕ n) = dependent-cogap _ _ (cocone-tB b n)
@@ -403,7 +446,19 @@ module _
           ( ev-pair (left-family-descent-data-pushout R) a)
           ( coherence-cocone-standard-sequential-colimit n p)
           ( tA a n p)
-      pr1 (pr2 (cocone-tA a n)) (s , refl , p) = {!!}
+      pr1 (pr2 (cocone-tA a n)) (s , refl , p) =
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( CA s n p)
+          ( inv-map-family-descent-data-pushout R
+            ( s , concat-inv-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+            ( tr
+              ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+              ( inv
+                ( is-section-map-inv-equiv
+                  ( equiv-id-pushout 𝒮 a₀ s)
+                  ( map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
+              ( tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p)))
       pr2 (pr2 (cocone-tA a n)) (s , refl , p) = {!!}
 
       pr1 (cocone-tB b n) p =
@@ -414,145 +469,57 @@ module _
       pr1 (pr2 (cocone-tB b n)) (s , refl , p) =
         tr
           ( ev-pair (right-family-descent-data-pushout R) b)
-          ( {!!})
+          ( CB s n p)
           ( map-family-descent-data-pushout R
             ( s , map-cocone-standard-sequential-colimit n p)
             ( tA (left-map-span-diagram 𝒮 s) n p))
       pr2 (pr2 (cocone-tB b n)) (s , refl , p) = {!!}
 
-      kA a n p = inv (compute-inl-dependent-cogap _ _ (cocone-tA a n) p)
-      kB b n p = inv (compute-inl-dependent-cogap _ _ (cocone-tB b n) p)
+      tS s n p =
+        inv
+          ( compute-inr-dependent-cogap _ _
+            ( cocone-tB (right-map-span-diagram 𝒮 s) n)
+            ( s , refl , p))
+
+      alt-tS :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p)
+          ( tAA
+            ( left-map-span-diagram 𝒮 s)
+            ( map-cocone-standard-sequential-colimit n p)) ＝
+        tBB
+          ( right-map-span-diagram 𝒮 s)
+          ( concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
+      alt-tS s n p =
+        {!tS s n p!}
+        where
+        [ii] =
+          pr1
+            ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+              ( dup-standard-sequential-colimit)
+              ( cocone-tAA (left-map-span-diagram 𝒮 s)))
+            ( n)
+            ( p)
+        [i] =
+          apd
+            ( map-family-descent-data-pushout R (s , map-cocone-standard-sequential-colimit n p))
+            ( [ii])
+
+      tSS s = dependent-cogap-standard-sequential-colimit (cocone-tSS s)
 
       pr1 (cocone-tAA a) = tA a
-      pr2 (cocone-tAA a) = kA a
+      pr2 (cocone-tAA a) n p = inv (compute-inl-dependent-cogap _ _ (cocone-tA a n) p)
 
       pr1 (cocone-tBB b) = tB b
-      pr2 (cocone-tBB b) = kB b
-
-    type-stage-map-ind-singleton-zigzag-id-pushout :
-      (n : ℕ) →
-      UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
-    type-stage-map-ind-singleton-zigzag-id-pushout n =
-      Σ ( (b : codomain-span-diagram 𝒮) (p : Path-to-b 𝒮 a₀ b n) →
-          right-family-descent-data-pushout R
-            (b , map-cocone-standard-sequential-colimit n p))
-        ( λ tB →
-          Σ ( (a : domain-span-diagram 𝒮) (p : Path-to-a 𝒮 a₀ a n) →
-              left-family-descent-data-pushout R
-                (a , map-cocone-standard-sequential-colimit n p))
-            ( λ tA →
-              (s : spanning-type-span-diagram 𝒮)
-              (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-              {!tB (right-map-span-diagram 𝒮 s)
-                ?!} ＝
-                {!tr
-                  ( )!}))
-              -- map-family-descent-data-pushout R
-              --   ( s , map-cocone-standard-sequential-colimit n p)
-              --   ( tA (left-map-span-diagram 𝒮 s) p)))
-
-    stage-map-ind-singleton-zigzag-id-pushout :
-      (n : ℕ) → type-stage-map-ind-singleton-zigzag-id-pushout n
-    stage-map-ind-singleton-zigzag-id-pushout zero-ℕ =
-      map-b ,
-      map-a ,
-      {!!}
-      where
-      map-b :
-        (b : codomain-span-diagram 𝒮) (p : Path-to-b 𝒮 a₀ b 0) →
-        right-family-descent-data-pushout R
-          ( b , map-cocone-standard-sequential-colimit 0 p)
-      map-b b (map-raise ())
-      map-a :
-        (a : domain-span-diagram 𝒮) (p : Path-to-a 𝒮 a₀ a 0) →
-        left-family-descent-data-pushout R
-          ( a , map-cocone-standard-sequential-colimit 0 p)
-      map-a a (map-raise refl) = r₀
-    stage-map-ind-singleton-zigzag-id-pushout (succ-ℕ n) =
-      map-b ,
-      map-a ,
-      {!!}
-      where
-      dep-cocone-b :
-        (b : codomain-span-diagram 𝒮) →
-        dependent-cocone _ _
-          ( cocone-pushout _ _)
-          ( λ p →
-            right-family-descent-data-pushout R
-              ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-      pr1 (dep-cocone-b b) p =
-        tr
-          ( ev-pair (right-family-descent-data-pushout R) b)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( pr1 (stage-map-ind-singleton-zigzag-id-pushout n) b p)
-      pr1 (pr2 (dep-cocone-b b)) (s , refl , p) =
-        tr
-          ( ev-pair (right-family-descent-data-pushout R) b)
-          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-            ( up-standard-sequential-colimit)
-            ( shift-once-cocone-sequential-diagram
-              ( cocone-standard-sequential-colimit
-                ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b)))
-            ( hom-diagram-zigzag-sequential-diagram
-              ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-            ( n)
-            ( p))
-          ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit n p)
-            ( pr1
-              ( pr2 ( stage-map-ind-singleton-zigzag-id-pushout n))
-              ( left-map-span-diagram 𝒮 s)
-              ( p)))
-      pr2 (pr2 (dep-cocone-b b)) (s , refl , p) = {!!}
-      map-b :
-        (b : codomain-span-diagram 𝒮) (p : Path-to-b 𝒮 a₀ b (succ-ℕ n)) →
-        right-family-descent-data-pushout R
-          ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
-      map-b b = dependent-cogap _ _ (dep-cocone-b b)
-      dep-cocone-a :
-        (a : domain-span-diagram 𝒮) →
-        dependent-cocone _ _
-          ( cocone-pushout _ _)
-          ( λ p →
-            left-family-descent-data-pushout R
-              ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-      pr1 (dep-cocone-a a) p =
-        tr
-          ( ev-pair (left-family-descent-data-pushout R) a)
-          ( coherence-cocone-standard-sequential-colimit n p)
-        ( pr1 (pr2 (stage-map-ind-singleton-zigzag-id-pushout n)) a p)
-      pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
-        tr
-          ( ev-pair (left-family-descent-data-pushout R) a)
-          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-            ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
-            ( shift-once-cocone-sequential-diagram
-              ( cocone-standard-sequential-colimit
-                ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a)))
-            ( inv-hom-diagram-zigzag-sequential-diagram
-              ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-            ( n)
-            ( p))
-          ( inv-map-family-descent-data-pushout R
-            ( s ,
-              map-inv-equiv
-                ( equiv-id-pushout 𝒮 a₀ s)
-                ( map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-            ( tr
-              ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-              ( inv
-                ( is-section-map-inv-equiv
-                  ( equiv-id-pushout 𝒮 a₀ s)
-                  ( map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
-              ( map-b (right-map-span-diagram 𝒮 s) p)))
-      pr2 (pr2 (dep-cocone-a a)) (s , refl , p) = {!!}
-      map-a :
-        (a : domain-span-diagram 𝒮) (p : Path-to-a 𝒮 a₀ a (succ-ℕ n)) →
-        left-family-descent-data-pushout R
-          ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
-      map-a a = dependent-cogap _ _ (dep-cocone-a a)
+      pr2 (cocone-tBB b) n p = inv (compute-inl-dependent-cogap _ _ (cocone-tB b n) p)
 
-  ind-singleton-zigzag-id-pushout :
+      pr1 (cocone-tSS s) = alt-tS s
+      pr2 (cocone-tSS s) = {!!}
+
+  ind-singleton-zigzag-id-pushout' :
     {l5 : Level}
     (R :
       descent-data-pushout
@@ -561,31 +528,12 @@ module _
         ( l5))
     (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀)) →
     section-descent-data-pushout R
-  ind-singleton-zigzag-id-pushout R r₀ =
-    ind-Σ (λ a → dependent-cogap-standard-sequential-colimit (dep-cocone-a a)) ,
-    ind-Σ (λ b → dependent-cogap-standard-sequential-colimit (dep-cocone-b b)) ,
-    ind-Σ {!!}
-    where
-      dep-cocone-a :
-        ( a : domain-span-diagram 𝒮) →
-        dependent-cocone-sequential-diagram
-          ( cocone-standard-sequential-colimit
-            ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
-          ( λ p → left-family-descent-data-pushout R (a , p))
-      pr1 (dep-cocone-a a) n =
-        pr1 (pr2 (stage-map-ind-singleton-zigzag-id-pushout R r₀ n)) a
-      pr2 (dep-cocone-a a) n =
-        {!!}
-      dep-cocone-b :
-        (b : codomain-span-diagram 𝒮) →
-        dependent-cocone-sequential-diagram
-          ( cocone-standard-sequential-colimit
-            ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b))
-          ( λ p → right-family-descent-data-pushout R (b , p))
-      pr1 (dep-cocone-b b) n =
-        pr1 (stage-map-ind-singleton-zigzag-id-pushout R r₀ n) b
-      pr2 (dep-cocone-b b) n =
-        {!!}
+  pr1 (ind-singleton-zigzag-id-pushout' R r₀) (a , p) =
+    tAA R r₀ a p
+  pr1 (pr2 (ind-singleton-zigzag-id-pushout' R r₀)) (b , p) =
+    tBB R r₀ b p
+  pr2 (pr2 (ind-singleton-zigzag-id-pushout' R r₀)) (s , p) =
+    tSS R r₀ s p
 
   is-identity-system-zigzag-id-pushout :
     is-identity-system-descent-data-pushout
@@ -595,5 +543,5 @@ module _
     is-identity-system-descent-data-pushout-ind-singleton up-c
       ( descent-data-zigzag-id-pushout 𝒮 a₀)
       ( refl-id-pushout 𝒮 a₀)
-      ( ind-singleton-zigzag-id-pushout)
+      ( ind-singleton-zigzag-id-pushout')
 ```

From fb255de5ebfda2aa12350017be61c01c36eb4515 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Fri, 14 Jun 2024 17:09:39 +0200
Subject: [PATCH 04/33] Attempts at coherences

---
 ...nstruction-identity-type-pushouts.lagda.md | 115 ++++++++++++++++++
 1 file changed, 115 insertions(+)

diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index cc2fd5192b..dd19138ec9 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -69,6 +69,96 @@ TODO
 
 ### TODO
 
+```agda
+open import foundation.action-on-identifications-functions
+open import foundation.commuting-squares-of-maps
+open import synthetic-homotopy-theory.cocones-under-sequential-diagrams
+-- open import synthetic-homotopy-theory.dependent-universal-property-sequential-colimits
+open import synthetic-homotopy-theory.universal-property-sequential-colimits
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : sequential-diagram l1} {B : sequential-diagram l2}
+  {X : UU l3} {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {Y : UU l4} {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (z : zigzag-sequential-diagram A B)
+  (P : X → UU l5) (Q : Y → UU l6)
+  (e : (x : X) → P x ≃ Q (map-colimit-zigzag-sequential-diagram up-c up-c' z x))
+  where
+
+  private
+    CB :
+      (n : ℕ) →
+      coherence-square-maps
+        ( map-zigzag-sequential-diagram z n)
+        ( map-cocone-sequential-diagram c n)
+        ( map-cocone-sequential-diagram c' n)
+        ( map-colimit-zigzag-sequential-diagram up-c up-c' z)
+    CB =
+       htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+        ( up-c)
+        ( c')
+        ( hom-diagram-zigzag-sequential-diagram z)
+    dup-c : dependent-universal-property-sequential-colimit c
+    dup-c = dependent-universal-property-universal-property-sequential-colimit _ up-c
+    dup-c' : dependent-universal-property-sequential-colimit c'
+    dup-c' = dependent-universal-property-universal-property-sequential-colimit _ up-c'
+
+  tS-equiv-tS :
+    (tA : (n : ℕ) (a : family-sequential-diagram A n) → P (map-cocone-sequential-diagram c n a))
+    (HA :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      tr P (coherence-cocone-sequential-diagram c n a) (tA n a) ＝
+      tA (succ-ℕ n) (map-sequential-diagram A n a))
+    (tB : (n : ℕ) (b : family-sequential-diagram B n) → Q (map-cocone-sequential-diagram c' n b))
+    (HB :
+      (n : ℕ) (b : family-sequential-diagram B n) →
+      tr Q (coherence-cocone-sequential-diagram c' n b) (tB n b) ＝
+      tB (succ-ℕ n) (map-sequential-diagram B n b))
+    (n : ℕ) (a : family-sequential-diagram A n) →
+    ( ( map-equiv
+        ( e (map-cocone-sequential-diagram c n a))
+        ( map-dependent-universal-property-sequential-colimit dup-c
+          ( tA , HA)
+          ( map-cocone-sequential-diagram c n a))) ＝
+      map-dependent-universal-property-sequential-colimit dup-c'
+        ( tB , HB)
+        ( map-colimit-zigzag-sequential-diagram up-c up-c' z
+          ( map-cocone-sequential-diagram c n a))) ≃
+    ( ( tr Q
+        ( CB n a)
+        ( map-equiv (e (map-cocone-sequential-diagram c n a)) (tA n a))) ＝
+      ( tB n (map-zigzag-sequential-diagram z n a)))
+  tS-equiv-tS tA HA tB HB n a =
+    ( equiv-concat' _
+      ( pr1
+        ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+          ( dup-c')
+          ( tB , HB))
+        ( n)
+        ( map-zigzag-sequential-diagram z n a))) ∘e
+    ( equiv-concat' _
+      ( apd
+        ( map-dependent-universal-property-sequential-colimit dup-c' (tB , HB))
+        ( CB n a))) ∘e
+    ( equiv-ap
+      ( equiv-tr Q (CB n a))
+      ( _)
+      ( _)) ∘e
+    equiv-concat
+      ( ap
+        ( map-equiv (e (map-cocone-sequential-diagram c n a)))
+        ( inv
+          ( pr1
+            ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+              ( dup-c)
+              ( tA , HA))
+            ( n)
+            ( a))))
+      ( _)
+```
+
 ```agda
 module _
   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
@@ -519,6 +609,31 @@ module _
       pr1 (cocone-tSS s) = alt-tS s
       pr2 (cocone-tSS s) = {!!}
 
+    alt-tS-tS-equiv :
+      (s : spanning-type-span-diagram 𝒮) →
+      {!!}
+      -- (n : ℕ) →
+      -- (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+      -- {!!} ≃ {!!}
+    alt-tS-tS-equiv s =
+      tS-equiv-tS
+        ( up-standard-sequential-colimit)
+        ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+        ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
+        ( λ p → left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , p))
+        ( λ p → right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , p))
+        ( λ p → equiv-family-descent-data-pushout R (s , p))
+        ( tA (left-map-span-diagram 𝒮 s))
+        -- ( λ where
+        --   zero-ℕ (map-raise refl) → inv (compute-inl-dependent-cogap _ _ (cocone-tA (left-map-span-diagram 𝒮 s) 0) _ ∙ {!!})
+        --   (succ-ℕ n) a → {!!} )
+        ( λ n p →
+          inv
+            ( ( compute-inl-dependent-cogap _ _ (cocone-tA (left-map-span-diagram 𝒮 s) n) p) ∙
+              {!refl!}))
+        ( λ n → tB (right-map-span-diagram 𝒮 s) (succ-ℕ n))
+        ( {!!})
+
   ind-singleton-zigzag-id-pushout' :
     {l5 : Level}
     (R :

From 635fec9cdcda06007bb9a3ad3630fbe49851f0c6 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Fri, 21 Jun 2024 14:43:32 +0200
Subject: [PATCH 05/33] Progress

---
 ...nstruction-identity-type-pushouts.lagda.md | 247 ++++++++++++++----
 1 file changed, 203 insertions(+), 44 deletions(-)

diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index dd19138ec9..e870c3012d 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -21,7 +21,7 @@ open import foundation.equivalences
 open import foundation.function-types
 open import foundation.functoriality-dependent-pair-types
 -- open import foundation.fundamental-theorem-of-identity-types
--- open import foundation.homotopies
+open import foundation.homotopies
 -- open import foundation.identity-systems
 open import foundation.identity-types
 -- open import foundation.sections
@@ -29,11 +29,13 @@ open import foundation.identity-types
 open import foundation.raising-universe-levels
 open import foundation.span-diagrams
 open import foundation.transport-along-identifications
+open import foundation.transposition-identifications-along-equivalences
 -- open import foundation.torsorial-type-families
 -- open import foundation.transposition-identifications-along-equivalences
 -- open import foundation.universal-property-dependent-pair-types
 -- open import foundation.universal-property-identity-types
 open import foundation.universe-levels
+open import foundation.whiskering-homotopies-composition
 
 open import synthetic-homotopy-theory.cocones-under-spans
 -- open import synthetic-homotopy-theory.dependent-universal-property-pushouts
@@ -47,7 +49,7 @@ open import synthetic-homotopy-theory.functoriality-sequential-colimits
 open import synthetic-homotopy-theory.identity-systems-descent-data-pushouts
 -- open import synthetic-homotopy-theory.descent-property-pushouts
 -- open import synthetic-homotopy-theory.equivalences-descent-data-pushouts
--- open import synthetic-homotopy-theory.families-descent-data-pushouts
+open import synthetic-homotopy-theory.families-descent-data-pushouts
 open import synthetic-homotopy-theory.flattening-lemma-pushouts
 -- open import synthetic-homotopy-theory.morphisms-descent-data-pushouts
 open import synthetic-homotopy-theory.pushouts
@@ -184,8 +186,7 @@ module _
   stage-zigzag-construction-id-pushout zero-ℕ =
     Path-to-b ,
     Path-to-a ,
-    ( λ s → raise-ex-falso _) -- ,
-    -- ( λ s p → inr-pushout _ _ (s , refl , p))
+    ( λ s → raise-ex-falso _)
     where
     Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
     Path-to-b _ = raise-empty _
@@ -194,8 +195,7 @@ module _
   stage-zigzag-construction-id-pushout (succ-ℕ n) =
     Path-to-b ,
     Path-to-a ,
-    ( λ s p → inr-pushout _ _ (s , refl , p)) -- ,
-    -- ( λ s p → inr-pushout _ _ (s , refl , p))
+    ( λ s p → inr-pushout _ _ (s , refl , p))
     where
     span-diagram-B :
       codomain-span-diagram 𝒮 →
@@ -291,23 +291,21 @@ module _
   pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
     glue-pushout _ _ (s , refl , p)
 
---   -- zigzag-sequential-diagram-zigzag-id-pushout' :
---   --   (s : spanning-type-span-diagram 𝒮) →
---   --   zigzag-sequential-diagram
---   --     ( right-sequential-diagram-zigzag-id-pushout
---   --       ( right-map-span-diagram 𝒮 s))
---   --     ( left-sequential-diagram-zigzag-id-pushout
---   --       ( left-map-span-diagram 𝒮 s))
---   -- pr1 (zigzag-sequential-diagram-zigzag-id-pushout' s) n =
---   --   pr1 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
---   -- pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s)) n =
---   --   pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
---   -- pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s)))
---   --   zero-ℕ (map-raise ())
---   -- pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s))) (succ-ℕ n) p =
---   --   glue-pushout _ _ (s , refl , p)
---   -- pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s))) n p =
---   --   glue-pushout _ _ (s , refl , p)
+  zigzag-sequential-diagram-zigzag-id-pushout' :
+    (s : spanning-type-span-diagram 𝒮) →
+    zigzag-sequential-diagram
+      ( right-sequential-diagram-zigzag-id-pushout
+        ( right-map-span-diagram 𝒮 s))
+      ( left-sequential-diagram-zigzag-id-pushout
+        ( left-map-span-diagram 𝒮 s))
+  pr1 (zigzag-sequential-diagram-zigzag-id-pushout' s) =
+    concat-inv-s s
+  pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s)) =
+    concat-s s
+  pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s))) n p =
+    glue-pushout _ _ (s , refl , p)
+  pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s))) n p =
+    glue-pushout _ _ (s , refl , p)
 
   left-id-pushout : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
   left-id-pushout a =
@@ -331,6 +329,16 @@ module _
       ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
       ( zigzag-sequential-diagram-zigzag-id-pushout s)
 
+  equiv-id-pushout' :
+    (s : spanning-type-span-diagram 𝒮) →
+    right-id-pushout (right-map-span-diagram 𝒮 s) ≃
+    left-id-pushout (left-map-span-diagram 𝒮 s)
+  equiv-id-pushout' s =
+    equiv-colimit-zigzag-sequential-diagram _ _
+      ( up-standard-sequential-colimit)
+      ( up-standard-sequential-colimit)
+      ( zigzag-sequential-diagram-zigzag-id-pushout' s)
+
   concat-inv-s-inf :
     (s : spanning-type-span-diagram 𝒮) →
     right-id-pushout (right-map-span-diagram 𝒮 s) →
@@ -356,6 +364,19 @@ module _
 ### TODO
 
 ```agda
+nat-lemma :
+  {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
+  {P : A → UU l3} {Q : B → UU l4}
+  (f : A → B) (h : (a : A) → P a → Q (f a))
+  {x y : A} (p : x ＝ y)
+  (q : f x ＝ f y) (α : ap f p ＝ q) →
+  coherence-square-maps
+    ( tr P p)
+    ( h x)
+    ( h y)
+    ( tr Q q)
+nat-lemma f h p .(ap f p) refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
+
 module _
   {l1 l2 l3 l4 : Level} {𝒮 : span-diagram l1 l2 l3}
   {X : UU l4} {c : cocone-span-diagram 𝒮 X}
@@ -429,6 +450,28 @@ module _
           ( hom-diagram-zigzag-sequential-diagram
             ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
 
+      foo :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+        right-family-descent-data-pushout R
+          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
+        right-family-descent-data-pushout R
+          ( right-map-span-diagram 𝒮 s ,
+            concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+      foo s n p =
+        ( tr
+          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+          ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))) ∘
+        ( tr
+          ( λ p →
+            right-family-descent-data-pushout R
+              ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+          ( glue-pushout _ _ (s , refl , p))) ∘
+        ( tr
+          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
+
     interleaved mutual
       -- left section part tⁿ_A a
       tA :
@@ -531,26 +574,6 @@ module _
       tAA a = dependent-cogap-standard-sequential-colimit (cocone-tAA a)
       tBB b = dependent-cogap-standard-sequential-colimit (cocone-tBB b)
 
-      pr1 (cocone-tA a n) p =
-        tr
-          ( ev-pair (left-family-descent-data-pushout R) a)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tA a n p)
-      pr1 (pr2 (cocone-tA a n)) (s , refl , p) =
-        tr
-          ( ev-pair (left-family-descent-data-pushout R) a)
-          ( CA s n p)
-          ( inv-map-family-descent-data-pushout R
-            ( s , concat-inv-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-            ( tr
-              ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-              ( inv
-                ( is-section-map-inv-equiv
-                  ( equiv-id-pushout 𝒮 a₀ s)
-                  ( map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
-              ( tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p)))
-      pr2 (pr2 (cocone-tA a n)) (s , refl , p) = {!!}
-
       pr1 (cocone-tB b n) p =
         tr
           ( ev-pair (right-family-descent-data-pushout R) b)
@@ -563,7 +586,143 @@ module _
           ( map-family-descent-data-pushout R
             ( s , map-cocone-standard-sequential-colimit n p)
             ( tA (left-map-span-diagram 𝒮 s) n p))
-      pr2 (pr2 (cocone-tB b n)) (s , refl , p) = {!!}
+      pr2 (pr2 (cocone-tB ._ zero-ℕ)) (s , refl , map-raise ())
+      pr2 (pr2 (cocone-tB ._ (succ-ℕ n))) (s , refl , p) =
+        inv
+          ( ( ap
+              ( λ q →
+                tr
+                  ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+                  ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+                  ( map-family-descent-data-pushout R
+                    ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+                    ( q)))
+              ( compute-inr-dependent-cogap _ _
+                ( cocone-tA (left-map-span-diagram 𝒮 s) n)
+                ( s , refl , p))) ∙
+            ( ap
+              ( tr
+                ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+                ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+              -- Would typecheck if Agda were to expand vertical-map-dependent-cocone (cocone-tA)
+              ( {![i]!})) ∙
+            ( is-section-map-inv-equiv
+              ( equiv-tr
+                ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+                ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+              ( _)))
+        where
+          [i] :
+            map-family-descent-data-pushout R
+              ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+              ( inv-map-family-descent-data-pushout R
+                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+                ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))) ＝
+            foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p)
+          [i] =
+            is-section-map-inv-equiv
+              ( equiv-family-descent-data-pushout R
+                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+              ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))
+
+      pr1 (cocone-tA a n) p =
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tA a n p)
+      pr1 (pr2 (cocone-tA a n)) (s , refl , p) =
+        inv-map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+          ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))
+      pr2 (pr2 (cocone-tA a n)) (s , refl , p) =
+        [key]
+        where
+        [i] :
+          ( ( concat-s-inf 𝒮 a₀ s) ·l
+            ( coherence-cocone-standard-sequential-colimit n ∙h
+              map-cocone-standard-sequential-colimit (succ-ℕ n) ·l (λ p → glue-pushout _ _ (s , refl , p)))) ~
+          ( ( CB s n) ∙h
+            ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) ·r
+              ( concat-s 𝒮 a₀ s n))) ∙h
+            ( ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n))) ·l
+              (λ p → glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙h
+            ( {!CB s (succ-ℕ n) ·r ?!}))
+        [i] =
+          {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+            ( up-standard-sequential-colimit)
+            ( shift-once-cocone-sequential-diagram
+              ( cocone-standard-sequential-colimit
+                ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
+            ( hom-diagram-zigzag-sequential-diagram
+              ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+            ( n)!}
+        [key]'' :
+          tr
+            ( λ p →
+              left-family-descent-data-pushout R
+                ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+            ( glue-pushout _ _ (s , refl , p))
+            ( tr
+              ( ev-pair (left-family-descent-data-pushout R) (left-map-span-diagram 𝒮 s))
+              ( coherence-cocone-standard-sequential-colimit n p)
+              ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+          inv-map-family-descent-data-pushout R
+            ( s ,
+              map-cocone-standard-sequential-colimit
+                ( succ-ℕ n)
+                ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
+            ( ( ( tr
+                  ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+                  ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
+                ( tr
+                  ( λ p →
+                    right-family-descent-data-pushout R
+                      ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+                  ( glue-pushout _ _ (s , refl , (concat-s 𝒮 a₀ s n p)))) ∘
+                ( tr
+                  ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+                  ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))
+              ( tr
+                ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+                ( CB s n p)
+                ( map-family-descent-data-pushout R
+                  ( s , map-cocone-standard-sequential-colimit n p)
+                  ( tA (left-map-span-diagram 𝒮 s) n p))))
+        [key]'' = {!!}
+        [key]' :
+          tr
+            ( λ p →
+              left-family-descent-data-pushout R
+                ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+            ( glue-pushout _ _ (s , refl , p))
+            ( tr
+              ( ev-pair (left-family-descent-data-pushout R) (left-map-span-diagram 𝒮 s))
+              ( coherence-cocone-standard-sequential-colimit n p)
+              ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+          inv-map-family-descent-data-pushout R
+            ( s ,
+              map-cocone-standard-sequential-colimit
+                ( succ-ℕ n)
+                ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
+            ( foo s n (concat-s 𝒮 a₀ s n p) (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
+        [key]' = {!!}
+        [key] :
+          tr
+            ( λ p →
+              left-family-descent-data-pushout R
+                ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+            ( glue-pushout _ _ (s , refl , p))
+            ( pr1 (cocone-tA (left-map-span-diagram 𝒮 s) n) p) ＝
+          (pr1 (pr2 (cocone-tA (left-map-span-diagram 𝒮 s) n)) (s , refl , concat-s 𝒮 a₀ s n p))
+        [key] = {!!}
+          --         htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+          -- ( up-standard-sequential-colimit)
+          -- ( shift-once-cocone-sequential-diagram
+          --   ( cocone-standard-sequential-colimit
+          --     ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
+          -- ( hom-diagram-zigzag-sequential-diagram
+          --   ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+
 
       tS s n p =
         inv

From df0caf35ddd09cd6a6157a0cf9fb6bda4baca689 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Mon, 24 Jun 2024 00:21:35 +0200
Subject: [PATCH 06/33] Some more real progress

---
 .../pushouts.lagda.md                         |    6 +
 ...nstruction-identity-type-pushouts.lagda.md | 1263 ++++++++++++-----
 2 files changed, 888 insertions(+), 381 deletions(-)

diff --git a/src/synthetic-homotopy-theory/pushouts.lagda.md b/src/synthetic-homotopy-theory/pushouts.lagda.md
index 768276d97f..7c98487510 100644
--- a/src/synthetic-homotopy-theory/pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/pushouts.lagda.md
@@ -150,6 +150,12 @@ module _
       ( inl-standard-pushout)
   glue-standard-pushout =
     glue-pushout (left-map-span-diagram 𝒮) (right-map-span-diagram 𝒮)
+
+  cocone-pushout-span-diagram :
+    cocone-span-diagram 𝒮 standard-pushout
+  pr1 cocone-pushout-span-diagram = inl-standard-pushout
+  pr1 (pr2 cocone-pushout-span-diagram) = inr-standard-pushout
+  pr2 (pr2 cocone-pushout-span-diagram) = glue-standard-pushout
 ```
 
 ### The dependent cogap map
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index e870c3012d..d2b76f555d 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -1,7 +1,7 @@
 # The zigzag construction of identity types of pushouts
 
 ```agda
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
 
 module synthetic-homotopy-theory.zigzag-construction-identity-type-pushouts where
 ```
@@ -15,6 +15,7 @@ open import elementary-number-theory.natural-numbers
 -- open import foundation.contractible-types
 open import foundation.action-on-identifications-dependent-functions
 open import foundation.cartesian-product-types
+open import foundation.dependent-identifications
 open import foundation.dependent-pair-types
 open import foundation.empty-types
 open import foundation.equivalences
@@ -22,6 +23,7 @@ open import foundation.function-types
 open import foundation.functoriality-dependent-pair-types
 -- open import foundation.fundamental-theorem-of-identity-types
 open import foundation.homotopies
+open import foundation.homotopy-algebra
 -- open import foundation.identity-systems
 open import foundation.identity-types
 -- open import foundation.sections
@@ -34,7 +36,9 @@ open import foundation.transposition-identifications-along-equivalences
 -- open import foundation.transposition-identifications-along-equivalences
 -- open import foundation.universal-property-dependent-pair-types
 -- open import foundation.universal-property-identity-types
+open import foundation.unit-type
 open import foundation.universe-levels
+open import foundation.whiskering-higher-homotopies-composition
 open import foundation.whiskering-homotopies-composition
 
 open import synthetic-homotopy-theory.cocones-under-spans
@@ -166,15 +170,30 @@ module _
   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
   where
 
-  type-stage-zigzag-construction-id-pushout : UU (lsuc (l1 ⊔ l2 ⊔ l3))
-  type-stage-zigzag-construction-id-pushout =
+  type-stage-zigzag-construction-id-pushout : ℕ → UU (lsuc (l1 ⊔ l2 ⊔ l3))
+  type-stage-zigzag-construction-id-pushout n =
     Σ ( codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
       ( λ Path-to-b →
         Σ ( domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
           ( λ Path-to-a →
-            ( (s : spanning-type-span-diagram 𝒮) →
-              Path-to-b (right-map-span-diagram 𝒮 s) →
-              Path-to-a (left-map-span-diagram 𝒮 s))))
+            ( Σ ( (s : spanning-type-span-diagram 𝒮) →
+                  Path-to-b (right-map-span-diagram 𝒮 s) →
+                  Path-to-a (left-map-span-diagram 𝒮 s))
+                ( λ _ →
+                  rec-ℕ
+                    ( raise-unit (lsuc (l1 ⊔ l2 ⊔ l3)))
+                    ( λ _ _ →
+                      ( codomain-span-diagram 𝒮 →
+                        span-diagram
+                          ( l1 ⊔ l2 ⊔ l3)
+                          ( l1 ⊔ l2 ⊔ l3)
+                          ( l1 ⊔ l2 ⊔ l3)) ×
+                      ( domain-span-diagram 𝒮 →
+                        span-diagram
+                          ( l1 ⊔ l2 ⊔ l3)
+                          ( l1 ⊔ l2 ⊔ l3)
+                          ( l1 ⊔ l2 ⊔ l3)))
+                    ( n)))))
 
 module _
   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
@@ -182,11 +201,12 @@ module _
   where
 
   stage-zigzag-construction-id-pushout :
-    ℕ → type-stage-zigzag-construction-id-pushout 𝒮
+    (n : ℕ) → type-stage-zigzag-construction-id-pushout 𝒮 n
   stage-zigzag-construction-id-pushout zero-ℕ =
     Path-to-b ,
     Path-to-a ,
-    ( λ s → raise-ex-falso _)
+    ( λ s → raise-ex-falso _) ,
+    raise-star
     where
     Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
     Path-to-b _ = raise-empty _
@@ -195,7 +215,9 @@ module _
   stage-zigzag-construction-id-pushout (succ-ℕ n) =
     Path-to-b ,
     Path-to-a ,
-    ( λ s p → inr-pushout _ _ (s , refl , p))
+    ( λ s p → inr-pushout _ _ (s , refl , p)) ,
+    span-diagram-B ,
+    span-diagram-A
     where
     span-diagram-B :
       codomain-span-diagram 𝒮 →
@@ -207,8 +229,8 @@ module _
           ( λ s →
             tot
               ( λ r (p : pr1 (stage-zigzag-construction-id-pushout n) b) →
-                pr2
-                  ( pr2 (stage-zigzag-construction-id-pushout n))
+                pr1
+                  ( pr2 (pr2 (stage-zigzag-construction-id-pushout n)))
                   ( s)
                   ( tr (pr1 (stage-zigzag-construction-id-pushout n)) r p))))
     Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
@@ -228,12 +250,30 @@ module _
                   ( ( s) ,
                     ( refl) ,
                     ( tr
-                      (pr1 (pr2 (stage-zigzag-construction-id-pushout n)))
+                      ( pr1 (pr2 (stage-zigzag-construction-id-pushout n)))
                       ( r)
                       ( p))))))
     Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
     Path-to-a a = standard-pushout (span-diagram-A a)
 
+  span-diagram-path-to-b :
+    codomain-span-diagram 𝒮 → ℕ →
+    span-diagram
+      ( l1 ⊔ l2 ⊔ l3)
+      ( l1 ⊔ l2 ⊔ l3)
+      ( l1 ⊔ l2 ⊔ l3)
+  span-diagram-path-to-b b n =
+    pr1 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) b
+
+  span-diagram-path-to-a :
+    domain-span-diagram 𝒮 → ℕ →
+    span-diagram
+      ( l1 ⊔ l2 ⊔ l3)
+      ( l1 ⊔ l2 ⊔ l3)
+      ( l1 ⊔ l2 ⊔ l3)
+  span-diagram-path-to-a a n =
+    pr2 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) a
+
   Path-to-b : codomain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
   Path-to-b b n = pr1 (stage-zigzag-construction-id-pushout n) b
 
@@ -242,25 +282,32 @@ module _
 
   inl-Path-to-b :
     (b : codomain-span-diagram 𝒮) (n : ℕ) → Path-to-b b n → Path-to-b b (succ-ℕ n)
-  inl-Path-to-b b n = inl-pushout _ _
+  inl-Path-to-b b n =
+    inl-standard-pushout
+      ( span-diagram-path-to-b b n)
 
   inl-Path-to-a :
     (a : domain-span-diagram 𝒮) (n : ℕ) → Path-to-a a n → Path-to-a a (succ-ℕ n)
-  inl-Path-to-a a n = inl-pushout _ _
+  inl-Path-to-a a n =
+    inl-standard-pushout
+      ( span-diagram-path-to-a a n)
 
   concat-inv-s :
     (s : spanning-type-span-diagram 𝒮) →
     (n : ℕ) →
     Path-to-b (right-map-span-diagram 𝒮 s) n →
     Path-to-a (left-map-span-diagram 𝒮 s) n
-  concat-inv-s s n = pr2 (pr2 (stage-zigzag-construction-id-pushout n)) s
+  concat-inv-s s n = pr1 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
 
   concat-s :
     (s : spanning-type-span-diagram 𝒮) →
     (n : ℕ) →
     Path-to-a (left-map-span-diagram 𝒮 s) n →
     Path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n)
-  concat-s s n p = inr-pushout _ _ (s , refl , p)
+  concat-s s n p =
+    inr-standard-pushout
+      ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) n)
+      ( s , refl , p)
 
   right-sequential-diagram-zigzag-id-pushout :
     codomain-span-diagram 𝒮 →
@@ -287,25 +334,13 @@ module _
   pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s)) n =
     concat-inv-s s (succ-ℕ n)
   pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
-    glue-pushout _ _ (s , refl , p)
+    glue-standard-pushout
+      ( span-diagram-path-to-a (left-map-span-diagram 𝒮 s) n)
+      ( s , refl , p)
   pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
-    glue-pushout _ _ (s , refl , p)
-
-  zigzag-sequential-diagram-zigzag-id-pushout' :
-    (s : spanning-type-span-diagram 𝒮) →
-    zigzag-sequential-diagram
-      ( right-sequential-diagram-zigzag-id-pushout
-        ( right-map-span-diagram 𝒮 s))
-      ( left-sequential-diagram-zigzag-id-pushout
-        ( left-map-span-diagram 𝒮 s))
-  pr1 (zigzag-sequential-diagram-zigzag-id-pushout' s) =
-    concat-inv-s s
-  pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s)) =
-    concat-s s
-  pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s))) n p =
-    glue-pushout _ _ (s , refl , p)
-  pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout' s))) n p =
-    glue-pushout _ _ (s , refl , p)
+    glue-standard-pushout
+      ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n))
+      ( s , refl , p)
 
   left-id-pushout : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
   left-id-pushout a =
@@ -329,16 +364,6 @@ module _
       ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
       ( zigzag-sequential-diagram-zigzag-id-pushout s)
 
-  equiv-id-pushout' :
-    (s : spanning-type-span-diagram 𝒮) →
-    right-id-pushout (right-map-span-diagram 𝒮 s) ≃
-    left-id-pushout (left-map-span-diagram 𝒮 s)
-  equiv-id-pushout' s =
-    equiv-colimit-zigzag-sequential-diagram _ _
-      ( up-standard-sequential-colimit)
-      ( up-standard-sequential-colimit)
-      ( zigzag-sequential-diagram-zigzag-id-pushout' s)
-
   concat-inv-s-inf :
     (s : spanning-type-span-diagram 𝒮) →
     right-id-pushout (right-map-span-diagram 𝒮 s) →
@@ -368,14 +393,14 @@ nat-lemma :
   {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
   {P : A → UU l3} {Q : B → UU l4}
   (f : A → B) (h : (a : A) → P a → Q (f a))
-  {x y : A} (p : x ＝ y)
-  (q : f x ＝ f y) (α : ap f p ＝ q) →
+  {x y : A} {p : x ＝ y}
+  {q : f x ＝ f y} (α : ap f p ＝ q) →
   coherence-square-maps
     ( tr P p)
     ( h x)
     ( h y)
     ( tr Q q)
-nat-lemma f h p .(ap f p) refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
+nat-lemma f h {p = p} refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
 
 module _
   {l1 l2 l3 l4 : Level} {𝒮 : span-diagram l1 l2 l3}
@@ -384,28 +409,6 @@ module _
   (a₀ : domain-span-diagram 𝒮)
   where
 
-  type-stage-ind-singleton-zigzag-id-pushout :
-    {l5 : Level}
-    (R : descent-data-pushout
-      ( span-diagram-flattening-descent-data-pushout
-        ( descent-data-zigzag-id-pushout 𝒮 a₀))
-      ( l5))
-    (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀)) →
-    UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
-  type-stage-ind-singleton-zigzag-id-pushout R r₀ =
-    Σ ( (a : domain-span-diagram 𝒮) →
-        dependent-cocone-sequential-diagram
-          ( cocone-standard-sequential-colimit
-            ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
-          ( λ p → left-family-descent-data-pushout R (a , p)))
-      ( λ dep-cocone-left →
-        (b : codomain-span-diagram 𝒮) →
-        dependent-cocone-sequential-diagram
-          ( shift-once-cocone-sequential-diagram
-            ( cocone-standard-sequential-colimit
-              ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b)))
-          ( λ p → right-family-descent-data-pushout R (b , p)))
-
   module _
     {l5 : Level}
     (R : descent-data-pushout
@@ -415,24 +418,36 @@ module _
     (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
     where
 
-    private
-      CA :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
-        concat-inv-s-inf 𝒮 a₀ s
-          ( map-cocone-standard-sequential-colimit (succ-ℕ n) p) ＝
-        map-cocone-standard-sequential-colimit (succ-ℕ n)
-          ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)
-      CA s =
-        htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-          ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
-          ( shift-once-cocone-sequential-diagram
-            ( cocone-standard-sequential-colimit
-              ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s))))
-          ( inv-hom-diagram-zigzag-sequential-diagram
-            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+    -- type-stage-ind-singleton-zigzag-id-pushout : ℕ → UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
+    -- type-stage-ind-singleton-zigzag-id-pushout n =
+    --   Σ ( (b : codomain-span-diagram 𝒮) (p : Path-to-b 𝒮 a₀ b n) →
+    --       right-family-descent-data-pushout R
+    --         ( b , map-cocone-standard-sequential-colimit n p))
+    --     ( λ tB →
+    --       Σ ( (a : domain-span-diagram 𝒮) (p : Path-to-a 𝒮 a₀ a n) →
+    --           left-family-descent-data-pushout R
+    --             ( a , map-cocone-standard-sequential-colimit n p))
+    --         ( λ tA →
+    --           rec-ℕ
+    --             ( raise-unit (l1 ⊔ l2 ⊔ l3 ⊔ l5))
+    --             ( λ n' _ →
+    --               ( (b : codomain-span-diagram 𝒮) →
+    --                 dependent-cocone-span-diagram
+    --                   ( cocone-pushout-span-diagram
+    --                     ( span-diagram-path-to-b 𝒮 a₀ b n'))
+    --                   ( λ p →
+    --                     right-family-descent-data-pushout R
+    --                       ( b , map-cocone-standard-sequential-colimit (succ-ℕ n') p))) ×
+    --               ( (a : domain-span-diagram 𝒮) →
+    --                 dependent-cocone-span-diagram
+    --                   ( cocone-pushout-span-diagram
+    --                     ( span-diagram-path-to-a 𝒮 a₀ a n'))
+    --                   ( λ p →
+    --                     left-family-descent-data-pushout R
+    --                       ( a , map-cocone-standard-sequential-colimit (succ-ℕ n') p))))
+    --             ( n)))
 
+    private
       CB :
         (s : spanning-type-span-diagram 𝒮) →
         (n : ℕ) →
@@ -472,342 +487,828 @@ module _
           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
 
-    interleaved mutual
-      -- left section part tⁿ_A a
-      tA :
-        (a : domain-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-a 𝒮 a₀ a n) →
-        left-family-descent-data-pushout R
-          ( a , map-cocone-standard-sequential-colimit n p)
-      -- definition of tⁿ⁺¹_A a (pattern matching on Pⁿ⁺¹_A a)
-      cocone-tA :
-        (a : domain-span-diagram 𝒮) →
-        (n : ℕ) →
-        dependent-cocone-span-diagram
-          ( cocone-pushout _ _)
-          ( λ p →
-            left-family-descent-data-pushout R
-              ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-      -- right section part tⁿ_B b
-      tB :
-        (b : codomain-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-b 𝒮 a₀ b n) →
-        right-family-descent-data-pushout R
-          ( b , map-cocone-standard-sequential-colimit n p)
-      -- definition of tⁿ⁺¹_B b (pattern matching on Pⁿ⁺¹_B b)
-      cocone-tB :
+    coh-dep-cocone-a :
+      (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+      coherence-square-maps
+        ( ( tr
+            ( λ p →
+              left-family-descent-data-pushout R
+                ( left-map-span-diagram 𝒮 s ,
+                  map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+            ( glue-pushout _ _ (s , refl , p))) ∘
+          ( tr
+            ( ev-pair
+              ( left-family-descent-data-pushout R)
+              ( left-map-span-diagram 𝒮 s))
+            ( coherence-cocone-standard-sequential-colimit n p)))
+        ( map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p))
+        ( map-family-descent-data-pushout R
+          ( s ,
+            map-cocone-standard-sequential-colimit (succ-ℕ n)
+              ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
+        ( ( tr
+            ( ev-pair
+              ( right-family-descent-data-pushout R)
+              ( right-map-span-diagram 𝒮 s))
+            ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
+          ( tr
+            ( λ p →
+              right-family-descent-data-pushout R
+                ( right-map-span-diagram 𝒮 s ,
+                  map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+            ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
+          ( tr
+            ( ev-pair
+              ( right-family-descent-data-pushout R)
+              ( right-map-span-diagram 𝒮 s))
+            ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))) ∘
+          ( tr
+            ( ev-pair
+              ( right-family-descent-data-pushout R)
+              ( right-map-span-diagram 𝒮 s))
+            ( CB s n p)))
+    coh-dep-cocone-a s n p =
+      ( ( inv-htpy
+          ( ( tr-concat _ _) ∙h
+            ( ( tr _ _) ·l
+              ( ( tr-concat _ _) ∙h
+                ( horizontal-concat-htpy
+                  ( λ _ → substitution-law-tr _ _ _)
+                  ( tr-concat _ _)))))) ·r
+        ( map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p))) ∙h
+      ( [ii]) ∙h
+      ( ( map-family-descent-data-pushout R
+          ( s ,
+            map-cocone-standard-sequential-colimit
+              ( succ-ℕ n)
+              ( concat-inv-s 𝒮 a₀ s
+                ( succ-ℕ n)
+                ( concat-s 𝒮 a₀ s n p)))) ·l
+        ( ( tr-concat _ _) ∙h
+          ( λ q → substitution-law-tr _ _ _)))
+      where
+      [0] :
+        ( ( ( concat-s-inf 𝒮 a₀ s) ·l
+            ( coherence-cocone-standard-sequential-colimit n)) ∙h
+          ( ( CB s (succ-ℕ n)) ·r
+            ( inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n))) ~
+        ( ( CB s n) ∙h
+          ( ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
+              ( concat-s 𝒮 a₀ s n)) ∙h
+            ( ( map-cocone-standard-sequential-colimit
+                { A =
+                  right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                    ( right-map-span-diagram 𝒮 s)}
+                ( succ-ℕ (succ-ℕ n))) ·l
+              pr2
+               (hom-diagram-zigzag-sequential-diagram
+                (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+               n)))
+      [0] =
+        coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+          ( up-standard-sequential-colimit)
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit
+              ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
+          ( hom-diagram-zigzag-sequential-diagram
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+          ( n)
+      [0]' :
+        (
+            (concat-s-inf 𝒮 a₀ s ·l
+             coherence-cocone-standard-sequential-colimit n
+             ∙h
+             CB s (succ-ℕ n) ·r
+             inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) ∙h
+             (map-cocone-standard-sequential-colimit {A = right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s) } (succ-ℕ (succ-ℕ n)) ·l
+              (
+                pr1 (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
+                  (succ-ℕ n)
+                  ·l
+                  (pr1
+                  (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)))
+                  n)
+                )
+            ))
+         ~
+          (CB s n ∙h
+             (
+                coherence-cocone-standard-sequential-colimit (succ-ℕ n) ·r
+                 concat-s 𝒮 a₀ s n
+                 ∙h
+                (map-cocone-standard-sequential-colimit {A = right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s) } (succ-ℕ (succ-ℕ n)) ·l
+                     (λ x₃ →
+                        glue-pushout
+                        _
+                        _
+                        (s ,
+                         refl ,
+                         pr1 (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s) n x₃))))
+                     )
+
+      [0]' =
+        ( ap-concat-htpy _
+          ( ?)) ∙h
+        ( map-inv-equiv
+          ( equiv-right-transpose-htpy-concat _ _ _)
+          ( ( [0]) ∙h
+            ( ap-concat-htpy
+              ( CB s n)
+              ( ( ap-concat-htpy
+                  ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) ·r concat-s 𝒮 a₀ s n)
+                  ( ( distributive-left-whisker-comp-concat
+                      ( map-cocone-standard-sequential-colimit
+                        {A = right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s)}
+                        ( succ-ℕ (succ-ℕ n)))
+                      ( _)
+                      ( _)) ∙h
+                    ( ap-concat-htpy _
+                      ( ( left-whisker-comp² _ (left-whisker-inv-htpy _ _)) ∙h
+                        ( left-whisker-inv-htpy _ _))))) ∙h
+                ( inv-htpy-assoc-htpy _ _ _))) ∙h
+            ( inv-htpy-assoc-htpy _ _ _)))
+      [i] :
+        ( ( concat-s-inf 𝒮 a₀ s) ·l
+          ( coherence-cocone-standard-sequential-colimit n ∙h
+            map-cocone-standard-sequential-colimit (succ-ℕ n) ·l (λ p → glue-pushout _ _ (s , refl , p)))) ~
+        ( ( CB s n) ∙h
+          ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
+            ( concat-s 𝒮 a₀ s n)) ∙h
+          ( ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n))) ·l
+            ( λ p → glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙h
+          ( inv-htpy (CB s (succ-ℕ n)) ·r (concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
+      [i] =
+        distributive-left-whisker-comp-concat _ _ _ ∙h
+        {!!}
+      -- square with condensed top and bottom
+      [ii] :
+        coherence-square-maps
+          ( tr
+            ( ev-pair
+              ( left-family-descent-data-pushout R)
+              ( left-map-span-diagram 𝒮 s))
+            ( ( coherence-cocone-standard-sequential-colimit n p) ∙
+              ( ap
+                ( map-cocone-standard-sequential-colimit (succ-ℕ n))
+                ( glue-pushout _ _ (s , refl , p)))))
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit n p))
+          ( map-family-descent-data-pushout R
+            ( s ,
+              map-cocone-standard-sequential-colimit (succ-ℕ n)
+                ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
+          ( tr
+            ( ev-pair
+              ( right-family-descent-data-pushout R)
+              ( right-map-span-diagram 𝒮 s))
+            ( ( CB s n p) ∙
+              ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p)) ∙
+              ( ap
+                ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)))
+                ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙
+              ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))))
+      [ii] =
+        nat-lemma
+          ( concat-s-inf 𝒮 a₀ s)
+          ( ev-pair (map-family-descent-data-pushout R) s)
+          ( [i] p)
+
+
+    -- TODO: Explore omitting vertical-map-dependent-cocone
+    stages-cocones' :
+      (n : ℕ) →
+      Σ ( (b : codomain-span-diagram 𝒮) →
+          dependent-cocone-span-diagram
+            ( cocone-pushout-span-diagram
+              ( span-diagram-path-to-b 𝒮 a₀ b n))
+            ( λ p →
+              right-family-descent-data-pushout R
+                ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
+        ( λ dep-cocone-b →
+          Σ ( (a : domain-span-diagram 𝒮) →
+              dependent-cocone-span-diagram
+                ( cocone-pushout-span-diagram
+                  ( span-diagram-path-to-a 𝒮 a₀ a n))
+                ( λ p →
+                  left-family-descent-data-pushout R
+                    ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
+            ( λ dep-cocone-a →
+              (s : spanning-type-span-diagram 𝒮) →
+              (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+              vertical-map-dependent-cocone _ _ _ _
+                ( dep-cocone-a (left-map-span-diagram 𝒮 s))
+                ( s , refl , p) ＝
+              inv-map-family-descent-data-pushout R
+                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+                ( foo s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))))
+    stages-cocones' zero-ℕ =
+      dep-cocone-b ,
+      dep-cocone-a ,
+      λ s p → refl
+      where
+      dep-cocone-b :
         (b : codomain-span-diagram 𝒮) →
-        (n : ℕ) →
         dependent-cocone-span-diagram
-          ( cocone-pushout _ _)
+          ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b 0))
           ( λ p →
             right-family-descent-data-pushout R
-              ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-      -- section coherence part tⁿ_S
-      tS :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+              ( b , map-cocone-standard-sequential-colimit 1 p))
+      pr1 (dep-cocone-b b) (map-raise ())
+      pr1 (pr2 (dep-cocone-b ._)) (s , refl , map-raise refl) =
         tr
-          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-          ( CB s n p)
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( CB s 0 (map-raise refl))
           ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit n p)
-            ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
-        tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
-      -- left section t_A a
-      tAA :
+            ( s , map-cocone-standard-sequential-colimit 0 (map-raise refl))
+            ( r₀))
+      pr2 (pr2 (dep-cocone-b ._)) (s , refl , map-raise ())
+      dep-cocone-a :
         (a : domain-span-diagram 𝒮) →
-        (p : left-id-pushout 𝒮 a₀ a) →
-        left-family-descent-data-pushout R (a , p)
-      -- definition of t_A a (pattern matching on Pᵒᵒ_A a)
-      cocone-tAA :
-        (a : domain-span-diagram 𝒮) →
-        dependent-cocone-sequential-diagram
-          ( cocone-standard-sequential-colimit
-            ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
-          ( λ p → left-family-descent-data-pushout R (a , p))
-      -- right section t_B b
-      tBB :
-        (b : codomain-span-diagram 𝒮) →
-        (p : right-id-pushout 𝒮 a₀ b) →
-        right-family-descent-data-pushout R (b , p)
-      -- definition of t_B b (pattern matching on Pᵒᵒ_B b)
-      cocone-tBB :
+        dependent-cocone-span-diagram
+          ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a 0))
+          ( λ p →
+            left-family-descent-data-pushout R
+              ( a , map-cocone-standard-sequential-colimit 1 p))
+      pr1 (dep-cocone-a .a₀) (map-raise refl) =
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a₀)
+          ( coherence-cocone-standard-sequential-colimit 0 (map-raise refl))
+          ( r₀)
+      pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
+        inv-map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit 1 (concat-inv-s 𝒮 a₀ s 1 p))
+          ( foo s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
+      pr2 (pr2 (dep-cocone-a .a₀)) (s , refl , map-raise refl) =
+        map-eq-transpose-equiv
+          ( equiv-family-descent-data-pushout R
+            ( s ,
+              map-cocone-standard-sequential-colimit 1
+                ( concat-inv-s 𝒮 a₀ s 1 (concat-s 𝒮 a₀ s 0 (map-raise refl)))))
+          ( inv
+            ( ( ap
+                ( foo s 0 (concat-s 𝒮 a₀ s 0 (map-raise refl)))
+                ( compute-inr-dependent-cogap _ _
+                  ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+                  (s , refl , map-raise refl))) ∙
+              ( coh-dep-cocone-a s 0 (map-raise refl) r₀)))
+    stages-cocones' (succ-ℕ n) =
+      dep-cocone-b ,
+      dep-cocone-a ,
+      λ s p → refl
+      where
+      dep-cocone-b :
         (b : codomain-span-diagram 𝒮) →
-        dependent-cocone-sequential-diagram
-          ( cocone-standard-sequential-colimit
-            ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b))
-          ( λ p → right-family-descent-data-pushout R (b , p))
-      -- section coherence t_S s
-      tSS :
-        (s : spanning-type-span-diagram 𝒮) →
-        (p : left-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s)) →
-        map-family-descent-data-pushout R
-          ( s , p)
-          ( tAA (left-map-span-diagram 𝒮 s) p) ＝
-        tBB
-          ( right-map-span-diagram 𝒮 s)
-          ( concat-s-inf 𝒮 a₀ s p)
-      -- definition of t_S s (pattern matching on Pᵒᵒ_A a)
-      cocone-tSS :
-        (s : spanning-type-span-diagram 𝒮) →
-        dependent-cocone-sequential-diagram
-          ( cocone-standard-sequential-colimit
-            ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-              ( left-map-span-diagram 𝒮 s)))
+        dependent-cocone-span-diagram
+          ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b (succ-ℕ n)))
           ( λ p →
-            map-family-descent-data-pushout R
-              ( s , p)
-              ( tAA (left-map-span-diagram 𝒮 s) p) ＝
-            tBB (right-map-span-diagram 𝒮 s) (concat-s-inf 𝒮 a₀ s p))
-
-      tA a zero-ℕ (map-raise refl) = r₀
-      -- tA (n+1) needs coconeA n, which needs tA n and tB (n+1),
-      -- which needs coconeB n, which only needs tB n and tA n,
-      -- so it terminates
-      tA a (succ-ℕ n) = dependent-cogap _ _ (cocone-tA a n)
-      tB b zero-ℕ (map-raise ())
-      tB b (succ-ℕ n) = dependent-cogap _ _ (cocone-tB b n)
-      tAA a = dependent-cogap-standard-sequential-colimit (cocone-tAA a)
-      tBB b = dependent-cogap-standard-sequential-colimit (cocone-tBB b)
-
-      pr1 (cocone-tB b n) p =
+            right-family-descent-data-pushout R
+              ( b , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+      pr1 (dep-cocone-b b) p =
         tr
           ( ev-pair (right-family-descent-data-pushout R) b)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tB b n p)
-      pr1 (pr2 (cocone-tB b n)) (s , refl , p) =
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
+          ( dependent-cogap _ _ (pr1 (stages-cocones' n) b) p)
+      pr1 (pr2 (dep-cocone-b b)) (s , refl , p) =
         tr
-          ( ev-pair (right-family-descent-data-pushout R) b)
-          ( CB s n p)
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( CB s (succ-ℕ n) p)
           ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit n p)
-            ( tA (left-map-span-diagram 𝒮 s) n p))
-      pr2 (pr2 (cocone-tB ._ zero-ℕ)) (s , refl , map-raise ())
-      pr2 (pr2 (cocone-tB ._ (succ-ℕ n))) (s , refl , p) =
+            ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
+            ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))
+      pr2 (pr2 (dep-cocone-b b)) (s , refl , p) =
         inv
           ( ( ap
               ( λ q →
                 tr
-                  ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+                  ( ev-pair
+                    ( right-family-descent-data-pushout R)
+                    ( right-map-span-diagram 𝒮 s))
                   ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
                   ( map-family-descent-data-pushout R
-                    ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+                    ( s ,
+                      ( map-cocone-standard-sequential-colimit
+                        ( succ-ℕ n)
+                        ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
                     ( q)))
-              ( compute-inr-dependent-cogap _ _
-                ( cocone-tA (left-map-span-diagram 𝒮 s) n)
-                ( s , refl , p))) ∙
+              ( ( compute-inr-dependent-cogap _ _
+                  ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
+                  ( s , refl , p)) ∙
+                ( pr2 (pr2 (stages-cocones' n)) s p))) ∙
             ( ap
               ( tr
-                ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+                ( ev-pair
+                  ( right-family-descent-data-pushout R)
+                  ( right-map-span-diagram 𝒮 s))
                 ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-              -- Would typecheck if Agda were to expand vertical-map-dependent-cocone (cocone-tA)
-              ( {![i]!})) ∙
+              ( is-section-map-inv-equiv
+                ( equiv-family-descent-data-pushout R
+                  ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+                ( foo s n p (dependent-cogap _ _
+                  ( pr1 (stages-cocones' n) (right-map-span-diagram 𝒮 s)) p)))) ∙
             ( is-section-map-inv-equiv
               ( equiv-tr
                 ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
                 ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
               ( _)))
-        where
-          [i] :
-            map-family-descent-data-pushout R
-              ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-              ( inv-map-family-descent-data-pushout R
-                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-                ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))) ＝
-            foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p)
-          [i] =
-            is-section-map-inv-equiv
-              ( equiv-family-descent-data-pushout R
-                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-              ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))
-
-      pr1 (cocone-tA a n) p =
+      dep-cocone-a :
+        (a : domain-span-diagram 𝒮) →
+        dependent-cocone-span-diagram
+          ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a (succ-ℕ n)))
+          ( λ p →
+            left-family-descent-data-pushout R
+              ( a , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+      pr1 (dep-cocone-a a) p =
         tr
           ( ev-pair (left-family-descent-data-pushout R) a)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tA a n p)
-      pr1 (pr2 (cocone-tA a n)) (s , refl , p) =
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
+          ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a) p)
+      pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
         inv-map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-          ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))
-      pr2 (pr2 (cocone-tA a n)) (s , refl , p) =
-        [key]
-        where
-        [i] :
-          ( ( concat-s-inf 𝒮 a₀ s) ·l
-            ( coherence-cocone-standard-sequential-colimit n ∙h
-              map-cocone-standard-sequential-colimit (succ-ℕ n) ·l (λ p → glue-pushout _ _ (s , refl , p)))) ~
-          ( ( CB s n) ∙h
-            ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) ·r
-              ( concat-s 𝒮 a₀ s n))) ∙h
-            ( ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n))) ·l
-              (λ p → glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙h
-            ( {!CB s (succ-ℕ n) ·r ?!}))
-        [i] =
-          {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-            ( up-standard-sequential-colimit)
-            ( shift-once-cocone-sequential-diagram
-              ( cocone-standard-sequential-colimit
-                ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
-            ( hom-diagram-zigzag-sequential-diagram
-              ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-            ( n)!}
-        [key]'' :
-          tr
-            ( λ p →
-              left-family-descent-data-pushout R
-                ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-            ( glue-pushout _ _ (s , refl , p))
-            ( tr
-              ( ev-pair (left-family-descent-data-pushout R) (left-map-span-diagram 𝒮 s))
-              ( coherence-cocone-standard-sequential-colimit n p)
-              ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
-          inv-map-family-descent-data-pushout R
-            ( s ,
-              map-cocone-standard-sequential-colimit
-                ( succ-ℕ n)
-                ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
-            ( ( ( tr
-                  ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-                  ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
-                ( tr
-                  ( λ p →
-                    right-family-descent-data-pushout R
-                      ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-                  ( glue-pushout _ _ (s , refl , (concat-s 𝒮 a₀ s n p)))) ∘
-                ( tr
-                  ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-                  ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))
-              ( tr
-                ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-                ( CB s n p)
-                ( map-family-descent-data-pushout R
-                  ( s , map-cocone-standard-sequential-colimit n p)
-                  ( tA (left-map-span-diagram 𝒮 s) n p))))
-        [key]'' = {!!}
-        [key]' :
-          tr
-            ( λ p →
-              left-family-descent-data-pushout R
-                ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-            ( glue-pushout _ _ (s , refl , p))
-            ( tr
-              ( ev-pair (left-family-descent-data-pushout R) (left-map-span-diagram 𝒮 s))
-              ( coherence-cocone-standard-sequential-colimit n p)
-              ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
-          inv-map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) (concat-inv-s 𝒮 a₀ s (succ-ℕ (succ-ℕ n)) p))
+          ( foo s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
+      pr2 (pr2 (dep-cocone-a a)) (s , refl , p) =
+        map-eq-transpose-equiv
+          ( equiv-family-descent-data-pushout R
             ( s ,
               map-cocone-standard-sequential-colimit
+                ( succ-ℕ (succ-ℕ n))
+                ( concat-inv-s 𝒮 a₀ s
+                  ( succ-ℕ (succ-ℕ n))
+                  ( concat-s 𝒮 a₀ s (succ-ℕ n) p))))
+          ( inv
+            ( ( ap
+                ( foo s (succ-ℕ n) (concat-s 𝒮 a₀ s (succ-ℕ n) p))
+                ( compute-inr-dependent-cogap _ _
+                  ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+                  ( s , refl , p))) ∙
+              ( coh-dep-cocone-a s
                 ( succ-ℕ n)
-                ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
-            ( foo s n (concat-s 𝒮 a₀ s n p) (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
-        [key]' = {!!}
-        [key] :
-          tr
-            ( λ p →
-              left-family-descent-data-pushout R
-                ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-            ( glue-pushout _ _ (s , refl , p))
-            ( pr1 (cocone-tA (left-map-span-diagram 𝒮 s) n) p) ＝
-          (pr1 (pr2 (cocone-tA (left-map-span-diagram 𝒮 s) n)) (s , refl , concat-s 𝒮 a₀ s n p))
-        [key] = {!!}
-          --         htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-          -- ( up-standard-sequential-colimit)
-          -- ( shift-once-cocone-sequential-diagram
-          --   ( cocone-standard-sequential-colimit
-          --     ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
-          -- ( hom-diagram-zigzag-sequential-diagram
-          --   ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-
-
-      tS s n p =
-        inv
-          ( compute-inr-dependent-cogap _ _
-            ( cocone-tB (right-map-span-diagram 𝒮 s) n)
-            ( s , refl , p))
+                ( p)
+                ( dependent-cogap _ _
+                  (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))))
 
-      alt-tS :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p)
-          ( tAA
-            ( left-map-span-diagram 𝒮 s)
-            ( map-cocone-standard-sequential-colimit n p)) ＝
-        tBB
-          ( right-map-span-diagram 𝒮 s)
-          ( concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
-      alt-tS s n p =
-        {!tS s n p!}
-        where
-        [ii] =
-          pr1
-            ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
-              ( dup-standard-sequential-colimit)
-              ( cocone-tAA (left-map-span-diagram 𝒮 s)))
-            ( n)
-            ( p)
-        [i] =
-          apd
-            ( map-family-descent-data-pushout R (s , map-cocone-standard-sequential-colimit n p))
-            ( [ii])
+--     interleaved mutual
+--       -- left section part tⁿ_A a
+--       tA :
+--         (a : domain-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         (p : Path-to-a 𝒮 a₀ a n) →
+--         left-family-descent-data-pushout R
+--           ( a , map-cocone-standard-sequential-colimit n p)
+--       -- definition of tⁿ⁺¹_A a (pattern matching on Pⁿ⁺¹_A a)
+--       cocone-tA :
+--         (a : domain-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         dependent-cocone-span-diagram
+--           ( cocone-pushout _ _)
+--           ( λ p →
+--             left-family-descent-data-pushout R
+--               ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--       -- right section part tⁿ_B b
+--       tB :
+--         (b : codomain-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         (p : Path-to-b 𝒮 a₀ b n) →
+--         right-family-descent-data-pushout R
+--           ( b , map-cocone-standard-sequential-colimit n p)
+--       -- definition of tⁿ⁺¹_B b (pattern matching on Pⁿ⁺¹_B b)
+--       cocone-tB :
+--         (b : codomain-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         dependent-cocone-span-diagram
+--           ( cocone-pushout _ _)
+--           ( λ p →
+--             right-family-descent-data-pushout R
+--               ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--       -- section coherence part tⁿ_S
+--       tS :
+--         (s : spanning-type-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--         tr
+--           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--           ( CB s n p)
+--           ( map-family-descent-data-pushout R
+--             ( s , map-cocone-standard-sequential-colimit n p)
+--             ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+--         tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
+--       -- left section t_A a
+--       tAA :
+--         (a : domain-span-diagram 𝒮) →
+--         (p : left-id-pushout 𝒮 a₀ a) →
+--         left-family-descent-data-pushout R (a , p)
+--       -- definition of t_A a (pattern matching on Pᵒᵒ_A a)
+--       cocone-tAA :
+--         (a : domain-span-diagram 𝒮) →
+--         dependent-cocone-sequential-diagram
+--           ( cocone-standard-sequential-colimit
+--             ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
+--           ( λ p → left-family-descent-data-pushout R (a , p))
+--       -- right section t_B b
+--       tBB :
+--         (b : codomain-span-diagram 𝒮) →
+--         (p : right-id-pushout 𝒮 a₀ b) →
+--         right-family-descent-data-pushout R (b , p)
+--       -- definition of t_B b (pattern matching on Pᵒᵒ_B b)
+--       cocone-tBB :
+--         (b : codomain-span-diagram 𝒮) →
+--         dependent-cocone-sequential-diagram
+--           ( cocone-standard-sequential-colimit
+--             ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b))
+--           ( λ p → right-family-descent-data-pushout R (b , p))
+--       -- section coherence t_S s
+--       tSS :
+--         (s : spanning-type-span-diagram 𝒮) →
+--         (p : left-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s)) →
+--         map-family-descent-data-pushout R
+--           ( s , p)
+--           ( tAA (left-map-span-diagram 𝒮 s) p) ＝
+--         tBB
+--           ( right-map-span-diagram 𝒮 s)
+--           ( concat-s-inf 𝒮 a₀ s p)
+--       -- definition of t_S s (pattern matching on Pᵒᵒ_A a)
+--       cocone-tSS :
+--         (s : spanning-type-span-diagram 𝒮) →
+--         dependent-cocone-sequential-diagram
+--           ( cocone-standard-sequential-colimit
+--             ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+--               ( left-map-span-diagram 𝒮 s)))
+--           ( λ p →
+--             map-family-descent-data-pushout R
+--               ( s , p)
+--               ( tAA (left-map-span-diagram 𝒮 s) p) ＝
+--             tBB (right-map-span-diagram 𝒮 s) (concat-s-inf 𝒮 a₀ s p))
+
+--       tA a zero-ℕ (map-raise refl) = r₀
+--       -- tA (n+1) needs coconeA n, which needs tA n and tB (n+1),
+--       -- which needs coconeB n, which only needs tB n and tA n,
+--       -- so it terminates
+--       tA a (succ-ℕ n) = dependent-cogap _ _ (cocone-tA a n)
+--       tB b zero-ℕ (map-raise ())
+--       tB b (succ-ℕ n) = dependent-cogap _ _ (cocone-tB b n)
+--       tAA a = dependent-cogap-standard-sequential-colimit (cocone-tAA a)
+--       tBB b = dependent-cogap-standard-sequential-colimit (cocone-tBB b)
+
+--       pr1 (cocone-tB b n) p =
+--         tr
+--           ( ev-pair (right-family-descent-data-pushout R) b)
+--           ( coherence-cocone-standard-sequential-colimit n p)
+--           ( tB b n p)
+--       pr1 (pr2 (cocone-tB b n)) (s , refl , p) =
+--         tr
+--           ( ev-pair (right-family-descent-data-pushout R) b)
+--           ( CB s n p)
+--           ( map-family-descent-data-pushout R
+--             ( s , map-cocone-standard-sequential-colimit n p)
+--             ( tA (left-map-span-diagram 𝒮 s) n p))
+--       pr2 (pr2 (cocone-tB ._ zero-ℕ)) (s , refl , map-raise ())
+--       pr2 (pr2 (cocone-tB ._ (succ-ℕ n))) (s , refl , p) =
+--         inv
+--           ( ( ap
+--               ( λ q →
+--                 tr
+--                   ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--                   ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+--                   ( map-family-descent-data-pushout R
+--                     ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+--                     ( q)))
+--               ( compute-inr-dependent-cogap _ _
+--                 ( cocone-tA (left-map-span-diagram 𝒮 s) n)
+--                 ( s , refl , p))) ∙
+--             ( ap
+--               ( tr
+--                 ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--                 ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+--               -- Would typecheck if Agda were to expand vertical-map-dependent-cocone (cocone-tA)
+--               ( {![i]!})) ∙
+--             ( is-section-map-inv-equiv
+--               ( equiv-tr
+--                 ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--                 ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+--               ( _)))
+--         where
+--           [i] :
+--             map-family-descent-data-pushout R
+--               ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+--               ( inv-map-family-descent-data-pushout R
+--                 ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+--                 ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))) ＝
+--             foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p)
+--           [i] =
+--             is-section-map-inv-equiv
+--               ( equiv-family-descent-data-pushout R
+--                 ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+--               ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))
+
+--       pr1 (cocone-tA a n) p =
+--         tr
+--           ( ev-pair (left-family-descent-data-pushout R) a)
+--           ( coherence-cocone-standard-sequential-colimit n p)
+--           ( tA a n p)
+--       pr1 (pr2 (cocone-tA a n)) (s , refl , p) =
+--         inv-map-family-descent-data-pushout R
+--           ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+--           ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))
+--       pr2 (pr2 (cocone-tA a n)) (s , refl , p) =
+--         [key]
+--         where
+--         [i] :
+--           ( ( concat-s-inf 𝒮 a₀ s) ·l
+--             ( coherence-cocone-standard-sequential-colimit n ∙h
+--               map-cocone-standard-sequential-colimit (succ-ℕ n) ·l (λ p → glue-pushout _ _ (s , refl , p)))) ~
+--           ( ( CB s n) ∙h
+--             ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) ·r
+--               ( concat-s 𝒮 a₀ s n))) ∙h
+--             ( ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n))) ·l
+--               (λ p → glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙h
+--             ( inv-htpy (CB s (succ-ℕ n)) ·r (concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
+--         [i] =
+--           {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--             ( up-standard-sequential-colimit)
+--             ( shift-once-cocone-sequential-diagram
+--               ( cocone-standard-sequential-colimit
+--                 ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
+--             ( hom-diagram-zigzag-sequential-diagram
+--               ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+--             ( n)!}
+--         [ii] :
+--           coherence-square-maps
+--             ( tr
+--               ( ev-pair
+--                 ( left-family-descent-data-pushout R)
+--                 ( left-map-span-diagram 𝒮 s))
+--               ( ( coherence-cocone-standard-sequential-colimit n p) ∙
+--                 ( ap
+--                   ( map-cocone-standard-sequential-colimit (succ-ℕ n))
+--                   ( glue-pushout _ _ (s , refl , p)))))
+--             ( map-family-descent-data-pushout R
+--               ( s , map-cocone-standard-sequential-colimit n p))
+--             ( map-family-descent-data-pushout R
+--               ( s ,
+--                 map-cocone-standard-sequential-colimit
+--                   ( succ-ℕ n)
+--                   ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))
+--             ( tr
+--               ( ev-pair
+--                 ( right-family-descent-data-pushout R)
+--                 ( right-map-span-diagram 𝒮 s))
+--               ( ( CB s n p) ∙
+--                 ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p)) ∙
+--                 ( ap
+--                   ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)))
+--                   ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙
+--                 ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))))
+--         [ii] =
+--           nat-lemma
+--             ( concat-s-inf 𝒮 a₀ s)
+--             ( ev-pair (map-family-descent-data-pushout R) s)
+--             ( [i] p)
+--         [iii] :
+--           coherence-square-maps
+--             ( ( tr
+--                 ( λ p →
+--                   left-family-descent-data-pushout R
+--                     ( left-map-span-diagram 𝒮 s ,
+--                       map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--                 ( glue-pushout _ _ (s , refl , p))) ∘
+--               ( tr
+--                 ( ev-pair
+--                   ( left-family-descent-data-pushout R)
+--                   ( left-map-span-diagram 𝒮 s))
+--                 ( coherence-cocone-standard-sequential-colimit n p)))
+--             ( map-family-descent-data-pushout R
+--               ( s , map-cocone-standard-sequential-colimit n p))
+--             ( map-family-descent-data-pushout R
+--               ( s ,
+--                 map-cocone-standard-sequential-colimit
+--                   ( succ-ℕ n)
+--                   ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))
+--             ( ( tr
+--                 ( ev-pair
+--                   ( right-family-descent-data-pushout R)
+--                   ( right-map-span-diagram 𝒮 s))
+--                 ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
+--               ( tr
+--                 ( λ p →
+--                   right-family-descent-data-pushout R
+--                     ( right-map-span-diagram 𝒮 s ,
+--                       map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+--                 ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
+--               ( tr
+--                 ( ev-pair
+--                   ( right-family-descent-data-pushout R)
+--                   ( right-map-span-diagram 𝒮 s))
+--                 ( coherence-cocone-standard-sequential-colimit
+--                   ( succ-ℕ n)
+--                   ( concat-s 𝒮 a₀ s n p))) ∘
+--               ( tr
+--                 ( ev-pair
+--                   ( right-family-descent-data-pushout R)
+--                   ( right-map-span-diagram 𝒮 s))
+--                 ( CB s n p)))
+--         [iii] = {! annoying straightforward path algebra from [ii] !}
+--         [key]'' :
+--           tr
+--             ( λ p →
+--               left-family-descent-data-pushout R
+--                 ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--             ( glue-pushout _ _ (s , refl , p))
+--             ( tr
+--               ( ev-pair (left-family-descent-data-pushout R) (left-map-span-diagram 𝒮 s))
+--               ( coherence-cocone-standard-sequential-colimit n p)
+--               ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+--           inv-map-family-descent-data-pushout R
+--             ( s ,
+--               map-cocone-standard-sequential-colimit
+--                 ( succ-ℕ n)
+--                 ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
+--             ( ( ( tr
+--                   ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--                   ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
+--                 ( tr
+--                   ( λ p →
+--                     right-family-descent-data-pushout R
+--                       ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+--                   ( glue-pushout _ _ (s , refl , (concat-s 𝒮 a₀ s n p)))) ∘
+--                 ( tr
+--                   ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--                   ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))
+--               ( tr
+--                 ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--                 ( CB s n p)
+--                 ( map-family-descent-data-pushout R
+--                   ( s , map-cocone-standard-sequential-colimit n p)
+--                   ( tA (left-map-span-diagram 𝒮 s) n p))))
+--         [key]'' =
+--           map-eq-transpose-equiv
+--             ( equiv-family-descent-data-pushout R
+--               ( s ,
+--                 map-cocone-standard-sequential-colimit
+--                   ( succ-ℕ n)
+--                   ( concat-inv-s 𝒮 a₀ s
+--                     ( succ-ℕ n)
+--                     ( concat-s 𝒮 a₀ s n p))))
+--             ( inv
+--               ( [iii] (tA (left-map-span-diagram 𝒮 s) n p)))
+--         [key]' :
+--           tr
+--             ( λ p →
+--               left-family-descent-data-pushout R
+--                 ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--             ( glue-pushout _ _ (s , refl , p))
+--             ( tr
+--               ( ev-pair (left-family-descent-data-pushout R) (left-map-span-diagram 𝒮 s))
+--               ( coherence-cocone-standard-sequential-colimit n p)
+--               ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+--           inv-map-family-descent-data-pushout R
+--             ( s ,
+--               map-cocone-standard-sequential-colimit
+--                 ( succ-ℕ n)
+--                 ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
+--             ( foo s n (concat-s 𝒮 a₀ s n p) (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
+--         [key]' = {!folded foo and tB from [key]''!}
+--         [key] :
+--           tr
+--             ( λ p →
+--               left-family-descent-data-pushout R
+--                 ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--             ( glue-pushout _ _ (s , refl , p))
+--             ( pr1 (cocone-tA (left-map-span-diagram 𝒮 s) n) p) ＝
+--           (pr1 (pr2 (cocone-tA (left-map-span-diagram 𝒮 s) n)) (s , refl , concat-s 𝒮 a₀ s n p))
+--         [key] = {!folded cocone-tA from [key]'!}
+
+--       tS s n p =
+--         inv
+--           ( compute-inr-dependent-cogap _ _
+--             ( cocone-tB (right-map-span-diagram 𝒮 s) n)
+--             ( s , refl , p))
+
+--       alt-tS :
+--         (s : spanning-type-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--         map-family-descent-data-pushout R
+--           ( s , map-cocone-standard-sequential-colimit n p)
+--           ( tAA
+--             ( left-map-span-diagram 𝒮 s)
+--             ( map-cocone-standard-sequential-colimit n p)) ＝
+--         tBB
+--           ( right-map-span-diagram 𝒮 s)
+--           ( concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
+--       alt-tS s n p =
+--         {!tS s n p!}
+--         where
+--         [ii] =
+--           pr1
+--             ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+--               ( dup-standard-sequential-colimit)
+--               ( cocone-tAA (left-map-span-diagram 𝒮 s)))
+--             ( n)
+--             ( p)
+--         [i] =
+--           apd
+--             ( map-family-descent-data-pushout R (s , map-cocone-standard-sequential-colimit n p))
+--             ( [ii])
 
-      tSS s = dependent-cogap-standard-sequential-colimit (cocone-tSS s)
+--       tSS s = dependent-cogap-standard-sequential-colimit (cocone-tSS s)
 
-      pr1 (cocone-tAA a) = tA a
-      pr2 (cocone-tAA a) n p = inv (compute-inl-dependent-cogap _ _ (cocone-tA a n) p)
+--       pr1 (cocone-tAA a) = tA a
+--       pr2 (cocone-tAA a) n p = inv (compute-inl-dependent-cogap _ _ (cocone-tA a n) p)
 
-      pr1 (cocone-tBB b) = tB b
-      pr2 (cocone-tBB b) n p = inv (compute-inl-dependent-cogap _ _ (cocone-tB b n) p)
+--       pr1 (cocone-tBB b) = tB b
+--       pr2 (cocone-tBB b) n p = inv (compute-inl-dependent-cogap _ _ (cocone-tB b n) p)
 
-      pr1 (cocone-tSS s) = alt-tS s
-      pr2 (cocone-tSS s) = {!!}
+--       pr1 (cocone-tSS s) = alt-tS s
+--       pr2 (cocone-tSS s) = {!!}
 
-    alt-tS-tS-equiv :
-      (s : spanning-type-span-diagram 𝒮) →
+--     alt-tS-tS-equiv :
+--       (s : spanning-type-span-diagram 𝒮) →
+--       {!!}
+--       -- (n : ℕ) →
+--       -- (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--       -- {!!} ≃ {!!}
+--     alt-tS-tS-equiv s =
+--       tS-equiv-tS
+--         ( up-standard-sequential-colimit)
+--         ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+--         ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
+--         ( λ p → left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , p))
+--         ( λ p → right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , p))
+--         ( λ p → equiv-family-descent-data-pushout R (s , p))
+--         ( tA (left-map-span-diagram 𝒮 s))
+--         -- ( λ where
+--         --   zero-ℕ (map-raise refl) → inv (compute-inl-dependent-cogap _ _ (cocone-tA (left-map-span-diagram 𝒮 s) 0) _ ∙ {!!})
+--         --   (succ-ℕ n) a → {!!} )
+--         ( λ n p →
+--           inv
+--             ( ( compute-inl-dependent-cogap _ _ (cocone-tA (left-map-span-diagram 𝒮 s) n) p) ∙
+--               {!refl!}))
+--         ( λ n → tB (right-map-span-diagram 𝒮 s) (succ-ℕ n))
+--         ( {!!})
+
+
+    ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
+    pr1 ind-singleton-zigzag-id-pushout' (a , p) =
+      dependent-cogap-standard-sequential-colimit
+        ( tA , KA)
+        ( p)
+      where
+      tA :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
+        left-family-descent-data-pushout R
+          ( a , map-cocone-standard-sequential-colimit n p)
+      tA zero-ℕ (map-raise refl) = r₀
+      tA (succ-ℕ n) = dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a)
+      KA :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
+        dependent-identification
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tA n p)
+          ( tA (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p))
+      KA zero-ℕ (map-raise refl) =
+        inv
+          ( compute-inl-dependent-cogap _ _
+            ( pr1 (pr2 (stages-cocones' 0)) a)
+            ( map-raise refl))
+      KA (succ-ℕ n) p =
+        inv
+          ( compute-inl-dependent-cogap _ _
+            ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) a)
+            ( p))
+    pr1 (pr2 ind-singleton-zigzag-id-pushout') (b , p) =
+      dependent-cogap-standard-sequential-colimit
+        ( tB , KB)
+        ( p)
+      where
+      tB :
+        (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
+        right-family-descent-data-pushout R
+          ( b , map-cocone-standard-sequential-colimit n p)
+      tB zero-ℕ (map-raise ())
+      tB (succ-ℕ n) = dependent-cogap _ _ (pr1 (stages-cocones' n) b)
+      KB :
+        (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
+        dependent-identification
+          ( ev-pair (right-family-descent-data-pushout R) b)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tB n p)
+          ( tB (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
+      KB zero-ℕ (map-raise ())
+      KB (succ-ℕ n) p =
+        inv
+          ( compute-inl-dependent-cogap _ _
+            ( pr1 (stages-cocones' (succ-ℕ n)) b)
+            ( p))
+    pr2 (pr2 ind-singleton-zigzag-id-pushout') (s , p) =
       {!!}
-      -- (n : ℕ) →
-      -- (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-      -- {!!} ≃ {!!}
-    alt-tS-tS-equiv s =
-      tS-equiv-tS
-        ( up-standard-sequential-colimit)
-        ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
-        ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
-        ( λ p → left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , p))
-        ( λ p → right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , p))
-        ( λ p → equiv-family-descent-data-pushout R (s , p))
-        ( tA (left-map-span-diagram 𝒮 s))
-        -- ( λ where
-        --   zero-ℕ (map-raise refl) → inv (compute-inl-dependent-cogap _ _ (cocone-tA (left-map-span-diagram 𝒮 s) 0) _ ∙ {!!})
-        --   (succ-ℕ n) a → {!!} )
-        ( λ n p →
-          inv
-            ( ( compute-inl-dependent-cogap _ _ (cocone-tA (left-map-span-diagram 𝒮 s) n) p) ∙
-              {!refl!}))
-        ( λ n → tB (right-map-span-diagram 𝒮 s) (succ-ℕ n))
-        ( {!!})
-
-  ind-singleton-zigzag-id-pushout' :
-    {l5 : Level}
-    (R :
-      descent-data-pushout
-        ( span-diagram-flattening-descent-data-pushout
-          ( descent-data-zigzag-id-pushout 𝒮 a₀))
-        ( l5))
-    (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀)) →
-    section-descent-data-pushout R
-  pr1 (ind-singleton-zigzag-id-pushout' R r₀) (a , p) =
-    tAA R r₀ a p
-  pr1 (pr2 (ind-singleton-zigzag-id-pushout' R r₀)) (b , p) =
-    tBB R r₀ b p
-  pr2 (pr2 (ind-singleton-zigzag-id-pushout' R r₀)) (s , p) =
-    tSS R r₀ s p
 
   is-identity-system-zigzag-id-pushout :
     is-identity-system-descent-data-pushout

From 2cfce599b1445d997d4a8fff59475decd13bf47b Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Mon, 24 Jun 2024 01:17:33 +0200
Subject: [PATCH 07/33] Down to one hole

---
 ...nstruction-identity-type-pushouts.lagda.md | 180 ++++++------------
 1 file changed, 59 insertions(+), 121 deletions(-)

diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index d2b76f555d..c700b06760 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -15,6 +15,7 @@ open import elementary-number-theory.natural-numbers
 -- open import foundation.contractible-types
 open import foundation.action-on-identifications-dependent-functions
 open import foundation.cartesian-product-types
+open import foundation.commuting-squares-of-homotopies
 open import foundation.dependent-identifications
 open import foundation.dependent-pair-types
 open import foundation.empty-types
@@ -539,7 +540,10 @@ module _
                   ( tr-concat _ _)))))) ·r
         ( map-family-descent-data-pushout R
           ( s , map-cocone-standard-sequential-colimit n p))) ∙h
-      ( [ii]) ∙h
+      ( nat-lemma
+          ( concat-s-inf 𝒮 a₀ s)
+          ( ev-pair (map-family-descent-data-pushout R) s)
+          ( [i] p)) ∙h
       ( ( map-family-descent-data-pushout R
           ( s ,
             map-cocone-standard-sequential-colimit
@@ -550,131 +554,65 @@ module _
         ( ( tr-concat _ _) ∙h
           ( λ q → substitution-law-tr _ _ _)))
       where
-      [0] :
-        ( ( ( concat-s-inf 𝒮 a₀ s) ·l
-            ( coherence-cocone-standard-sequential-colimit n)) ∙h
-          ( ( CB s (succ-ℕ n)) ·r
-            ( inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n))) ~
-        ( ( CB s n) ∙h
-          ( ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
-              ( concat-s 𝒮 a₀ s n)) ∙h
-            ( ( map-cocone-standard-sequential-colimit
-                { A =
-                  right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                    ( right-map-span-diagram 𝒮 s)}
-                ( succ-ℕ (succ-ℕ n))) ·l
-              pr2
-               (hom-diagram-zigzag-sequential-diagram
-                (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-               n)))
-      [0] =
-        coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-          ( up-standard-sequential-colimit)
-          ( shift-once-cocone-sequential-diagram
-            ( cocone-standard-sequential-colimit
-              ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
-          ( hom-diagram-zigzag-sequential-diagram
-            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-          ( n)
-      [0]' :
-        (
-            (concat-s-inf 𝒮 a₀ s ·l
-             coherence-cocone-standard-sequential-colimit n
-             ∙h
-             CB s (succ-ℕ n) ·r
-             inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) ∙h
-             (map-cocone-standard-sequential-colimit {A = right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s) } (succ-ℕ (succ-ℕ n)) ·l
-              (
-                pr1 (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
-                  (succ-ℕ n)
-                  ·l
-                  (pr1
-                  (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)))
-                  n)
-                )
-            ))
-         ~
-          (CB s n ∙h
-             (
-                coherence-cocone-standard-sequential-colimit (succ-ℕ n) ·r
-                 concat-s 𝒮 a₀ s n
-                 ∙h
-                (map-cocone-standard-sequential-colimit {A = right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s) } (succ-ℕ (succ-ℕ n)) ·l
-                     (λ x₃ →
-                        glue-pushout
-                        _
-                        _
-                        (s ,
-                         refl ,
-                         pr1 (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s) n x₃))))
-                     )
-
-      [0]' =
-        ( ap-concat-htpy _
-          ( ?)) ∙h
-        ( map-inv-equiv
-          ( equiv-right-transpose-htpy-concat _ _ _)
-          ( ( [0]) ∙h
-            ( ap-concat-htpy
-              ( CB s n)
-              ( ( ap-concat-htpy
-                  ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) ·r concat-s 𝒮 a₀ s n)
-                  ( ( distributive-left-whisker-comp-concat
-                      ( map-cocone-standard-sequential-colimit
-                        {A = right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s)}
-                        ( succ-ℕ (succ-ℕ n)))
-                      ( _)
-                      ( _)) ∙h
-                    ( ap-concat-htpy _
-                      ( ( left-whisker-comp² _ (left-whisker-inv-htpy _ _)) ∙h
-                        ( left-whisker-inv-htpy _ _))))) ∙h
-                ( inv-htpy-assoc-htpy _ _ _))) ∙h
-            ( inv-htpy-assoc-htpy _ _ _)))
       [i] :
         ( ( concat-s-inf 𝒮 a₀ s) ·l
-          ( coherence-cocone-standard-sequential-colimit n ∙h
-            map-cocone-standard-sequential-colimit (succ-ℕ n) ·l (λ p → glue-pushout _ _ (s , refl , p)))) ~
+          ( ( coherence-cocone-standard-sequential-colimit n) ∙h
+            ( ( map-cocone-standard-sequential-colimit
+              { A =
+                left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                  ( left-map-span-diagram 𝒮 s)}
+              ( succ-ℕ n)) ·l
+            ( λ p → glue-pushout _ _ (s , refl , p))))) ~
         ( ( CB s n) ∙h
           ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
-            ( concat-s 𝒮 a₀ s n)) ∙h
-          ( ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n))) ·l
-            ( λ p → glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙h
-          ( inv-htpy (CB s (succ-ℕ n)) ·r (concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
+              ( concat-s 𝒮 a₀ s n)) ∙h
+          ( ( map-cocone-standard-sequential-colimit
+              { A =
+                right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                  ( right-map-span-diagram 𝒮 s)}
+              ( succ-ℕ (succ-ℕ n))) ·l
+            ( λ p → glue-pushout _ _ ( s , refl , concat-s 𝒮 a₀ s n p))) ∙h
+          ( ( inv-htpy (CB s (succ-ℕ n))) ·r
+            ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
       [i] =
-        distributive-left-whisker-comp-concat _ _ _ ∙h
-        {!!}
-      -- square with condensed top and bottom
-      [ii] :
-        coherence-square-maps
-          ( tr
-            ( ev-pair
-              ( left-family-descent-data-pushout R)
-              ( left-map-span-diagram 𝒮 s))
-            ( ( coherence-cocone-standard-sequential-colimit n p) ∙
-              ( ap
-                ( map-cocone-standard-sequential-colimit (succ-ℕ n))
-                ( glue-pushout _ _ (s , refl , p)))))
-          ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit n p))
-          ( map-family-descent-data-pushout R
-            ( s ,
-              map-cocone-standard-sequential-colimit (succ-ℕ n)
-                ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
-          ( tr
-            ( ev-pair
-              ( right-family-descent-data-pushout R)
-              ( right-map-span-diagram 𝒮 s))
-            ( ( CB s n p) ∙
-              ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p)) ∙
-              ( ap
-                ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)))
-                ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙
-              ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))))
-      [ii] =
-        nat-lemma
-          ( concat-s-inf 𝒮 a₀ s)
-          ( ev-pair (map-family-descent-data-pushout R) s)
-          ( [i] p)
+        ( distributive-left-whisker-comp-concat _ _ _) ∙h
+        ( right-transpose-htpy-concat _ _ _
+          ( ( left-whisker-concat-coherence-square-homotopies _ _ _ _ _
+              ( λ p →
+                inv
+                  ( nat-coherence-square-maps _ _ _ _
+                    ( CB s (succ-ℕ n))
+                    ( glue-pushout _ _ (s , refl , p))))) ∙h
+            ( map-inv-equiv
+              ( equiv-right-transpose-htpy-concat _ _ _)
+              ( ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+                  ( up-standard-sequential-colimit)
+                  ( shift-once-cocone-sequential-diagram
+                    ( cocone-standard-sequential-colimit
+                      ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                        ( right-map-span-diagram 𝒮 s))))
+                  ( hom-diagram-zigzag-sequential-diagram
+                    ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+                  ( n)) ∙h
+                ( ap-concat-htpy
+                  ( CB s n)
+                  ( ( ap-concat-htpy _
+                      ( ( distributive-left-whisker-comp-concat
+                          ( map-cocone-standard-sequential-colimit
+                            { A =
+                              right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                                ( right-map-span-diagram 𝒮 s)}
+                            ( succ-ℕ (succ-ℕ n)))
+                          ( _)
+                          ( _)) ∙h
+                        ( ap-concat-htpy _
+                          ( ( left-whisker-comp² _
+                              ( left-whisker-inv-htpy _ _)) ∙h
+                            ( left-whisker-inv-htpy _ _))))) ∙h
+                    ( inv-htpy-assoc-htpy _ _ _))) ∙h
+                ( inv-htpy-assoc-htpy _ _ _))))) ∙h
+        ( ap-concat-htpy' _
+          ( inv-htpy-assoc-htpy _ _ _))
 
 
     -- TODO: Explore omitting vertical-map-dependent-cocone

From 6c38ee8e4dd302a84624acd0a3ad635081eefe81 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Mon, 24 Jun 2024 18:01:43 +0200
Subject: [PATCH 08/33] Down to one coherence

---
 .../sequential-colimits.lagda.md              |  18 +
 ...nstruction-identity-type-pushouts.lagda.md | 668 +++---------------
 2 files changed, 122 insertions(+), 564 deletions(-)

diff --git a/src/synthetic-homotopy-theory/sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/sequential-colimits.lagda.md
index e0767413bd..4b5b04f385 100644
--- a/src/synthetic-homotopy-theory/sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/sequential-colimits.lagda.md
@@ -16,6 +16,7 @@ open import foundation.function-types
 open import foundation.functoriality-dependent-function-types
 open import foundation.functoriality-dependent-pair-types
 open import foundation.homotopies
+open import foundation.identity-types
 open import foundation.propositions
 open import foundation.universe-levels
 
@@ -205,6 +206,23 @@ module _
     ( x : standard-sequential-colimit A) → P x
   dependent-cogap-standard-sequential-colimit =
     map-inv-equiv equiv-dup-standard-sequential-colimit
+
+  compute-incl-dependent-cogap-standard-sequential-colimit :
+    { P : standard-sequential-colimit A → UU l2} →
+    ( d :
+      dependent-cocone-sequential-diagram
+        ( cocone-standard-sequential-colimit A)
+        ( P)) →
+    ( n : ℕ) (a : family-sequential-diagram A n) →
+    dependent-cogap-standard-sequential-colimit d
+      ( map-cocone-standard-sequential-colimit n a) ＝
+    map-dependent-cocone-sequential-diagram P d n a
+  compute-incl-dependent-cogap-standard-sequential-colimit d =
+     pr1
+      ( htpy-eq-dependent-cocone-sequential-diagram _ _ d
+        ( is-section-map-inv-is-equiv
+          ( dup-standard-sequential-colimit _)
+          ( d)))
 ```
 
 ### The small predicate of being a sequential colimit cocone
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index c700b06760..b2c0f4d734 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -11,52 +11,39 @@ module synthetic-homotopy-theory.zigzag-construction-identity-type-pushouts wher
 ```agda
 open import elementary-number-theory.natural-numbers
 
--- open import foundation.commuting-squares-of-maps
--- open import foundation.contractible-types
 open import foundation.action-on-identifications-dependent-functions
+open import foundation.action-on-identifications-functions
 open import foundation.cartesian-product-types
 open import foundation.commuting-squares-of-homotopies
+open import foundation.commuting-squares-of-maps
 open import foundation.dependent-identifications
 open import foundation.dependent-pair-types
+open import foundation.embeddings
 open import foundation.empty-types
 open import foundation.equivalences
 open import foundation.function-types
 open import foundation.functoriality-dependent-pair-types
--- open import foundation.fundamental-theorem-of-identity-types
 open import foundation.homotopies
 open import foundation.homotopy-algebra
--- open import foundation.identity-systems
 open import foundation.identity-types
--- open import foundation.sections
--- open import foundation.singleton-induction
 open import foundation.raising-universe-levels
 open import foundation.span-diagrams
 open import foundation.transport-along-identifications
 open import foundation.transposition-identifications-along-equivalences
--- open import foundation.torsorial-type-families
--- open import foundation.transposition-identifications-along-equivalences
--- open import foundation.universal-property-dependent-pair-types
--- open import foundation.universal-property-identity-types
 open import foundation.unit-type
 open import foundation.universe-levels
 open import foundation.whiskering-higher-homotopies-composition
 open import foundation.whiskering-homotopies-composition
 
 open import synthetic-homotopy-theory.cocones-under-spans
--- open import synthetic-homotopy-theory.dependent-universal-property-pushouts
--- open import synthetic-homotopy-theory.descent-data-equivalence-types-over-pushouts
--- open import synthetic-homotopy-theory.descent-data-identity-types-over-pushouts
 open import synthetic-homotopy-theory.dependent-cocones-under-sequential-diagrams
 open import synthetic-homotopy-theory.dependent-cocones-under-spans
 open import synthetic-homotopy-theory.dependent-universal-property-sequential-colimits
 open import synthetic-homotopy-theory.descent-data-pushouts
 open import synthetic-homotopy-theory.functoriality-sequential-colimits
 open import synthetic-homotopy-theory.identity-systems-descent-data-pushouts
--- open import synthetic-homotopy-theory.descent-property-pushouts
--- open import synthetic-homotopy-theory.equivalences-descent-data-pushouts
 open import synthetic-homotopy-theory.families-descent-data-pushouts
 open import synthetic-homotopy-theory.flattening-lemma-pushouts
--- open import synthetic-homotopy-theory.morphisms-descent-data-pushouts
 open import synthetic-homotopy-theory.pushouts
 open import synthetic-homotopy-theory.sequential-colimits
 open import synthetic-homotopy-theory.sequential-diagrams
@@ -70,102 +57,11 @@ open import synthetic-homotopy-theory.zigzags-sequential-diagrams
 
 ## Idea
 
-TODO
+The identity types of pushouts may be characterized as certain sequential
+colimits of pushouts.
 
 ## Definitions
 
-### TODO
-
-```agda
-open import foundation.action-on-identifications-functions
-open import foundation.commuting-squares-of-maps
-open import synthetic-homotopy-theory.cocones-under-sequential-diagrams
--- open import synthetic-homotopy-theory.dependent-universal-property-sequential-colimits
-open import synthetic-homotopy-theory.universal-property-sequential-colimits
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : sequential-diagram l1} {B : sequential-diagram l2}
-  {X : UU l3} {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  {Y : UU l4} {c' : cocone-sequential-diagram B Y}
-  (up-c' : universal-property-sequential-colimit c')
-  (z : zigzag-sequential-diagram A B)
-  (P : X → UU l5) (Q : Y → UU l6)
-  (e : (x : X) → P x ≃ Q (map-colimit-zigzag-sequential-diagram up-c up-c' z x))
-  where
-
-  private
-    CB :
-      (n : ℕ) →
-      coherence-square-maps
-        ( map-zigzag-sequential-diagram z n)
-        ( map-cocone-sequential-diagram c n)
-        ( map-cocone-sequential-diagram c' n)
-        ( map-colimit-zigzag-sequential-diagram up-c up-c' z)
-    CB =
-       htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-        ( up-c)
-        ( c')
-        ( hom-diagram-zigzag-sequential-diagram z)
-    dup-c : dependent-universal-property-sequential-colimit c
-    dup-c = dependent-universal-property-universal-property-sequential-colimit _ up-c
-    dup-c' : dependent-universal-property-sequential-colimit c'
-    dup-c' = dependent-universal-property-universal-property-sequential-colimit _ up-c'
-
-  tS-equiv-tS :
-    (tA : (n : ℕ) (a : family-sequential-diagram A n) → P (map-cocone-sequential-diagram c n a))
-    (HA :
-      (n : ℕ) (a : family-sequential-diagram A n) →
-      tr P (coherence-cocone-sequential-diagram c n a) (tA n a) ＝
-      tA (succ-ℕ n) (map-sequential-diagram A n a))
-    (tB : (n : ℕ) (b : family-sequential-diagram B n) → Q (map-cocone-sequential-diagram c' n b))
-    (HB :
-      (n : ℕ) (b : family-sequential-diagram B n) →
-      tr Q (coherence-cocone-sequential-diagram c' n b) (tB n b) ＝
-      tB (succ-ℕ n) (map-sequential-diagram B n b))
-    (n : ℕ) (a : family-sequential-diagram A n) →
-    ( ( map-equiv
-        ( e (map-cocone-sequential-diagram c n a))
-        ( map-dependent-universal-property-sequential-colimit dup-c
-          ( tA , HA)
-          ( map-cocone-sequential-diagram c n a))) ＝
-      map-dependent-universal-property-sequential-colimit dup-c'
-        ( tB , HB)
-        ( map-colimit-zigzag-sequential-diagram up-c up-c' z
-          ( map-cocone-sequential-diagram c n a))) ≃
-    ( ( tr Q
-        ( CB n a)
-        ( map-equiv (e (map-cocone-sequential-diagram c n a)) (tA n a))) ＝
-      ( tB n (map-zigzag-sequential-diagram z n a)))
-  tS-equiv-tS tA HA tB HB n a =
-    ( equiv-concat' _
-      ( pr1
-        ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
-          ( dup-c')
-          ( tB , HB))
-        ( n)
-        ( map-zigzag-sequential-diagram z n a))) ∘e
-    ( equiv-concat' _
-      ( apd
-        ( map-dependent-universal-property-sequential-colimit dup-c' (tB , HB))
-        ( CB n a))) ∘e
-    ( equiv-ap
-      ( equiv-tr Q (CB n a))
-      ( _)
-      ( _)) ∘e
-    equiv-concat
-      ( ap
-        ( map-equiv (e (map-cocone-sequential-diagram c n a)))
-        ( inv
-          ( pr1
-            ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
-              ( dup-c)
-              ( tA , HA))
-            ( n)
-            ( a))))
-      ( _)
-```
-
 ```agda
 module _
   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
@@ -403,6 +299,12 @@ nat-lemma :
     ( tr Q q)
 nat-lemma f h {p = p} refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
 
+apd-lemma :
+  {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
+  (f : (a : A) → B a) (g : (a : A) → B a → C a) {x y : A} (p : x ＝ y) →
+  apd (λ a → g a (f a)) p ＝ inv (preserves-tr g p (f x)) ∙ ap (g y) (apd f p)
+apd-lemma f g refl = refl
+
 module _
   {l1 l2 l3 l4 : Level} {𝒮 : span-diagram l1 l2 l3}
   {X : UU l4} {c : cocone-span-diagram 𝒮 X}
@@ -419,35 +321,6 @@ module _
     (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
     where
 
-    -- type-stage-ind-singleton-zigzag-id-pushout : ℕ → UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
-    -- type-stage-ind-singleton-zigzag-id-pushout n =
-    --   Σ ( (b : codomain-span-diagram 𝒮) (p : Path-to-b 𝒮 a₀ b n) →
-    --       right-family-descent-data-pushout R
-    --         ( b , map-cocone-standard-sequential-colimit n p))
-    --     ( λ tB →
-    --       Σ ( (a : domain-span-diagram 𝒮) (p : Path-to-a 𝒮 a₀ a n) →
-    --           left-family-descent-data-pushout R
-    --             ( a , map-cocone-standard-sequential-colimit n p))
-    --         ( λ tA →
-    --           rec-ℕ
-    --             ( raise-unit (l1 ⊔ l2 ⊔ l3 ⊔ l5))
-    --             ( λ n' _ →
-    --               ( (b : codomain-span-diagram 𝒮) →
-    --                 dependent-cocone-span-diagram
-    --                   ( cocone-pushout-span-diagram
-    --                     ( span-diagram-path-to-b 𝒮 a₀ b n'))
-    --                   ( λ p →
-    --                     right-family-descent-data-pushout R
-    --                       ( b , map-cocone-standard-sequential-colimit (succ-ℕ n') p))) ×
-    --               ( (a : domain-span-diagram 𝒮) →
-    --                 dependent-cocone-span-diagram
-    --                   ( cocone-pushout-span-diagram
-    --                     ( span-diagram-path-to-a 𝒮 a₀ a n'))
-    --                   ( λ p →
-    --                     left-family-descent-data-pushout R
-    --                       ( a , map-cocone-standard-sequential-colimit (succ-ℕ n') p))))
-    --             ( n)))
-
     private
       CB :
         (s : spanning-type-span-diagram 𝒮) →
@@ -466,7 +339,7 @@ module _
           ( hom-diagram-zigzag-sequential-diagram
             ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
 
-      foo :
+      Φ :
         (s : spanning-type-span-diagram 𝒮) →
         (n : ℕ) →
         (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
@@ -475,7 +348,7 @@ module _
         right-family-descent-data-pushout R
           ( right-map-span-diagram 𝒮 s ,
             concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-      foo s n p =
+      Φ s n p =
         ( tr
           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
           ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))) ∘
@@ -615,7 +488,6 @@ module _
           ( inv-htpy-assoc-htpy _ _ _))
 
 
-    -- TODO: Explore omitting vertical-map-dependent-cocone
     stages-cocones' :
       (n : ℕ) →
       Σ ( (b : codomain-span-diagram 𝒮) →
@@ -641,7 +513,7 @@ module _
                 ( s , refl , p) ＝
               inv-map-family-descent-data-pushout R
                 ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-                ( foo s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))))
+                ( Φ s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))))
     stages-cocones' zero-ℕ =
       dep-cocone-b ,
       dep-cocone-a ,
@@ -680,7 +552,7 @@ module _
       pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
         inv-map-family-descent-data-pushout R
           ( s , map-cocone-standard-sequential-colimit 1 (concat-inv-s 𝒮 a₀ s 1 p))
-          ( foo s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
+          ( Φ s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
       pr2 (pr2 (dep-cocone-a .a₀)) (s , refl , map-raise refl) =
         map-eq-transpose-equiv
           ( equiv-family-descent-data-pushout R
@@ -689,7 +561,7 @@ module _
                 ( concat-inv-s 𝒮 a₀ s 1 (concat-s 𝒮 a₀ s 0 (map-raise refl)))))
           ( inv
             ( ( ap
-                ( foo s 0 (concat-s 𝒮 a₀ s 0 (map-raise refl)))
+                ( Φ s 0 (concat-s 𝒮 a₀ s 0 (map-raise refl)))
                 ( compute-inr-dependent-cogap _ _
                   ( dep-cocone-b (right-map-span-diagram 𝒮 s))
                   (s , refl , map-raise refl))) ∙
@@ -748,7 +620,7 @@ module _
               ( is-section-map-inv-equiv
                 ( equiv-family-descent-data-pushout R
                   ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-                ( foo s n p (dependent-cogap _ _
+                ( Φ s n p (dependent-cogap _ _
                   ( pr1 (stages-cocones' n) (right-map-span-diagram 𝒮 s)) p)))) ∙
             ( is-section-map-inv-equiv
               ( equiv-tr
@@ -770,7 +642,7 @@ module _
       pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
         inv-map-family-descent-data-pushout R
           ( s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) (concat-inv-s 𝒮 a₀ s (succ-ℕ (succ-ℕ n)) p))
-          ( foo s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
+          ( Φ s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
       pr2 (pr2 (dep-cocone-a a)) (s , refl , p) =
         map-eq-transpose-equiv
           ( equiv-family-descent-data-pushout R
@@ -782,7 +654,7 @@ module _
                   ( concat-s 𝒮 a₀ s (succ-ℕ n) p))))
           ( inv
             ( ( ap
-                ( foo s (succ-ℕ n) (concat-s 𝒮 a₀ s (succ-ℕ n) p))
+                ( Φ s (succ-ℕ n) (concat-s 𝒮 a₀ s (succ-ℕ n) p))
                 ( compute-inr-dependent-cogap _ _
                   ( dep-cocone-b (right-map-span-diagram 𝒮 s))
                   ( s , refl , p))) ∙
@@ -792,425 +664,33 @@ module _
                 ( dependent-cogap _ _
                   (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))))
 
---     interleaved mutual
---       -- left section part tⁿ_A a
---       tA :
---         (a : domain-span-diagram 𝒮) →
---         (n : ℕ) →
---         (p : Path-to-a 𝒮 a₀ a n) →
---         left-family-descent-data-pushout R
---           ( a , map-cocone-standard-sequential-colimit n p)
---       -- definition of tⁿ⁺¹_A a (pattern matching on Pⁿ⁺¹_A a)
---       cocone-tA :
---         (a : domain-span-diagram 𝒮) →
---         (n : ℕ) →
---         dependent-cocone-span-diagram
---           ( cocone-pushout _ _)
---           ( λ p →
---             left-family-descent-data-pushout R
---               ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
---       -- right section part tⁿ_B b
---       tB :
---         (b : codomain-span-diagram 𝒮) →
---         (n : ℕ) →
---         (p : Path-to-b 𝒮 a₀ b n) →
---         right-family-descent-data-pushout R
---           ( b , map-cocone-standard-sequential-colimit n p)
---       -- definition of tⁿ⁺¹_B b (pattern matching on Pⁿ⁺¹_B b)
---       cocone-tB :
---         (b : codomain-span-diagram 𝒮) →
---         (n : ℕ) →
---         dependent-cocone-span-diagram
---           ( cocone-pushout _ _)
---           ( λ p →
---             right-family-descent-data-pushout R
---               ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
---       -- section coherence part tⁿ_S
---       tS :
---         (s : spanning-type-span-diagram 𝒮) →
---         (n : ℕ) →
---         (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---         tr
---           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---           ( CB s n p)
---           ( map-family-descent-data-pushout R
---             ( s , map-cocone-standard-sequential-colimit n p)
---             ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
---         tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
---       -- left section t_A a
---       tAA :
---         (a : domain-span-diagram 𝒮) →
---         (p : left-id-pushout 𝒮 a₀ a) →
---         left-family-descent-data-pushout R (a , p)
---       -- definition of t_A a (pattern matching on Pᵒᵒ_A a)
---       cocone-tAA :
---         (a : domain-span-diagram 𝒮) →
---         dependent-cocone-sequential-diagram
---           ( cocone-standard-sequential-colimit
---             ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀ a))
---           ( λ p → left-family-descent-data-pushout R (a , p))
---       -- right section t_B b
---       tBB :
---         (b : codomain-span-diagram 𝒮) →
---         (p : right-id-pushout 𝒮 a₀ b) →
---         right-family-descent-data-pushout R (b , p)
---       -- definition of t_B b (pattern matching on Pᵒᵒ_B b)
---       cocone-tBB :
---         (b : codomain-span-diagram 𝒮) →
---         dependent-cocone-sequential-diagram
---           ( cocone-standard-sequential-colimit
---             ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ b))
---           ( λ p → right-family-descent-data-pushout R (b , p))
---       -- section coherence t_S s
---       tSS :
---         (s : spanning-type-span-diagram 𝒮) →
---         (p : left-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s)) →
---         map-family-descent-data-pushout R
---           ( s , p)
---           ( tAA (left-map-span-diagram 𝒮 s) p) ＝
---         tBB
---           ( right-map-span-diagram 𝒮 s)
---           ( concat-s-inf 𝒮 a₀ s p)
---       -- definition of t_S s (pattern matching on Pᵒᵒ_A a)
---       cocone-tSS :
---         (s : spanning-type-span-diagram 𝒮) →
---         dependent-cocone-sequential-diagram
---           ( cocone-standard-sequential-colimit
---             ( left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
---               ( left-map-span-diagram 𝒮 s)))
---           ( λ p →
---             map-family-descent-data-pushout R
---               ( s , p)
---               ( tAA (left-map-span-diagram 𝒮 s) p) ＝
---             tBB (right-map-span-diagram 𝒮 s) (concat-s-inf 𝒮 a₀ s p))
-
---       tA a zero-ℕ (map-raise refl) = r₀
---       -- tA (n+1) needs coconeA n, which needs tA n and tB (n+1),
---       -- which needs coconeB n, which only needs tB n and tA n,
---       -- so it terminates
---       tA a (succ-ℕ n) = dependent-cogap _ _ (cocone-tA a n)
---       tB b zero-ℕ (map-raise ())
---       tB b (succ-ℕ n) = dependent-cogap _ _ (cocone-tB b n)
---       tAA a = dependent-cogap-standard-sequential-colimit (cocone-tAA a)
---       tBB b = dependent-cogap-standard-sequential-colimit (cocone-tBB b)
-
---       pr1 (cocone-tB b n) p =
---         tr
---           ( ev-pair (right-family-descent-data-pushout R) b)
---           ( coherence-cocone-standard-sequential-colimit n p)
---           ( tB b n p)
---       pr1 (pr2 (cocone-tB b n)) (s , refl , p) =
---         tr
---           ( ev-pair (right-family-descent-data-pushout R) b)
---           ( CB s n p)
---           ( map-family-descent-data-pushout R
---             ( s , map-cocone-standard-sequential-colimit n p)
---             ( tA (left-map-span-diagram 𝒮 s) n p))
---       pr2 (pr2 (cocone-tB ._ zero-ℕ)) (s , refl , map-raise ())
---       pr2 (pr2 (cocone-tB ._ (succ-ℕ n))) (s , refl , p) =
---         inv
---           ( ( ap
---               ( λ q →
---                 tr
---                   ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---                   ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
---                   ( map-family-descent-data-pushout R
---                     ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
---                     ( q)))
---               ( compute-inr-dependent-cogap _ _
---                 ( cocone-tA (left-map-span-diagram 𝒮 s) n)
---                 ( s , refl , p))) ∙
---             ( ap
---               ( tr
---                 ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---                 ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
---               -- Would typecheck if Agda were to expand vertical-map-dependent-cocone (cocone-tA)
---               ( {![i]!})) ∙
---             ( is-section-map-inv-equiv
---               ( equiv-tr
---                 ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---                 ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
---               ( _)))
---         where
---           [i] :
---             map-family-descent-data-pushout R
---               ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
---               ( inv-map-family-descent-data-pushout R
---                 ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
---                 ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))) ＝
---             foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p)
---           [i] =
---             is-section-map-inv-equiv
---               ( equiv-family-descent-data-pushout R
---                 ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
---               ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))
-
---       pr1 (cocone-tA a n) p =
---         tr
---           ( ev-pair (left-family-descent-data-pushout R) a)
---           ( coherence-cocone-standard-sequential-colimit n p)
---           ( tA a n p)
---       pr1 (pr2 (cocone-tA a n)) (s , refl , p) =
---         inv-map-family-descent-data-pushout R
---           ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
---           ( foo s n p (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) p))
---       pr2 (pr2 (cocone-tA a n)) (s , refl , p) =
---         [key]
---         where
---         [i] :
---           ( ( concat-s-inf 𝒮 a₀ s) ·l
---             ( coherence-cocone-standard-sequential-colimit n ∙h
---               map-cocone-standard-sequential-colimit (succ-ℕ n) ·l (λ p → glue-pushout _ _ (s , refl , p)))) ~
---           ( ( CB s n) ∙h
---             ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) ·r
---               ( concat-s 𝒮 a₀ s n))) ∙h
---             ( ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n))) ·l
---               (λ p → glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙h
---             ( inv-htpy (CB s (succ-ℕ n)) ·r (concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
---         [i] =
---           {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---             ( up-standard-sequential-colimit)
---             ( shift-once-cocone-sequential-diagram
---               ( cocone-standard-sequential-colimit
---                 ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
---             ( hom-diagram-zigzag-sequential-diagram
---               ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
---             ( n)!}
---         [ii] :
---           coherence-square-maps
---             ( tr
---               ( ev-pair
---                 ( left-family-descent-data-pushout R)
---                 ( left-map-span-diagram 𝒮 s))
---               ( ( coherence-cocone-standard-sequential-colimit n p) ∙
---                 ( ap
---                   ( map-cocone-standard-sequential-colimit (succ-ℕ n))
---                   ( glue-pushout _ _ (s , refl , p)))))
---             ( map-family-descent-data-pushout R
---               ( s , map-cocone-standard-sequential-colimit n p))
---             ( map-family-descent-data-pushout R
---               ( s ,
---                 map-cocone-standard-sequential-colimit
---                   ( succ-ℕ n)
---                   ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))
---             ( tr
---               ( ev-pair
---                 ( right-family-descent-data-pushout R)
---                 ( right-map-span-diagram 𝒮 s))
---               ( ( CB s n p) ∙
---                 ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p)) ∙
---                 ( ap
---                   ( map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)))
---                   ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∙
---                 ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))))
---         [ii] =
---           nat-lemma
---             ( concat-s-inf 𝒮 a₀ s)
---             ( ev-pair (map-family-descent-data-pushout R) s)
---             ( [i] p)
---         [iii] :
---           coherence-square-maps
---             ( ( tr
---                 ( λ p →
---                   left-family-descent-data-pushout R
---                     ( left-map-span-diagram 𝒮 s ,
---                       map-cocone-standard-sequential-colimit (succ-ℕ n) p))
---                 ( glue-pushout _ _ (s , refl , p))) ∘
---               ( tr
---                 ( ev-pair
---                   ( left-family-descent-data-pushout R)
---                   ( left-map-span-diagram 𝒮 s))
---                 ( coherence-cocone-standard-sequential-colimit n p)))
---             ( map-family-descent-data-pushout R
---               ( s , map-cocone-standard-sequential-colimit n p))
---             ( map-family-descent-data-pushout R
---               ( s ,
---                 map-cocone-standard-sequential-colimit
---                   ( succ-ℕ n)
---                   ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))
---             ( ( tr
---                 ( ev-pair
---                   ( right-family-descent-data-pushout R)
---                   ( right-map-span-diagram 𝒮 s))
---                 ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
---               ( tr
---                 ( λ p →
---                   right-family-descent-data-pushout R
---                     ( right-map-span-diagram 𝒮 s ,
---                       map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
---                 ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
---               ( tr
---                 ( ev-pair
---                   ( right-family-descent-data-pushout R)
---                   ( right-map-span-diagram 𝒮 s))
---                 ( coherence-cocone-standard-sequential-colimit
---                   ( succ-ℕ n)
---                   ( concat-s 𝒮 a₀ s n p))) ∘
---               ( tr
---                 ( ev-pair
---                   ( right-family-descent-data-pushout R)
---                   ( right-map-span-diagram 𝒮 s))
---                 ( CB s n p)))
---         [iii] = {! annoying straightforward path algebra from [ii] !}
---         [key]'' :
---           tr
---             ( λ p →
---               left-family-descent-data-pushout R
---                 ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
---             ( glue-pushout _ _ (s , refl , p))
---             ( tr
---               ( ev-pair (left-family-descent-data-pushout R) (left-map-span-diagram 𝒮 s))
---               ( coherence-cocone-standard-sequential-colimit n p)
---               ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
---           inv-map-family-descent-data-pushout R
---             ( s ,
---               map-cocone-standard-sequential-colimit
---                 ( succ-ℕ n)
---                 ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
---             ( ( ( tr
---                   ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---                   ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
---                 ( tr
---                   ( λ p →
---                     right-family-descent-data-pushout R
---                       ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
---                   ( glue-pushout _ _ (s , refl , (concat-s 𝒮 a₀ s n p)))) ∘
---                 ( tr
---                   ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---                   ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))
---               ( tr
---                 ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---                 ( CB s n p)
---                 ( map-family-descent-data-pushout R
---                   ( s , map-cocone-standard-sequential-colimit n p)
---                   ( tA (left-map-span-diagram 𝒮 s) n p))))
---         [key]'' =
---           map-eq-transpose-equiv
---             ( equiv-family-descent-data-pushout R
---               ( s ,
---                 map-cocone-standard-sequential-colimit
---                   ( succ-ℕ n)
---                   ( concat-inv-s 𝒮 a₀ s
---                     ( succ-ℕ n)
---                     ( concat-s 𝒮 a₀ s n p))))
---             ( inv
---               ( [iii] (tA (left-map-span-diagram 𝒮 s) n p)))
---         [key]' :
---           tr
---             ( λ p →
---               left-family-descent-data-pushout R
---                 ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
---             ( glue-pushout _ _ (s , refl , p))
---             ( tr
---               ( ev-pair (left-family-descent-data-pushout R) (left-map-span-diagram 𝒮 s))
---               ( coherence-cocone-standard-sequential-colimit n p)
---               ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
---           inv-map-family-descent-data-pushout R
---             ( s ,
---               map-cocone-standard-sequential-colimit
---                 ( succ-ℕ n)
---                 ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
---             ( foo s n (concat-s 𝒮 a₀ s n p) (tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)))
---         [key]' = {!folded foo and tB from [key]''!}
---         [key] :
---           tr
---             ( λ p →
---               left-family-descent-data-pushout R
---                 ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p))
---             ( glue-pushout _ _ (s , refl , p))
---             ( pr1 (cocone-tA (left-map-span-diagram 𝒮 s) n) p) ＝
---           (pr1 (pr2 (cocone-tA (left-map-span-diagram 𝒮 s) n)) (s , refl , concat-s 𝒮 a₀ s n p))
---         [key] = {!folded cocone-tA from [key]'!}
-
---       tS s n p =
---         inv
---           ( compute-inr-dependent-cogap _ _
---             ( cocone-tB (right-map-span-diagram 𝒮 s) n)
---             ( s , refl , p))
-
---       alt-tS :
---         (s : spanning-type-span-diagram 𝒮) →
---         (n : ℕ) →
---         (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---         map-family-descent-data-pushout R
---           ( s , map-cocone-standard-sequential-colimit n p)
---           ( tAA
---             ( left-map-span-diagram 𝒮 s)
---             ( map-cocone-standard-sequential-colimit n p)) ＝
---         tBB
---           ( right-map-span-diagram 𝒮 s)
---           ( concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
---       alt-tS s n p =
---         {!tS s n p!}
---         where
---         [ii] =
---           pr1
---             ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
---               ( dup-standard-sequential-colimit)
---               ( cocone-tAA (left-map-span-diagram 𝒮 s)))
---             ( n)
---             ( p)
---         [i] =
---           apd
---             ( map-family-descent-data-pushout R (s , map-cocone-standard-sequential-colimit n p))
---             ( [ii])
-
---       tSS s = dependent-cogap-standard-sequential-colimit (cocone-tSS s)
-
---       pr1 (cocone-tAA a) = tA a
---       pr2 (cocone-tAA a) n p = inv (compute-inl-dependent-cogap _ _ (cocone-tA a n) p)
-
---       pr1 (cocone-tBB b) = tB b
---       pr2 (cocone-tBB b) n p = inv (compute-inl-dependent-cogap _ _ (cocone-tB b n) p)
-
---       pr1 (cocone-tSS s) = alt-tS s
---       pr2 (cocone-tSS s) = {!!}
-
---     alt-tS-tS-equiv :
---       (s : spanning-type-span-diagram 𝒮) →
---       {!!}
---       -- (n : ℕ) →
---       -- (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---       -- {!!} ≃ {!!}
---     alt-tS-tS-equiv s =
---       tS-equiv-tS
---         ( up-standard-sequential-colimit)
---         ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
---         ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
---         ( λ p → left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , p))
---         ( λ p → right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , p))
---         ( λ p → equiv-family-descent-data-pushout R (s , p))
---         ( tA (left-map-span-diagram 𝒮 s))
---         -- ( λ where
---         --   zero-ℕ (map-raise refl) → inv (compute-inl-dependent-cogap _ _ (cocone-tA (left-map-span-diagram 𝒮 s) 0) _ ∙ {!!})
---         --   (succ-ℕ n) a → {!!} )
---         ( λ n p →
---           inv
---             ( ( compute-inl-dependent-cogap _ _ (cocone-tA (left-map-span-diagram 𝒮 s) n) p) ∙
---               {!refl!}))
---         ( λ n → tB (right-map-span-diagram 𝒮 s) (succ-ℕ n))
---         ( {!!})
+    tB :
+      (b : codomain-span-diagram 𝒮) (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
+      right-family-descent-data-pushout R
+        ( b , map-cocone-standard-sequential-colimit n p)
+    tB b zero-ℕ (map-raise ())
+    tB b (succ-ℕ n) = dependent-cogap _ _ (pr1 (stages-cocones' n) b)
 
+    tA :
+      (a : domain-span-diagram 𝒮) (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
+      left-family-descent-data-pushout R
+        ( a , map-cocone-standard-sequential-colimit n p)
+    tA .a₀ zero-ℕ (map-raise refl) = r₀
+    tA a (succ-ℕ n) = dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a)
 
     ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
     pr1 ind-singleton-zigzag-id-pushout' (a , p) =
       dependent-cogap-standard-sequential-colimit
-        ( tA , KA)
+        ( tA a , KA)
         ( p)
       where
-      tA :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
-        left-family-descent-data-pushout R
-          ( a , map-cocone-standard-sequential-colimit n p)
-      tA zero-ℕ (map-raise refl) = r₀
-      tA (succ-ℕ n) = dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a)
       KA :
         (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
         dependent-identification
           ( ev-pair (left-family-descent-data-pushout R) a)
           ( coherence-cocone-standard-sequential-colimit n p)
-          ( tA n p)
-          ( tA (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p))
+          ( tA a n p)
+          ( tA a (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p))
       KA zero-ℕ (map-raise refl) =
         inv
           ( compute-inl-dependent-cogap _ _
@@ -1223,22 +703,16 @@ module _
             ( p))
     pr1 (pr2 ind-singleton-zigzag-id-pushout') (b , p) =
       dependent-cogap-standard-sequential-colimit
-        ( tB , KB)
+        ( tB b , KB)
         ( p)
       where
-      tB :
-        (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
-        right-family-descent-data-pushout R
-          ( b , map-cocone-standard-sequential-colimit n p)
-      tB zero-ℕ (map-raise ())
-      tB (succ-ℕ n) = dependent-cogap _ _ (pr1 (stages-cocones' n) b)
       KB :
         (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
         dependent-identification
           ( ev-pair (right-family-descent-data-pushout R) b)
           ( coherence-cocone-standard-sequential-colimit n p)
-          ( tB n p)
-          ( tB (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
+          ( tB b n p)
+          ( tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
       KB zero-ℕ (map-raise ())
       KB (succ-ℕ n) p =
         inv
@@ -1246,7 +720,73 @@ module _
             ( pr1 (stages-cocones' (succ-ℕ n)) b)
             ( p))
     pr2 (pr2 ind-singleton-zigzag-id-pushout') (s , p) =
-      {!!}
+      dependent-cogap-standard-sequential-colimit
+        ( tS , KS)
+        ( p)
+      where
+      [i] :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        tr
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( CB s n p)
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit n p)
+            ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+        tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
+      [i] zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
+      [i] (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
+      tS :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p)
+          ( pr1
+            ( ind-singleton-zigzag-id-pushout')
+            ( left-map-span-diagram 𝒮 s ,
+              map-cocone-standard-sequential-colimit n p)) ＝
+        pr1
+          ( pr2 ind-singleton-zigzag-id-pushout')
+          ( right-map-span-diagram 𝒮 s ,
+            concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
+      tS n p =
+        ( ap
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit n p))
+          ( compute-incl-dependent-cogap-standard-sequential-colimit _ n p)) ∙
+        ( map-equiv
+          ( inv-equiv-ap-emb
+            ( emb-equiv
+              ( equiv-tr
+                ( ev-pair
+                  ( right-family-descent-data-pushout R)
+                  ( right-map-span-diagram 𝒮 s))
+                ( CB s n p))))
+          ( [i] n p ∙
+            inv
+              ( ( apd
+                  ( dependent-cogap-standard-sequential-colimit (tB (right-map-span-diagram 𝒮 s) , _))
+                  ( CB s n p)) ∙
+                ( compute-incl-dependent-cogap-standard-sequential-colimit _ (succ-ℕ n) _))))
+      KS :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        tr
+          ( λ p →
+            map-family-descent-data-pushout R
+              ( s , p)
+              ( pr1
+                ( ind-singleton-zigzag-id-pushout')
+                ( left-map-span-diagram 𝒮 s , p)) ＝
+            pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p))
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tS n p) ＝
+        tS (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n p)
+      KS n p =
+        map-compute-dependent-identification-eq-value _ _
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( _)
+          ( _)
+          ( {!!})
 
   is-identity-system-zigzag-id-pushout :
     is-identity-system-descent-data-pushout

From 2b323e4e40e1dbbcb23210093e78069f0bea547a Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 24 Jul 2024 17:09:57 +0200
Subject: [PATCH 09/33] Abstractions

---
 .../morphisms-descent-data-pushouts.lagda.md  |  10 +-
 ...nstruction-identity-type-pushouts.lagda.md | 285 +++++++++++++-----
 2 files changed, 218 insertions(+), 77 deletions(-)

diff --git a/src/synthetic-homotopy-theory/morphisms-descent-data-pushouts.lagda.md b/src/synthetic-homotopy-theory/morphisms-descent-data-pushouts.lagda.md
index 27f747d90f..98d068c27f 100644
--- a/src/synthetic-homotopy-theory/morphisms-descent-data-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/morphisms-descent-data-pushouts.lagda.md
@@ -74,7 +74,7 @@ homotopies
                  HB(gs) ·r PS s
   hB(gs) ∘ PS s ---------------> kB(gs) ∘ PS s
          |                              |
-    hS s |                              | tS s
+    hS s |                              | kS s
          |                              |
          ∨                              ∨
   QS s ∘ hA(fs) ---------------> QS s ∘ kA(fs)
@@ -83,10 +83,10 @@ homotopies
 
 [commutes](foundation-core.commuting-squares-of-homotopies.md). This coherence
 datum may be seen as a filler of the diagram one gets by gluing the squares `hS`
-and `tS` along the common vertical maps
+and `kS` along the common vertical maps
 
 ```text
-             tA(fs)
+             kA(fs)
             ________
            /        ∨
      PA(fs)          QA(fs)
@@ -94,7 +94,7 @@ and `tS` along the common vertical maps
        |     hA(fs)    |
        |               |
   PS s |               | QS s
-       |     tB(gs)    |
+       |     kB(gs)    |
        |    ________   |
        ∨   /        ∨  ∨
      PB(gs)          QB(gs).
@@ -102,7 +102,7 @@ and `tS` along the common vertical maps
              hB(gs)
 ```
 
-The front and back faces are `hS s` and `tS s`, and the top and bottom faces are
+The front and back faces are `hS s` and `kS s`, and the top and bottom faces are
 `HA(fs)` and `HB(gs)`, respectively. `HS` then expresses that going along the
 front face and then the top face is homotopic to first going along the bottom
 face and then the back face.
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index b2c0f4d734..c604b996dd 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -339,6 +339,21 @@ module _
           ( hom-diagram-zigzag-sequential-diagram
             ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
 
+      Ψ :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        left-family-descent-data-pushout R
+          ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p) →
+        right-family-descent-data-pushout R
+          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
+      Ψ s n p =
+        ( tr
+          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+          ( CB s n p)) ∘
+        ( map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p))
+
       Φ :
         (s : spanning-type-span-diagram 𝒮) →
         (n : ℕ) →
@@ -361,6 +376,19 @@ module _
           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
 
+      Φ' :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+        right-family-descent-data-pushout R
+          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
+        left-family-descent-data-pushout R
+          ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+      Φ' s n p =
+        ( inv-map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))) ∘
+        ( Φ s n p)
+
     coh-dep-cocone-a :
       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
@@ -487,6 +515,99 @@ module _
         ( ap-concat-htpy' _
           ( inv-htpy-assoc-htpy _ _ _))
 
+    α :
+      (s : spanning-type-span-diagram 𝒮) →
+      (n : ℕ) →
+      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+      coherence-square-maps
+        ( Ψ s n p)
+        ( tr
+          ( ev-pair
+            ( left-family-descent-data-pushout R)
+            ( left-map-span-diagram 𝒮 s))
+          ( coherence-cocone-standard-sequential-colimit n p))
+        ( Φ' s n (concat-s 𝒮 a₀ s n p))
+        ( tr
+          ( λ p →
+            left-family-descent-data-pushout R
+              ( left-map-span-diagram 𝒮 s ,
+                map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+          ( glue-pushout _ _ (s , refl , p)))
+    α s n p q =
+      map-eq-transpose-equiv
+        ( equiv-family-descent-data-pushout R
+          ( s ,
+            map-cocone-standard-sequential-colimit
+              ( succ-ℕ n)
+              ( concat-inv-s 𝒮 a₀ s
+                ( succ-ℕ n)
+                ( concat-s 𝒮 a₀ s n p))))
+        ( inv (coh-dep-cocone-a s n p q))
+
+    β :
+      (s : spanning-type-span-diagram 𝒮) →
+      (n : ℕ) →
+      (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+      coherence-square-maps
+        ( Φ' s n p)
+        ( tr
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
+        ( Ψ s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+        ( tr
+          ( λ p →
+            right-family-descent-data-pushout R
+              ( right-map-span-diagram 𝒮 s ,
+                map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+          ( glue-pushout _ _ (s , refl , p)))
+    β s n p q =
+      inv
+        ( ( ap
+            ( tr _ _)
+            ( is-section-map-inv-equiv
+              ( equiv-family-descent-data-pushout R
+                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+              ( _)) ∙
+          ( is-section-map-inv-equiv
+            ( equiv-tr _ _)
+            ( _))))
+        -- inv
+        --   ( ( ap
+        --       ( λ q →
+        --         tr
+        --           ( ev-pair
+        --             ( right-family-descent-data-pushout R)
+        --             ( right-map-span-diagram 𝒮 s))
+        --           ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+        --           ( map-family-descent-data-pushout R
+        --             ( s ,
+        --               ( map-cocone-standard-sequential-colimit
+        --                 ( succ-ℕ n)
+        --                 ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        --             ( q)))
+        --       ( ( compute-inr-dependent-cogap _ _
+        --           ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
+        --           ( s , refl , p)) ∙
+        --         ( pr2 (pr2 (stages-cocones' n)) s p))) ∙
+        --     ( ap
+        --       ( tr
+        --         ( ev-pair
+        --           ( right-family-descent-data-pushout R)
+        --           ( right-map-span-diagram 𝒮 s))
+        --         ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        --       ( is-section-map-inv-equiv
+        --         ( equiv-family-descent-data-pushout R
+        --           ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        --         ( Φ s n p (dependent-cogap _ _
+        --           ( pr1 (stages-cocones' n) (right-map-span-diagram 𝒮 s)) p)))) ∙
+        --     ( is-section-map-inv-equiv
+        --       ( equiv-tr
+        --         ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+        --         ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        --       ( _)))
+
 
     stages-cocones' :
       (n : ℕ) →
@@ -511,9 +632,7 @@ module _
               vertical-map-dependent-cocone _ _ _ _
                 ( dep-cocone-a (left-map-span-diagram 𝒮 s))
                 ( s , refl , p) ＝
-              inv-map-family-descent-data-pushout R
-                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-                ( Φ s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))))
+              Φ' s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)))
     stages-cocones' zero-ℕ =
       dep-cocone-b ,
       dep-cocone-a ,
@@ -550,22 +669,27 @@ module _
           ( coherence-cocone-standard-sequential-colimit 0 (map-raise refl))
           ( r₀)
       pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
-        inv-map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit 1 (concat-inv-s 𝒮 a₀ s 1 p))
-          ( Φ s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
+        Φ' s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
       pr2 (pr2 (dep-cocone-a .a₀)) (s , refl , map-raise refl) =
-        map-eq-transpose-equiv
-          ( equiv-family-descent-data-pushout R
-            ( s ,
-              map-cocone-standard-sequential-colimit 1
-                ( concat-inv-s 𝒮 a₀ s 1 (concat-s 𝒮 a₀ s 0 (map-raise refl)))))
+        ( α s 0 (map-raise refl) r₀) ∙
+        ( ap
+          ( Φ' s 0 _)
           ( inv
-            ( ( ap
-                ( Φ s 0 (concat-s 𝒮 a₀ s 0 (map-raise refl)))
-                ( compute-inr-dependent-cogap _ _
-                  ( dep-cocone-b (right-map-span-diagram 𝒮 s))
-                  (s , refl , map-raise refl))) ∙
-              ( coh-dep-cocone-a s 0 (map-raise refl) r₀)))
+            ( compute-inr-dependent-cogap _ _
+              ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+              ( s , refl , map-raise refl))))
+        -- map-eq-transpose-equiv
+        --   ( equiv-family-descent-data-pushout R
+        --     ( s ,
+        --       map-cocone-standard-sequential-colimit 1
+        --         ( concat-inv-s 𝒮 a₀ s 1 (concat-s 𝒮 a₀ s 0 (map-raise refl)))))
+        --   ( inv
+        --     ( ( ap
+        --         ( Φ s 0 (concat-s 𝒮 a₀ s 0 (map-raise refl)))
+        --         ( compute-inr-dependent-cogap _ _
+        --           ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+        --           (s , refl , map-raise refl))) ∙
+        --       ( coh-dep-cocone-a s 0 (map-raise refl) r₀)))
     stages-cocones' (succ-ℕ n) =
       dep-cocone-b ,
       dep-cocone-a ,
@@ -593,40 +717,48 @@ module _
             ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
             ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))
       pr2 (pr2 (dep-cocone-b b)) (s , refl , p) =
-        inv
-          ( ( ap
-              ( λ q →
-                tr
-                  ( ev-pair
-                    ( right-family-descent-data-pushout R)
-                    ( right-map-span-diagram 𝒮 s))
-                  ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-                  ( map-family-descent-data-pushout R
-                    ( s ,
-                      ( map-cocone-standard-sequential-colimit
-                        ( succ-ℕ n)
-                        ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-                    ( q)))
-              ( ( compute-inr-dependent-cogap _ _
-                  ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
-                  ( s , refl , p)) ∙
-                ( pr2 (pr2 (stages-cocones' n)) s p))) ∙
-            ( ap
-              ( tr
-                ( ev-pair
-                  ( right-family-descent-data-pushout R)
-                  ( right-map-span-diagram 𝒮 s))
-                ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-              ( is-section-map-inv-equiv
-                ( equiv-family-descent-data-pushout R
-                  ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-                ( Φ s n p (dependent-cogap _ _
-                  ( pr1 (stages-cocones' n) (right-map-span-diagram 𝒮 s)) p)))) ∙
-            ( is-section-map-inv-equiv
-              ( equiv-tr
-                ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-                ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-              ( _)))
+        ( β s n p _) ∙
+        ( ap
+          ( Ψ s (succ-ℕ n) _)
+          ( inv
+            ( ( compute-inr-dependent-cogap _ _
+                ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
+                ( s , refl , p)) ∙
+              ( pr2 (pr2 (stages-cocones' n)) s p))))
+        -- inv
+        --   ( ( ap
+        --       ( λ q →
+        --         tr
+        --           ( ev-pair
+        --             ( right-family-descent-data-pushout R)
+        --             ( right-map-span-diagram 𝒮 s))
+        --           ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+        --           ( map-family-descent-data-pushout R
+        --             ( s ,
+        --               ( map-cocone-standard-sequential-colimit
+        --                 ( succ-ℕ n)
+        --                 ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        --             ( q)))
+        --       ( ( compute-inr-dependent-cogap _ _
+        --           ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
+        --           ( s , refl , p)) ∙
+        --         ( pr2 (pr2 (stages-cocones' n)) s p))) ∙
+        --     ( ap
+        --       ( tr
+        --         ( ev-pair
+        --           ( right-family-descent-data-pushout R)
+        --           ( right-map-span-diagram 𝒮 s))
+        --         ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        --       ( is-section-map-inv-equiv
+        --         ( equiv-family-descent-data-pushout R
+        --           ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        --         ( Φ s n p (dependent-cogap _ _
+        --           ( pr1 (stages-cocones' n) (right-map-span-diagram 𝒮 s)) p)))) ∙
+        --     ( is-section-map-inv-equiv
+        --       ( equiv-tr
+        --         ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+        --         ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        --       ( _)))
       dep-cocone-a :
         (a : domain-span-diagram 𝒮) →
         dependent-cocone-span-diagram
@@ -640,29 +772,38 @@ module _
           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
           ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a) p)
       pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
-        inv-map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) (concat-inv-s 𝒮 a₀ s (succ-ℕ (succ-ℕ n)) p))
-          ( Φ s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
+        -- inv-map-family-descent-data-pushout R
+        --   ( s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) (concat-inv-s 𝒮 a₀ s (succ-ℕ (succ-ℕ n)) p))
+        --   ( Φ s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
+        Φ' s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
       pr2 (pr2 (dep-cocone-a a)) (s , refl , p) =
-        map-eq-transpose-equiv
-          ( equiv-family-descent-data-pushout R
-            ( s ,
-              map-cocone-standard-sequential-colimit
-                ( succ-ℕ (succ-ℕ n))
-                ( concat-inv-s 𝒮 a₀ s
-                  ( succ-ℕ (succ-ℕ n))
-                  ( concat-s 𝒮 a₀ s (succ-ℕ n) p))))
+        ( α s (succ-ℕ n) p _) ∙
+        ( ap
+          ( Φ' s (succ-ℕ n) _)
           ( inv
-            ( ( ap
-                ( Φ s (succ-ℕ n) (concat-s 𝒮 a₀ s (succ-ℕ n) p))
-                ( compute-inr-dependent-cogap _ _
-                  ( dep-cocone-b (right-map-span-diagram 𝒮 s))
-                  ( s , refl , p))) ∙
-              ( coh-dep-cocone-a s
-                ( succ-ℕ n)
-                ( p)
-                ( dependent-cogap _ _
-                  (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))))
+            ( compute-inr-dependent-cogap _ _
+              ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+              ( s , refl , p))))
+        -- map-eq-transpose-equiv
+        --   ( equiv-family-descent-data-pushout R
+        --     ( s ,
+        --       map-cocone-standard-sequential-colimit
+        --         ( succ-ℕ (succ-ℕ n))
+        --         ( concat-inv-s 𝒮 a₀ s
+        --           ( succ-ℕ (succ-ℕ n))
+        --           ( concat-s 𝒮 a₀ s (succ-ℕ n) p))))
+        --   ( inv
+        --     ( ( ap
+        --         ( Φ s (succ-ℕ n) (concat-s 𝒮 a₀ s (succ-ℕ n) p))
+        --         ( compute-inr-dependent-cogap _ _
+        --           ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+        --           ( s , refl , p))) ∙
+        --       ( coh-dep-cocone-a s
+        --         ( succ-ℕ n)
+        --         ( p)
+        --         ( dependent-cogap _ _
+        --           (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))))
+
 
     tB :
       (b : codomain-span-diagram 𝒮) (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →

From 45dc68099e6b88f0177732b0bb2304e81272a66d Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Thu, 25 Jul 2024 16:34:32 +0200
Subject: [PATCH 10/33] Minute progress

---
 .../commuting-squares-of-maps.lagda.md        | 57 +++++++++++++-
 ...sms-dependent-sequential-diagrams.lagda.md | 76 +++++++++++++++++++
 ...nstruction-identity-type-pushouts.lagda.md | 35 ---------
 3 files changed, 132 insertions(+), 36 deletions(-)

diff --git a/src/foundation/commuting-squares-of-maps.lagda.md b/src/foundation/commuting-squares-of-maps.lagda.md
index 347bb16120..57662665f2 100644
--- a/src/foundation/commuting-squares-of-maps.lagda.md
+++ b/src/foundation/commuting-squares-of-maps.lagda.md
@@ -13,7 +13,11 @@ open import foundation.action-on-identifications-binary-functions
 open import foundation.action-on-identifications-functions
 open import foundation.commuting-triangles-of-homotopies
 open import foundation.commuting-triangles-of-maps
+open import foundation.dependent-pair-types
+open import foundation.embeddings
 open import foundation.function-extensionality
+open import foundation.functoriality-dependent-function-types
+open import foundation.homotopies
 open import foundation.homotopy-algebra
 open import foundation.postcomposition-functions
 open import foundation.precomposition-functions
@@ -27,7 +31,6 @@ open import foundation-core.commuting-squares-of-homotopies
 open import foundation-core.commuting-squares-of-identifications
 open import foundation-core.equivalences
 open import foundation-core.function-types
-open import foundation-core.homotopies
 open import foundation-core.identity-types
 open import foundation-core.whiskering-identifications-concatenation
 ```
@@ -597,6 +600,58 @@ module _
             ( sq-right-top ·r top-left))))
 ```
 
+### Vertical pasting of a square with the right leg an equivalence is an equivalence
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {X : UU l4} {Y : UU l5} {Z : UU l6}
+  (top : A → X) (top-left : A → B) (top-right : X → Y) (mid : B → Y)
+  (bottom-left : B → C) (bottom-right : Y → Z) (bottom : C → Z)
+  (K : coherence-square-maps mid bottom-left bottom-right bottom)
+  (is-emb-bottom-right : is-emb bottom-right)
+  where
+
+  is-equiv-pasting-vertical-coherence-square-maps :
+    is-equiv
+      ( λ H →
+        pasting-vertical-coherence-square-maps
+          ( top)
+          ( top-left)
+          ( top-right)
+          ( mid)
+          ( bottom-left)
+          ( bottom-right)
+          ( bottom)
+          ( H)
+          ( K))
+  is-equiv-pasting-vertical-coherence-square-maps =
+    is-equiv-comp _ _
+      ( is-equiv-map-Π-is-fiberwise-equiv (λ _ → is-emb-bottom-right _ _))
+      ( is-equiv-concat-htpy (K ·r top-left) _)
+
+  equiv-pasting-vertical-coherence-square-maps :
+    coherence-square-maps top top-left top-right mid ≃
+    coherence-square-maps
+      ( top)
+      ( bottom-left ∘ top-left)
+      ( bottom-right ∘ top-right)
+      ( bottom)
+  pr1 equiv-pasting-vertical-coherence-square-maps H =
+    pasting-vertical-coherence-square-maps
+      ( top)
+      ( top-left)
+      ( top-right)
+      ( mid)
+      ( bottom-left)
+      ( bottom-right)
+      ( bottom)
+      ( H)
+      ( K)
+  pr2 equiv-pasting-vertical-coherence-square-maps =
+    is-equiv-pasting-vertical-coherence-square-maps
+```
+
 ### Distributivity of pasting squares and transposing by precomposition
 
 Given two commuting squares which can be composed horizontally (vertically), we
diff --git a/src/synthetic-homotopy-theory/morphisms-dependent-sequential-diagrams.lagda.md b/src/synthetic-homotopy-theory/morphisms-dependent-sequential-diagrams.lagda.md
index 129a0c0eca..5ce1fa4428 100644
--- a/src/synthetic-homotopy-theory/morphisms-dependent-sequential-diagrams.lagda.md
+++ b/src/synthetic-homotopy-theory/morphisms-dependent-sequential-diagrams.lagda.md
@@ -10,10 +10,13 @@ module synthetic-homotopy-theory.morphisms-dependent-sequential-diagrams where
 open import elementary-number-theory.natural-numbers
 
 open import foundation.commuting-squares-of-maps
+open import foundation.dependent-identifications
 open import foundation.dependent-pair-types
+open import foundation.transport-along-identifications
 open import foundation.universe-levels
 
 open import synthetic-homotopy-theory.dependent-sequential-diagrams
+open import synthetic-homotopy-theory.morphisms-sequential-diagrams
 open import synthetic-homotopy-theory.sequential-diagrams
 ```
 
@@ -111,3 +114,76 @@ module _
       ( map-hom-dependent-sequential-diagram)
   coh-hom-dependent-sequential-diagram = pr2 h
 ```
+
+### Morphisms of dependent sequential diagrams over morphisms of sequential diagrams
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level} {A : sequential-diagram l1} {B : sequential-diagram l2}
+  (P : dependent-sequential-diagram A l3)
+  (Q : dependent-sequential-diagram B l4)
+  (h : hom-sequential-diagram A B)
+  where
+
+  hom-dependent-sequential-diagram-over : UU (l1 ⊔ l3 ⊔ l4)
+  hom-dependent-sequential-diagram-over =
+    Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
+        family-dependent-sequential-diagram P n a →
+        family-dependent-sequential-diagram Q n
+          ( map-hom-sequential-diagram B h n a))
+      ( λ f →
+        (n : ℕ) (a : family-sequential-diagram A n) →
+        (p : family-dependent-sequential-diagram P n a) →
+        dependent-identification
+          ( family-dependent-sequential-diagram Q (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B h n a)
+          ( map-dependent-sequential-diagram Q n
+            ( map-hom-sequential-diagram B h n a)
+            ( f n a p))
+          ( f (succ-ℕ n) (map-sequential-diagram A n a) (map-dependent-sequential-diagram P n a p)))
+```
+
+## Properties
+
+### TODO
+
+```agda
+module _
+  {l1 l2 l3 : Level} {A : sequential-diagram l1} {B : sequential-diagram l2}
+  (h : hom-sequential-diagram A B)
+  where
+
+  pullback-hom-dependent-sequential-diagram :
+    dependent-sequential-diagram B l3 →
+    dependent-sequential-diagram A l3
+  pr1 (pullback-hom-dependent-sequential-diagram Q) n a =
+    family-dependent-sequential-diagram Q n
+      ( map-hom-sequential-diagram B h n a)
+  pr2 (pullback-hom-dependent-sequential-diagram Q) n a q =
+    tr
+      ( family-dependent-sequential-diagram Q (succ-ℕ n))
+      ( naturality-map-hom-sequential-diagram B h n a)
+      ( map-dependent-sequential-diagram Q n
+        ( map-hom-sequential-diagram B h n a)
+        ( q))
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level} {A : sequential-diagram l1} {B : sequential-diagram l2}
+  {P : dependent-sequential-diagram A l3}
+  {Q : dependent-sequential-diagram B l4}
+  (h : hom-sequential-diagram A B)
+  where
+
+  open import foundation.homotopies
+
+  hom-dep-seq-diag-over-hom-dep-seq-diag :
+    hom-dependent-sequential-diagram P
+      ( pullback-hom-dependent-sequential-diagram h Q) →
+    hom-dependent-sequential-diagram-over P Q h
+  pr1 (hom-dep-seq-diag-over-hom-dep-seq-diag h') =
+    map-hom-dependent-sequential-diagram (pullback-hom-dependent-sequential-diagram h Q) h'
+  pr2 (hom-dep-seq-diag-over-hom-dep-seq-diag h') n a =
+    inv-htpy (coh-hom-dependent-sequential-diagram (pullback-hom-dependent-sequential-diagram h Q) h' n a)
+```
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index c604b996dd..b41da123c1 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -573,41 +573,6 @@ module _
           ( is-section-map-inv-equiv
             ( equiv-tr _ _)
             ( _))))
-        -- inv
-        --   ( ( ap
-        --       ( λ q →
-        --         tr
-        --           ( ev-pair
-        --             ( right-family-descent-data-pushout R)
-        --             ( right-map-span-diagram 𝒮 s))
-        --           ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-        --           ( map-family-descent-data-pushout R
-        --             ( s ,
-        --               ( map-cocone-standard-sequential-colimit
-        --                 ( succ-ℕ n)
-        --                 ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-        --             ( q)))
-        --       ( ( compute-inr-dependent-cogap _ _
-        --           ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
-        --           ( s , refl , p)) ∙
-        --         ( pr2 (pr2 (stages-cocones' n)) s p))) ∙
-        --     ( ap
-        --       ( tr
-        --         ( ev-pair
-        --           ( right-family-descent-data-pushout R)
-        --           ( right-map-span-diagram 𝒮 s))
-        --         ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-        --       ( is-section-map-inv-equiv
-        --         ( equiv-family-descent-data-pushout R
-        --           ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-        --         ( Φ s n p (dependent-cogap _ _
-        --           ( pr1 (stages-cocones' n) (right-map-span-diagram 𝒮 s)) p)))) ∙
-        --     ( is-section-map-inv-equiv
-        --       ( equiv-tr
-        --         ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-        --         ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-        --       ( _)))
-
 
     stages-cocones' :
       (n : ℕ) →

From 8497e70472998e299aa953977ca4504888a6b76d Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 21 Aug 2024 18:15:33 +0200
Subject: [PATCH 11/33] WIP

---
 ...on-types-over-sequential-colimits.lagda.md |  91 ++++++++
 .../descent-data-sequential-colimits.lagda.md |  33 +++
 ...cent-property-sequential-colimits.lagda.md | 211 ++++++++++++++++++
 ...ces-dependent-sequential-diagrams.lagda.md |  57 ++++-
 ...-descent-data-sequential-colimits.lagda.md |   2 +-
 5 files changed, 392 insertions(+), 2 deletions(-)
 create mode 100644 src/synthetic-homotopy-theory/descent-data-function-types-over-sequential-colimits.lagda.md

diff --git a/src/synthetic-homotopy-theory/descent-data-function-types-over-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/descent-data-function-types-over-sequential-colimits.lagda.md
new file mode 100644
index 0000000000..1a615a1cae
--- /dev/null
+++ b/src/synthetic-homotopy-theory/descent-data-function-types-over-sequential-colimits.lagda.md
@@ -0,0 +1,91 @@
+# Descent data for type families of function types over sequential colimits
+
+```agda
+{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
+
+module synthetic-homotopy-theory.descent-data-function-types-over-sequential-colimits where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+-- open import foundation.commuting-squares-of-maps
+-- open import foundation.commuting-triangles-of-maps
+-- open import foundation.contractible-maps
+-- open import foundation.contractible-types
+open import foundation.dependent-pair-types
+open import foundation.equivalences
+-- open import foundation.fibers-of-maps
+-- open import foundation.function-extensionality
+-- open import foundation.function-types
+-- open import foundation.functoriality-dependent-function-types
+-- open import foundation.functoriality-dependent-pair-types
+-- open import foundation.homotopies
+-- open import foundation.homotopy-algebra
+open import foundation.postcomposition-functions
+-- open import foundation.transport-along-identifications
+open import foundation.universal-property-equivalences
+open import foundation.universe-levels
+-- open import foundation.whiskering-homotopies-composition
+
+open import synthetic-homotopy-theory.cocones-under-sequential-diagrams
+open import synthetic-homotopy-theory.descent-data-sequential-colimits
+-- open import synthetic-homotopy-theory.equivalences-descent-data-pushouts
+open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
+-- open import synthetic-homotopy-theory.morphisms-descent-data-pushouts
+-- open import synthetic-homotopy-theory.sections-descent-data-pushouts
+open import synthetic-homotopy-theory.sequential-diagrams
+-- open import synthetic-homotopy-theory.universal-property-pushouts
+```
+
+## Idea
+
+## Definitions
+
+### TODO
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 : Level} {A : sequential-diagram l1}
+  {X : UU l3} {c : cocone-sequential-diagram A X}
+  (P : family-with-descent-data-sequential-colimit c l4)
+  (Q : family-with-descent-data-sequential-colimit c l5)
+  where
+
+  family-cocone-function-type-sequential-colimit : X → UU (l4 ⊔ l5)
+  family-cocone-function-type-sequential-colimit x =
+    family-cocone-family-with-descent-data-sequential-colimit P x →
+    family-cocone-family-with-descent-data-sequential-colimit Q x
+
+  descent-data-function-type-sequential-colimit :
+    descent-data-sequential-colimit A (l4 ⊔ l5)
+  pr1 descent-data-function-type-sequential-colimit n a =
+    family-family-with-descent-data-sequential-colimit P n a →
+    family-family-with-descent-data-sequential-colimit Q n a
+  pr2 descent-data-function-type-sequential-colimit n a =
+    ( equiv-postcomp _
+      ( equiv-family-family-with-descent-data-sequential-colimit Q n a)) ∘e
+    ( equiv-precomp
+      ( inv-equiv (equiv-family-family-with-descent-data-sequential-colimit P n a))
+      ( _))
+```
+
+## Properties
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level} {A : sequential-diagram l1}
+  {X : UU l2} {c : cocone-sequential-diagram A X}
+  (P : family-with-descent-data-sequential-colimit c l3)
+  (Q : family-with-descent-data-sequential-colimit c l4)
+  where
+
+  equiv-hom-descent-data-map-family-cocone-sequential-diagram :
+    ( (x : X) →
+      family-cocone-family-with-descent-data-sequential-colimit P x →
+      family-cocone-family-with-descent-data-sequential-colimit Q x) ≃
+    ( hom-descent-data-sequential-colimit
+      ( descent-data-family-with-descent-data-sequential-colimit P)
+      ( descent-data-family-with-descent-data-sequential-colimit Q))
+  equiv-hom-descent-data-map-family-cocone-sequential-diagram = {!!}
+```
diff --git a/src/synthetic-homotopy-theory/descent-data-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/descent-data-sequential-colimits.lagda.md
index d498ebe3db..2114f82abb 100644
--- a/src/synthetic-homotopy-theory/descent-data-sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/descent-data-sequential-colimits.lagda.md
@@ -180,6 +180,39 @@ module _
   id-equiv-descent-data-sequential-colimit =
     id-equiv-dependent-sequential-diagram
       ( dependent-sequential-diagram-equifibered-sequential-diagram B)
+
+module _
+  {l1 l2 l3 l4 : Level} {A : sequential-diagram l1}
+  (B : descent-data-sequential-colimit A l2)
+  (C : descent-data-sequential-colimit A l3)
+  (D : descent-data-sequential-colimit A l4)
+  (f : equiv-descent-data-sequential-colimit C D)
+  (e : equiv-descent-data-sequential-colimit B C)
+  where
+
+  comp-equiv-descent-data-sequential-colimit :
+    equiv-descent-data-sequential-colimit B D
+  comp-equiv-descent-data-sequential-colimit =
+    comp-equiv-dependent-sequential-diagram
+      ( dependent-sequential-diagram-equifibered-sequential-diagram B)
+      ( dependent-sequential-diagram-equifibered-sequential-diagram C)
+      ( dependent-sequential-diagram-equifibered-sequential-diagram D)
+      ( f)
+      ( e)
+
+module _
+  {l1 l2 l3 : Level} {A : sequential-diagram l1}
+  (B : descent-data-sequential-colimit A l2)
+  (C : descent-data-sequential-colimit A l3)
+  where
+
+  inv-equiv-descent-data-sequential-colimit :
+    equiv-descent-data-sequential-colimit B C →
+    equiv-descent-data-sequential-colimit C B
+  inv-equiv-descent-data-sequential-colimit e =
+    inv-equiv-dependent-sequential-diagram
+      ( dependent-sequential-diagram-equifibered-sequential-diagram C)
+      ( e)
 ```
 
 ### Descent data induced by families over cocones under sequential diagrams
diff --git a/src/synthetic-homotopy-theory/descent-property-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/descent-property-sequential-colimits.lagda.md
index 20b9c33dc7..e41aa18fa6 100644
--- a/src/synthetic-homotopy-theory/descent-property-sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/descent-property-sequential-colimits.lagda.md
@@ -10,6 +10,7 @@ module synthetic-homotopy-theory.descent-property-sequential-colimits where
 open import elementary-number-theory.natural-numbers
 
 open import foundation.binary-homotopies
+open import foundation.commuting-squares-of-maps
 open import foundation.commuting-triangles-of-maps
 open import foundation.dependent-pair-types
 open import foundation.equality-dependent-pair-types
@@ -22,6 +23,7 @@ open import foundation.universe-levels
 
 open import synthetic-homotopy-theory.cocones-under-sequential-diagrams
 open import synthetic-homotopy-theory.descent-data-sequential-colimits
+open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
 open import synthetic-homotopy-theory.sequential-diagrams
 open import synthetic-homotopy-theory.universal-property-sequential-colimits
 ```
@@ -135,3 +137,212 @@ module _
     map-inv-equiv
       ( equiv-descent-data-family-cocone-sequential-diagram)
 ```
+
+```agda
+open import synthetic-homotopy-theory.morphisms-sequential-diagrams
+open import synthetic-homotopy-theory.morphisms-dependent-sequential-diagrams
+open import synthetic-homotopy-theory.descent-data-function-types-over-sequential-colimits
+open import foundation.action-on-identifications-functions
+open import foundation.transport-along-higher-identifications
+open import foundation.transport-along-identifications
+open import foundation.function-types
+open import foundation.whiskering-homotopies-composition
+open import foundation.homotopies
+module _
+  {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
+  {P : A → UU l3} {Q : B → UU l4}
+  (f : A → B) (h : (a : A) → P a → Q (f a))
+  where
+
+  other-nat-lemma :
+    {x y : A} (p : x ＝ y) (q : f x ＝ f y) (α : ap f p ＝ q) →
+    (z : P x) →
+    tr Q q (h x z) ＝ h y (tr P p z)
+  other-nat-lemma p q α z = inv (preserves-tr h p z ∙ (inv (substitution-law-tr Q f p) ∙ tr² Q α _))
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : sequential-diagram l1} {B : sequential-diagram l2}
+  {X : UU l3} {c : cocone-sequential-diagram A X}
+  {Y : UU l4} {c' : cocone-sequential-diagram B Y}
+  (P : family-with-descent-data-sequential-colimit c l5)
+  (Q : family-with-descent-data-sequential-colimit c' l6)
+  (f : hom-sequential-diagram A B)
+  (f∞ : X → Y)
+  (C :
+    (n : ℕ) →
+    coherence-square-maps
+      ( map-hom-sequential-diagram B f n)
+      ( map-cocone-sequential-diagram c n)
+      ( map-cocone-sequential-diagram c' n)
+      ( f∞))
+  (α :
+    (n : ℕ) →
+    ( (f∞ ·l (coherence-cocone-sequential-diagram c n)) ∙h
+      ( C (succ-ℕ n) ·r map-sequential-diagram A n)) ~
+    ( ( C n) ∙h
+      ( coherence-cocone-sequential-diagram c' n ·r (map-hom-sequential-diagram B f n)) ∙h
+      ( map-cocone-sequential-diagram c' (succ-ℕ n) ·l naturality-map-hom-sequential-diagram B f n)))
+  where
+
+  dd-alt-pullback : descent-data-sequential-colimit A l6
+  pr1 dd-alt-pullback n a =
+    family-cocone-family-with-descent-data-sequential-colimit Q
+      ( map-cocone-sequential-diagram c' n
+        ( map-hom-sequential-diagram B f n a))
+  pr2 dd-alt-pullback n a =
+    equiv-tr
+      ( family-cocone-family-with-descent-data-sequential-colimit Q)
+      ( ap
+        ( map-cocone-sequential-diagram c' (succ-ℕ n))
+        ( naturality-map-hom-sequential-diagram B f n a)) ∘e
+    equiv-tr
+      ( family-cocone-family-with-descent-data-sequential-colimit Q)
+      ( coherence-cocone-sequential-diagram c' n
+        ( map-hom-sequential-diagram B f n a))
+
+  dd-alt-precomp : descent-data-sequential-colimit A l6
+  pr1 dd-alt-precomp n a =
+    family-family-with-descent-data-sequential-colimit Q n
+      ( map-hom-sequential-diagram B f n a)
+  pr2 dd-alt-precomp n a =
+    ( equiv-tr
+      ( family-family-with-descent-data-sequential-colimit Q (succ-ℕ n))
+      ( naturality-map-hom-sequential-diagram B f n a)) ∘e
+    ( equiv-family-family-with-descent-data-sequential-colimit Q n
+      ( map-hom-sequential-diagram B f n a))
+
+  equiv-dd-foo :
+    equiv-descent-data-sequential-colimit
+      ( descent-data-family-cocone-sequential-diagram c
+        ( family-cocone-family-with-descent-data-sequential-colimit Q ∘ f∞))
+      ( dd-alt-pullback)
+  pr1 equiv-dd-foo n a =
+    equiv-tr
+      ( family-cocone-family-with-descent-data-sequential-colimit Q)
+      ( C n a)
+  pr2 equiv-dd-foo n a q =
+    ( ap
+      ( tr (family-cocone-family-with-descent-data-sequential-colimit Q) (C (succ-ℕ n) (map-sequential-diagram A n a)))
+      ( inv
+        ( substitution-law-tr
+          ( family-cocone-family-with-descent-data-sequential-colimit Q)
+          ( f∞)
+          ( coherence-cocone-sequential-diagram c n a)))) ∙
+    ( inv
+      ( tr-concat
+        ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+        ( C (succ-ℕ n) (map-sequential-diagram A n a))
+        ( q))) ∙
+    ( tr²
+      ( family-cocone-family-with-descent-data-sequential-colimit Q)
+      ( α n a)
+      ( q)) ∙
+    ( tr-concat (C n a ∙ pr2 c' n (pr1 f n a)) _ q) ∙
+    ap
+      ( tr (family-cocone-family-with-descent-data-sequential-colimit Q) (ap (pr1 c' (succ-ℕ n)) (pr2 f n a)))
+      ( tr-concat (C n a) (pr2 c' n (pr1 f n a)) q)
+
+  private
+    inv-equiv-e :
+      equiv-descent-data-sequential-colimit
+        ( descent-data-family-cocone-sequential-diagram c'
+          ( family-cocone-family-with-descent-data-sequential-colimit Q))
+        ( descent-data-family-with-descent-data-sequential-colimit Q)
+    inv-equiv-e =
+      inv-equiv-descent-data-sequential-colimit
+        ( descent-data-family-with-descent-data-sequential-colimit Q)
+        ( descent-data-family-cocone-sequential-diagram c'
+          ( family-cocone-family-with-descent-data-sequential-colimit Q))
+        ( equiv-descent-data-family-with-descent-data-sequential-colimit Q)
+
+  equiv-equiv-dd-foo' : (n : ℕ) (b : family-sequential-diagram B n) →
+    ( family-cocone-family-with-descent-data-sequential-colimit Q
+      ( map-cocone-sequential-diagram c' n b)) ≃
+    ( family-family-with-descent-data-sequential-colimit Q n b)
+  equiv-equiv-dd-foo' =
+    equiv-equiv-descent-data-sequential-colimit
+      ( descent-data-family-cocone-sequential-diagram c'
+        ( family-cocone-family-with-descent-data-sequential-colimit Q))
+      ( descent-data-family-with-descent-data-sequential-colimit Q)
+      ( inv-equiv-e)
+
+  equiv-dd-foo' :
+    equiv-descent-data-sequential-colimit
+      ( dd-alt-pullback)
+      ( dd-alt-precomp)
+  pr1 equiv-dd-foo' n a =
+    equiv-equiv-dd-foo' n (map-hom-sequential-diagram B f n a)
+  pr2 equiv-dd-foo' n a =
+    pasting-vertical-coherence-square-maps
+      ( map-equiv (equiv-equiv-dd-foo' n (map-hom-sequential-diagram B f n a)))
+      ( tr
+        ( family-cocone-family-with-descent-data-sequential-colimit Q)
+        ( pr2 c' n (pr1 f n a)))
+      ( map-family-family-with-descent-data-sequential-colimit Q n (map-hom-sequential-diagram B f n a))
+      ( map-equiv
+        ( equiv-equiv-dd-foo'
+          ( succ-ℕ n)
+          ( map-sequential-diagram B n (map-hom-sequential-diagram B f n a))))
+      ( tr
+        ( family-cocone-family-with-descent-data-sequential-colimit Q)
+        ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (pr2 f n a)))
+      ( tr
+        ( family-family-with-descent-data-sequential-colimit Q (succ-ℕ n))
+        ( pr2 f n a))
+      ( map-equiv
+        ( equiv-equiv-dd-foo'
+          ( succ-ℕ n)
+          ( map-hom-sequential-diagram B f (succ-ℕ n) (map-sequential-diagram A n a))))
+      ( coh-equiv-descent-data-sequential-colimit
+        ( descent-data-family-cocone-sequential-diagram c'
+          ( family-cocone-family-with-descent-data-sequential-colimit Q))
+        ( descent-data-family-with-descent-data-sequential-colimit Q)
+        ( inv-equiv-e)
+        ( n)
+        ( map-hom-sequential-diagram B f n a))
+      ( ( ( map-equiv
+            ( equiv-equiv-dd-foo'
+              ( succ-ℕ n)
+              ( map-hom-sequential-diagram B f
+                ( succ-ℕ n)
+                ( map-sequential-diagram A n a)))) ·l
+          ( λ z →
+            substitution-law-tr
+              ( family-cocone-family-with-descent-data-sequential-colimit Q)
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a) {z})) ∙h
+        ( inv-htpy
+          ( other-nat-lemma id
+            ( λ b → map-equiv (equiv-equiv-dd-foo' (succ-ℕ n) b))
+            ( pr2 f n a)
+            ( pr2 f n a)
+            ( ap-id (pr2 f n a)))))
+
+  hom-over-map-over :
+    ( (x : X) →
+      family-cocone-family-with-descent-data-sequential-colimit P x →
+      family-cocone-family-with-descent-data-sequential-colimit Q (f∞ x)) ≃
+    ( hom-dependent-sequential-diagram-over
+      ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)
+      ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit Q)
+      ( f))
+  hom-over-map-over =
+    ( equiv-tot
+      ( λ g →
+        equiv-Π-equiv-family
+          ( λ n → equiv-Π-equiv-family (λ a → equiv-inv-htpy _ _)))) ∘e
+    ( equiv-hom-descent-data-map-family-cocone-sequential-diagram P
+      ( family-cocone-family-with-descent-data-sequential-colimit Q ∘ f∞ ,
+        dd-alt-precomp ,
+        inv-equiv-descent-data-sequential-colimit
+          ( descent-data-family-cocone-sequential-diagram c
+            ( family-cocone-family-with-descent-data-sequential-colimit Q ∘ f∞))
+          ( dd-alt-precomp)
+          ( comp-equiv-descent-data-sequential-colimit
+            ( descent-data-family-cocone-sequential-diagram c
+              ( family-cocone-family-with-descent-data-sequential-colimit Q ∘ f∞))
+            ( dd-alt-pullback)
+            ( dd-alt-precomp)
+            ( equiv-dd-foo')
+            ( equiv-dd-foo))))
+```
diff --git a/src/synthetic-homotopy-theory/equivalences-dependent-sequential-diagrams.lagda.md b/src/synthetic-homotopy-theory/equivalences-dependent-sequential-diagrams.lagda.md
index 54b42eb7ca..e1a86f6c42 100644
--- a/src/synthetic-homotopy-theory/equivalences-dependent-sequential-diagrams.lagda.md
+++ b/src/synthetic-homotopy-theory/equivalences-dependent-sequential-diagrams.lagda.md
@@ -166,7 +166,7 @@ module _
     is-equiv-map-equiv-dependent-sequential-diagram C e
 ```
 
-### The identity equivalence of sequential diagrams
+### The identity equivalence of dependent sequential diagrams
 
 ```agda
 module _
@@ -179,6 +179,61 @@ module _
   pr2 id-equiv-dependent-sequential-diagram n a = refl-htpy
 ```
 
+### Composition of equivalences of dependent sequential diagrams
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level} {A : sequential-diagram l1}
+  (B : dependent-sequential-diagram A l2)
+  (C : dependent-sequential-diagram A l3)
+  (D : dependent-sequential-diagram A l4)
+  (f : equiv-dependent-sequential-diagram C D)
+  (e : equiv-dependent-sequential-diagram B C)
+  where
+
+  comp-equiv-dependent-sequential-diagram :
+    equiv-dependent-sequential-diagram B D
+  pr1 comp-equiv-dependent-sequential-diagram n a =
+    equiv-equiv-dependent-sequential-diagram D f n a ∘e
+    equiv-equiv-dependent-sequential-diagram C e n a
+  pr2 comp-equiv-dependent-sequential-diagram n a =
+    pasting-horizontal-coherence-square-maps
+      ( map-equiv-dependent-sequential-diagram C e n a)
+      ( map-equiv-dependent-sequential-diagram D f n a)
+      ( map-dependent-sequential-diagram B n a)
+      ( map-dependent-sequential-diagram C n a)
+      ( map-dependent-sequential-diagram D n a)
+      ( map-equiv-dependent-sequential-diagram C e (succ-ℕ n) (map-sequential-diagram A n a))
+      ( map-equiv-dependent-sequential-diagram D f (succ-ℕ n) (map-sequential-diagram A n a))
+      ( coh-equiv-dependent-sequential-diagram C e n a)
+      ( coh-equiv-dependent-sequential-diagram D f n a)
+```
+
+### The inverse of an equivalence of dependent sequential diagrams
+
+```agda
+module _
+  {l1 l2 l3 : Level} {A : sequential-diagram l1}
+  {B : dependent-sequential-diagram A l2}
+  (C : dependent-sequential-diagram A l3)
+  where
+
+  inv-equiv-dependent-sequential-diagram :
+    equiv-dependent-sequential-diagram B C →
+    equiv-dependent-sequential-diagram C B
+  pr1 (inv-equiv-dependent-sequential-diagram e) n a =
+    inv-equiv (equiv-equiv-dependent-sequential-diagram C e n a)
+  pr2 (inv-equiv-dependent-sequential-diagram e) n a =
+    horizontal-inv-equiv-coherence-square-maps
+      ( equiv-equiv-dependent-sequential-diagram C e n a)
+      ( map-dependent-sequential-diagram B n a)
+      ( map-dependent-sequential-diagram C n a)
+      ( equiv-equiv-dependent-sequential-diagram C e
+        ( succ-ℕ n)
+        ( map-sequential-diagram A n a))
+      ( coh-equiv-dependent-sequential-diagram C e n a)
+```
+
 ## Properties
 
 ### Morphisms of dependent sequential diagrams which are equivalences are equivalences of dependent sequential diagrams
diff --git a/src/synthetic-homotopy-theory/families-descent-data-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/families-descent-data-sequential-colimits.lagda.md
index 4343695a69..560da28e46 100644
--- a/src/synthetic-homotopy-theory/families-descent-data-sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/families-descent-data-sequential-colimits.lagda.md
@@ -32,7 +32,7 @@ the type of type families over
 is [equivalent](foundation-core.equivalences.md) to
 [descent data](synthetic-homotopy-theory.descent-data-sequential-colimits.md).
 
-Sometimes it is useful to consider tripes `(P, B, e)` where `P : X → 𝒰` is a
+Sometimes it is useful to consider triples `(P, B, e)` where `P : X → 𝒰` is a
 type family, `B` is descent data, and `e` is an equivalence between `B` and the
 descent data induced by `P`. The type of such pairs `(B, e)` is
 [contractible](foundation-core.contractible-types.md), so the type of these

From a54d770c1cde4b795f49d000a97871c8cc24a50b Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 15 Jan 2025 18:17:50 +0100
Subject: [PATCH 12/33] More progress

---
 ...nstruction-identity-type-pushouts.lagda.md | 2147 ++++++++++-------
 .../zigzags-sequential-diagrams.lagda.md      |   13 +-
 2 files changed, 1332 insertions(+), 828 deletions(-)

diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index b41da123c1..cb4e84aa09 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -1,7 +1,7 @@
 # The zigzag construction of identity types of pushouts
 
 ```agda
-{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
+{-# OPTIONS --lossy-unification #-}
 
 module synthetic-homotopy-theory.zigzag-construction-identity-type-pushouts where
 ```
@@ -63,844 +63,1343 @@ colimits of pushouts.
 ## Definitions
 
 ```agda
+open import foundation.commuting-triangles-of-maps
+open import foundation.homotopy-induction
+open import foundation.dependent-homotopies
 module _
-  {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2}
+  {A' : A → UU l3} (B' : B → UU l4)
+  {f g : A → B}
+  (H : f ~ g)
+  (f' : {a : A} → A' a → B' (f a))
+  (g' : {a : A} → A' a → B' (g a))
   where
 
-  type-stage-zigzag-construction-id-pushout : ℕ → UU (lsuc (l1 ⊔ l2 ⊔ l3))
-  type-stage-zigzag-construction-id-pushout n =
-    Σ ( codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
-      ( λ Path-to-b →
-        Σ ( domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
-          ( λ Path-to-a →
-            ( Σ ( (s : spanning-type-span-diagram 𝒮) →
-                  Path-to-b (right-map-span-diagram 𝒮 s) →
-                  Path-to-a (left-map-span-diagram 𝒮 s))
-                ( λ _ →
-                  rec-ℕ
-                    ( raise-unit (lsuc (l1 ⊔ l2 ⊔ l3)))
-                    ( λ _ _ →
-                      ( codomain-span-diagram 𝒮 →
-                        span-diagram
-                          ( l1 ⊔ l2 ⊔ l3)
-                          ( l1 ⊔ l2 ⊔ l3)
-                          ( l1 ⊔ l2 ⊔ l3)) ×
-                      ( domain-span-diagram 𝒮 →
-                        span-diagram
-                          ( l1 ⊔ l2 ⊔ l3)
-                          ( l1 ⊔ l2 ⊔ l3)
-                          ( l1 ⊔ l2 ⊔ l3)))
-                    ( n)))))
+  htpy-over : UU (l1 ⊔ l3 ⊔ l4)
+  htpy-over = {a : A} (a' : A' a) → dependent-identification B' (H a) (f' a') (g' a')
 
 module _
-  {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
-  (a₀ : domain-span-diagram 𝒮)
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  {s : X → A} (s' : {x : X} → X' x → A' (s x))
   where
 
-  stage-zigzag-construction-id-pushout :
-    (n : ℕ) → type-stage-zigzag-construction-id-pushout 𝒮 n
-  stage-zigzag-construction-id-pushout zero-ℕ =
-    Path-to-b ,
-    Path-to-a ,
-    ( λ s → raise-ex-falso _) ,
-    raise-star
-    where
-    Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
-    Path-to-b _ = raise-empty _
-    Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
-    Path-to-a a = raise (l2 ⊔ l3) (a₀ ＝ a)
-  stage-zigzag-construction-id-pushout (succ-ℕ n) =
-    Path-to-b ,
-    Path-to-a ,
-    ( λ s p → inr-pushout _ _ (s , refl , p)) ,
-    span-diagram-B ,
-    span-diagram-A
-    where
-    span-diagram-B :
-      codomain-span-diagram 𝒮 →
-      span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
-    span-diagram-B b =
-      make-span-diagram
-        ( pr2 ∘ pr2)
-        ( tot
-          ( λ s →
-            tot
-              ( λ r (p : pr1 (stage-zigzag-construction-id-pushout n) b) →
-                pr1
-                  ( pr2 (pr2 (stage-zigzag-construction-id-pushout n)))
-                  ( s)
-                  ( tr (pr1 (stage-zigzag-construction-id-pushout n)) r p))))
-    Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
-    Path-to-b b = standard-pushout (span-diagram-B b)
-    span-diagram-A :
-      domain-span-diagram 𝒮 →
-      span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
-    span-diagram-A a =
-      make-span-diagram
-        ( pr2 ∘ pr2)
-        ( tot
-          ( λ s →
-            tot
-              ( λ r (p : pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a) →
-                inr-standard-pushout
-                  ( span-diagram-B (right-map-span-diagram 𝒮 s))
-                  ( ( s) ,
-                    ( refl) ,
-                    ( tr
-                      ( pr1 (pr2 (stage-zigzag-construction-id-pushout n)))
-                      ( r)
-                      ( p))))))
-    Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
-    Path-to-a a = standard-pushout (span-diagram-A a)
-
-  span-diagram-path-to-b :
-    codomain-span-diagram 𝒮 → ℕ →
-    span-diagram
-      ( l1 ⊔ l2 ⊔ l3)
-      ( l1 ⊔ l2 ⊔ l3)
-      ( l1 ⊔ l2 ⊔ l3)
-  span-diagram-path-to-b b n =
-    pr1 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) b
-
-  span-diagram-path-to-a :
-    domain-span-diagram 𝒮 → ℕ →
-    span-diagram
-      ( l1 ⊔ l2 ⊔ l3)
-      ( l1 ⊔ l2 ⊔ l3)
-      ( l1 ⊔ l2 ⊔ l3)
-  span-diagram-path-to-a a n =
-    pr2 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) a
-
-  Path-to-b : codomain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
-  Path-to-b b n = pr1 (stage-zigzag-construction-id-pushout n) b
-
-  Path-to-a : domain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
-  Path-to-a a n = pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a
-
-  inl-Path-to-b :
-    (b : codomain-span-diagram 𝒮) (n : ℕ) → Path-to-b b n → Path-to-b b (succ-ℕ n)
-  inl-Path-to-b b n =
-    inl-standard-pushout
-      ( span-diagram-path-to-b b n)
-
-  inl-Path-to-a :
-    (a : domain-span-diagram 𝒮) (n : ℕ) → Path-to-a a n → Path-to-a a (succ-ℕ n)
-  inl-Path-to-a a n =
-    inl-standard-pushout
-      ( span-diagram-path-to-a a n)
-
-  concat-inv-s :
-    (s : spanning-type-span-diagram 𝒮) →
-    (n : ℕ) →
-    Path-to-b (right-map-span-diagram 𝒮 s) n →
-    Path-to-a (left-map-span-diagram 𝒮 s) n
-  concat-inv-s s n = pr1 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
-
-  concat-s :
-    (s : spanning-type-span-diagram 𝒮) →
-    (n : ℕ) →
-    Path-to-a (left-map-span-diagram 𝒮 s) n →
-    Path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n)
-  concat-s s n p =
-    inr-standard-pushout
-      ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) n)
-      ( s , refl , p)
-
-  right-sequential-diagram-zigzag-id-pushout :
-    codomain-span-diagram 𝒮 →
-    sequential-diagram (l1 ⊔ l2 ⊔ l3)
-  pr1 (right-sequential-diagram-zigzag-id-pushout b) = Path-to-b b
-  pr2 (right-sequential-diagram-zigzag-id-pushout b) = inl-Path-to-b b
-
-  left-sequential-diagram-zigzag-id-pushout :
-    domain-span-diagram 𝒮 →
-    sequential-diagram (l1 ⊔ l2 ⊔ l3)
-  pr1 (left-sequential-diagram-zigzag-id-pushout a) = Path-to-a a
-  pr2 (left-sequential-diagram-zigzag-id-pushout a) = inl-Path-to-a a
-
-  zigzag-sequential-diagram-zigzag-id-pushout :
-    (s : spanning-type-span-diagram 𝒮) →
-    zigzag-sequential-diagram
-      ( left-sequential-diagram-zigzag-id-pushout
-        ( left-map-span-diagram 𝒮 s))
-      ( shift-once-sequential-diagram
-        ( right-sequential-diagram-zigzag-id-pushout
-          ( right-map-span-diagram 𝒮 s)))
-  pr1 (zigzag-sequential-diagram-zigzag-id-pushout s) =
-    concat-s s
-  pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s)) n =
-    concat-inv-s s (succ-ℕ n)
-  pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
-    glue-standard-pushout
-      ( span-diagram-path-to-a (left-map-span-diagram 𝒮 s) n)
-      ( s , refl , p)
-  pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
-    glue-standard-pushout
-      ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n))
-      ( s , refl , p)
-
-  left-id-pushout : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
-  left-id-pushout a =
-    standard-sequential-colimit (left-sequential-diagram-zigzag-id-pushout a)
-
-  refl-id-pushout : left-id-pushout a₀
-  refl-id-pushout =
-    map-cocone-standard-sequential-colimit 0 (map-raise refl)
-
-  right-id-pushout : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
-  right-id-pushout b =
-    standard-sequential-colimit (right-sequential-diagram-zigzag-id-pushout b)
-
-  equiv-id-pushout :
-    (s : spanning-type-span-diagram 𝒮) →
-    left-id-pushout (left-map-span-diagram 𝒮 s) ≃
-    right-id-pushout (right-map-span-diagram 𝒮 s)
-  equiv-id-pushout s =
-    equiv-colimit-zigzag-sequential-diagram _ _
-      ( up-standard-sequential-colimit)
-      ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
-      ( zigzag-sequential-diagram-zigzag-id-pushout s)
-
-  concat-inv-s-inf :
-    (s : spanning-type-span-diagram 𝒮) →
-    right-id-pushout (right-map-span-diagram 𝒮 s) →
-    left-id-pushout (left-map-span-diagram 𝒮 s)
-  concat-inv-s-inf s =
-    map-inv-equiv (equiv-id-pushout s)
-
-  concat-s-inf :
-    (s : spanning-type-span-diagram 𝒮) →
-    left-id-pushout (left-map-span-diagram 𝒮 s) →
-    right-id-pushout (right-map-span-diagram 𝒮 s)
-  concat-s-inf s =
-    map-equiv (equiv-id-pushout s)
-
-  descent-data-zigzag-id-pushout : descent-data-pushout 𝒮 (l1 ⊔ l2 ⊔ l3)
-  pr1 descent-data-zigzag-id-pushout = left-id-pushout
-  pr1 (pr2 descent-data-zigzag-id-pushout) = right-id-pushout
-  pr2 (pr2 descent-data-zigzag-id-pushout) = equiv-id-pushout
-```
+  right-whisk-htpy-over : htpy-over B' (H ·r s) (f' ∘ s') (g' ∘ s')
+  right-whisk-htpy-over a' = H' (s' a')
 
-## Theorem
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  {s : B → X} (s' : {b : B} → B' b → X' (s b))
+  where
 
-### TODO
+  left-whisk-htpy-over : htpy-over X' (s ·l H) (s' ∘ f') (s' ∘ g')
+  left-whisk-htpy-over =
+    ind-htpy f
+      ( λ g H →
+        {g' : {a : A} → A' a → B' (g a)} (H' : htpy-over B' H f' g') →
+        htpy-over X' (s ·l H) (s' ∘ f') (s' ∘ g'))
+      ( λ H' → s' ·l H')
+      ( H)
+      ( H')
 
-```agda
-nat-lemma :
-  {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
-  {P : A → UU l3} {Q : B → UU l4}
-  (f : A → B) (h : (a : A) → P a → Q (f a))
-  {x y : A} {p : x ＝ y}
-  {q : f x ＝ f y} (α : ap f p ＝ q) →
-  coherence-square-maps
-    ( tr P p)
-    ( h x)
-    ( h y)
-    ( tr Q q)
-nat-lemma f h {p = p} refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
-
-apd-lemma :
-  {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
-  (f : (a : A) → B a) (g : (a : A) → B a → C a) {x y : A} (p : x ＝ y) →
-  apd (λ a → g a (f a)) p ＝ inv (preserves-tr g p (f x)) ∙ ap (g y) (apd f p)
-apd-lemma f g refl = refl
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  {f g h : A → B}
+  (H : f ~ g) (K : g ~ h)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  {h' : {a : A} → A' a → B' (h a)}
+  (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' h')
+  where
+
+  concat-htpy-over : htpy-over B' (H ∙h K) f' h'
+  concat-htpy-over {a} a' =
+    concat-dependent-identification B' (H a) (K a) (H' a') (K' a')
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  (f : A → B) (g : A → X) (m : B → X)
+  (f' : {a : A} → A' a → B' (f a))
+  (g' : {a : A} → A' a → X' (g a))
+  (m' : {b : B} → B' b → X' (m b))
+  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sX : (x : X) → X' x)
+  (F : (a : A) → f' (sA a) ＝ sB (f a))
+  (G : (a : A) → g' (sA a) ＝ sX (g a))
+  (M : (b : B) → m' (sB b) ＝ sX (m b))
+  where
+
+  section-triangle-over :
+    (H : coherence-triangle-maps g m f) →
+    (H' : htpy-over X' H g' (m' ∘ f')) →
+    UU (l1 ⊔ l6)
+  section-triangle-over H H' =
+    (a : A) →
+    H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
+    ap (tr X' (H a)) (G a) ∙ apd sX (H a)
+
+  section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    UU (l1 ⊔ l6)
+  section-triangle-over' H H' =
+    (a : A) →
+    ( H' (sA a) ∙ G a) ＝
+    ( ap (tr X' (H a) ∘ m') (F a) ∙ ap (tr X' (H a)) (M (f a)) ∙ apd sX (H a))
+
+  -- actually ≐ section-triangle-over 🤔
+  -- section-triangle-over-inv :
+  --   (H : coherence-triangle-maps g m f) →
+  --   (H' : {a : A} (a' : A' a) → dependent-identification X' (H a) (g' a') (m' (f' a'))) →
+  --   UU (l1 ⊔ l6)
+  -- section-triangle-over-inv H H' =
+  --   (a : A) →
+  --   H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
+  --   ap (tr X' (H a)) (G a) ∙ apd sX (H a)
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  (f : A → B)
+  (f' : {a : A} → A' a → B' (f a))
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  where
+
+  section-map-over : UU (l1 ⊔ l4)
+  section-map-over = (a : A) → f' (sA a) ＝ sB (f a)
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {C' : C → UU l6}
+  (g : B → C) (f : A → B)
+  (g' : {b : B} → B' b → C' (g b))
+  (f' : {a : A} → A' a → B' (f a))
+  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sC : (c : C) → C' c)
+  where
+
+  comp-section-map-over :
+    section-map-over g g' sB sC → section-map-over f f' sA sB →
+    section-map-over (g ∘ f) (g' ∘ f') sA sC
+  comp-section-map-over G F =
+    g' ·l F ∙h G ·r f
 
 module _
-  {l1 l2 l3 l4 : Level} {𝒮 : span-diagram l1 l2 l3}
-  {X : UU l4} {c : cocone-span-diagram 𝒮 X}
-  (up-c : universal-property-pushout _ _ c)
-  (a₀ : domain-span-diagram 𝒮)
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
   where
 
+  section-htpy-over : UU (l1 ⊔ l4)
+  section-htpy-over =
+    (a : A) →
+    H' (sA a) ∙ G a ＝
+    ap (tr B' (H a)) (F a) ∙ apd sB (H a)
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  {f g i : A → B}
+  (H : f ~ g) (K : g ~ i)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  {i' : {a : A} → A' a → B' (i a)}
+  (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' i')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  (I : section-map-over i i' sA sB)
+  (α : section-htpy-over H H' sA sB F G)
+  (β : section-htpy-over K K' sA sB G I)
+  where
+
+  concat-section-htpy-over :
+    section-htpy-over
+      ( H ∙h K)
+      ( concat-htpy-over H K H' K')
+      ( sA)
+      ( sB)
+      ( F)
+      ( I)
+  concat-section-htpy-over =
+    ind-htpy f
+      ( λ g H →
+        {i : A → B} (K : g ~ i)
+        {g' : {a : A} → A' a → B' (g a)}
+        {i' : {a : A} → A' a → B' (i a)}
+        (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' i')
+        (G : section-map-over g g' sA sB)
+        (I : section-map-over i i' sA sB)
+        (α : section-htpy-over H H' sA sB F G)
+        (β : section-htpy-over K K' sA sB G I) →
+        section-htpy-over
+          ( H ∙h K)
+          ( concat-htpy-over H K H' K')
+          sA sB F I)
+      ( λ K H' K' G I α β a →
+        ind-htpy (f' {a})
+          ( λ g'a H' →
+            {ia : B} (K : f a ＝ ia)
+            {i'a : A' a → B' ia}
+            (K' : (a' : A' a) → dependent-identification B' K (g'a a') (i'a a'))
+            (G : g'a (sA a) ＝ sB (f a))
+            (I : i'a (sA a) ＝ sB ia)
+            (α : H' (sA a) ∙ G ＝ ap id (F a) ∙ refl)
+            (β : K' (sA a) ∙ I ＝ ap (tr B' K) G ∙ apd sB K) →
+              concat-dependent-identification B' refl K (H' (sA a)) (K' (sA a)) ∙ I ＝
+              ap (tr B' K) (F a) ∙ apd sB K)
+          ( λ K K' G I α β → β ∙ ap (λ p → ap (tr B' K) p ∙ apd sB K) (α ∙ (right-unit ∙ ap-id (F a))))
+          ( H' {a})
+          ( K a)
+          ( K' {a})
+          ( G a)
+          ( I a)
+          ( α a)
+          ( β a))
+      ( H)
+      ( K)
+      ( H')
+      ( K')
+      ( G)
+      ( I)
+      ( α)
+      ( β)
+
+module _
+  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+  {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
+  {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
+  (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
+  (g1' : {p : P1} → Q1 p → Q3 (g1 p))
+  (f1' : {p : P1} → Q1 p → Q2 (f1 p))
+  (f2' : {p : P3} → Q3 p → Q4 (f2 p))
+  (g2' : {p : P2} → Q2 p → Q4 (g2 p))
+  where
+
+  module _
+    (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p) (s3 : (p : P3) → Q3 p)
+    (s4 : (p : P4) → Q4 p)
+    (G1 : (p : P1) → g1' (s1 p) ＝ s3 (g1 p))
+    (F1 : (p : P1) → f1' (s1 p) ＝ s2 (f1 p))
+    (F2 : (p : P3) → f2' (s3 p) ＝ s4 (f2 p))
+    (G2 : (p : P2) → g2' (s2 p) ＝ s4 (g2 p))
+    (H : coherence-square-maps g1 f1 f2 g2)
+    (H' : htpy-over Q4 H (g2' ∘ f1') (f2' ∘ g1'))
+    where
+
+    section-square-over : UU (l1 ⊔ l8)
+    section-square-over =
+      (p : P1) →
+      H' (s1 p) ∙ ap f2' (G1 p) ∙ (F2 (g1 p)) ＝
+      ( ap (tr Q4 (H p) ∘ g2') (F1 p) ∙
+        ap (tr Q4 (H p)) (G2 (f1 p)) ∙
+        apd s4 (H p))
+
+    get-section-square-over :
+      section-htpy-over H H' s1 s4
+        ( comp-section-map-over g2 f1 g2' f1' s1 s2 s4 G2 F1)
+        ( comp-section-map-over f2 g1 f2' g1' s1 s3 s4 F2 G1) →
+      section-square-over
+    get-section-square-over = {!!}
+
   module _
-    {l5 : Level}
-    (R : descent-data-pushout
-      ( span-diagram-flattening-descent-data-pushout
-        ( descent-data-zigzag-id-pushout 𝒮 a₀))
-      ( l5))
-    (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
+    (m : P2 → P3)
+    (m' : {p : P2} → Q2 p → Q3 (m p))
+    (B1 : coherence-triangle-maps' g1 m f1)
+    (B2 : coherence-triangle-maps g2 f2 m)
+    (T1 : htpy-over Q3 B1 (m' ∘ f1') g1')
+    (T2 : htpy-over Q4 B2 g2' (f2' ∘ m'))
     where
 
-    private
-      CB :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        concat-s-inf 𝒮 a₀ s
-          ( map-cocone-standard-sequential-colimit n p) ＝
-        map-cocone-standard-sequential-colimit (succ-ℕ n)
-          ( concat-s 𝒮 a₀ s n p)
-      CB s =
-        htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-          ( up-standard-sequential-colimit)
-          ( shift-once-cocone-sequential-diagram
-            ( cocone-standard-sequential-colimit
-              ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
-          ( hom-diagram-zigzag-sequential-diagram
-            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-
-      Ψ :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        left-family-descent-data-pushout R
-          ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p) →
-        right-family-descent-data-pushout R
-          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
-      Ψ s n p =
-        ( tr
-          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-          ( CB s n p)) ∘
-        ( map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p))
-
-      Φ :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
-        right-family-descent-data-pushout R
-          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
-        right-family-descent-data-pushout R
-          ( right-map-span-diagram 𝒮 s ,
-            concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-      Φ s n p =
-        ( tr
-          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-          ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))) ∘
-        ( tr
-          ( λ p →
-            right-family-descent-data-pushout R
-              ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-          ( glue-pushout _ _ (s , refl , p))) ∘
-        ( tr
-          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
-
-      Φ' :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
-        right-family-descent-data-pushout R
-          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
-        left-family-descent-data-pushout R
-          ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-      Φ' s n p =
-        ( inv-map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))) ∘
-        ( Φ s n p)
-
-    coh-dep-cocone-a :
-      (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
-      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-      coherence-square-maps
-        ( ( tr
-            ( λ p →
-              left-family-descent-data-pushout R
-                ( left-map-span-diagram 𝒮 s ,
-                  map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-            ( glue-pushout _ _ (s , refl , p))) ∘
-          ( tr
-            ( ev-pair
-              ( left-family-descent-data-pushout R)
-              ( left-map-span-diagram 𝒮 s))
-            ( coherence-cocone-standard-sequential-colimit n p)))
-        ( map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p))
-        ( map-family-descent-data-pushout R
-          ( s ,
-            map-cocone-standard-sequential-colimit (succ-ℕ n)
-              ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
-        ( ( tr
-            ( ev-pair
-              ( right-family-descent-data-pushout R)
-              ( right-map-span-diagram 𝒮 s))
-            ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
-          ( tr
-            ( λ p →
-              right-family-descent-data-pushout R
-                ( right-map-span-diagram 𝒮 s ,
-                  map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-            ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
-          ( tr
-            ( ev-pair
-              ( right-family-descent-data-pushout R)
-              ( right-map-span-diagram 𝒮 s))
-            ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))) ∘
-          ( tr
-            ( ev-pair
-              ( right-family-descent-data-pushout R)
-              ( right-map-span-diagram 𝒮 s))
-            ( CB s n p)))
-    coh-dep-cocone-a s n p =
-      ( ( inv-htpy
-          ( ( tr-concat _ _) ∙h
-            ( ( tr _ _) ·l
-              ( ( tr-concat _ _) ∙h
-                ( horizontal-concat-htpy
-                  ( λ _ → substitution-law-tr _ _ _)
-                  ( tr-concat _ _)))))) ·r
-        ( map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p))) ∙h
-      ( nat-lemma
-          ( concat-s-inf 𝒮 a₀ s)
-          ( ev-pair (map-family-descent-data-pushout R) s)
-          ( [i] p)) ∙h
-      ( ( map-family-descent-data-pushout R
-          ( s ,
-            map-cocone-standard-sequential-colimit
-              ( succ-ℕ n)
-              ( concat-inv-s 𝒮 a₀ s
-                ( succ-ℕ n)
-                ( concat-s 𝒮 a₀ s n p)))) ·l
-        ( ( tr-concat _ _) ∙h
-          ( λ q → substitution-law-tr _ _ _)))
-      where
-      [i] :
-        ( ( concat-s-inf 𝒮 a₀ s) ·l
-          ( ( coherence-cocone-standard-sequential-colimit n) ∙h
-            ( ( map-cocone-standard-sequential-colimit
-              { A =
-                left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                  ( left-map-span-diagram 𝒮 s)}
-              ( succ-ℕ n)) ·l
-            ( λ p → glue-pushout _ _ (s , refl , p))))) ~
-        ( ( CB s n) ∙h
-          ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
-              ( concat-s 𝒮 a₀ s n)) ∙h
-          ( ( map-cocone-standard-sequential-colimit
-              { A =
-                right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                  ( right-map-span-diagram 𝒮 s)}
-              ( succ-ℕ (succ-ℕ n))) ·l
-            ( λ p → glue-pushout _ _ ( s , refl , concat-s 𝒮 a₀ s n p))) ∙h
-          ( ( inv-htpy (CB s (succ-ℕ n))) ·r
-            ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
-      [i] =
-        ( distributive-left-whisker-comp-concat _ _ _) ∙h
-        ( right-transpose-htpy-concat _ _ _
-          ( ( left-whisker-concat-coherence-square-homotopies _ _ _ _ _
-              ( λ p →
-                inv
-                  ( nat-coherence-square-maps _ _ _ _
-                    ( CB s (succ-ℕ n))
-                    ( glue-pushout _ _ (s , refl , p))))) ∙h
-            ( map-inv-equiv
-              ( equiv-right-transpose-htpy-concat _ _ _)
-              ( ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-                  ( up-standard-sequential-colimit)
-                  ( shift-once-cocone-sequential-diagram
-                    ( cocone-standard-sequential-colimit
-                      ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                        ( right-map-span-diagram 𝒮 s))))
-                  ( hom-diagram-zigzag-sequential-diagram
-                    ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-                  ( n)) ∙h
-                ( ap-concat-htpy
-                  ( CB s n)
-                  ( ( ap-concat-htpy _
-                      ( ( distributive-left-whisker-comp-concat
-                          ( map-cocone-standard-sequential-colimit
-                            { A =
-                              right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                                ( right-map-span-diagram 𝒮 s)}
-                            ( succ-ℕ (succ-ℕ n)))
-                          ( _)
-                          ( _)) ∙h
-                        ( ap-concat-htpy _
-                          ( ( left-whisker-comp² _
-                              ( left-whisker-inv-htpy _ _)) ∙h
-                            ( left-whisker-inv-htpy _ _))))) ∙h
-                    ( inv-htpy-assoc-htpy _ _ _))) ∙h
-                ( inv-htpy-assoc-htpy _ _ _))))) ∙h
-        ( ap-concat-htpy' _
-          ( inv-htpy-assoc-htpy _ _ _))
-
-    α :
-      (s : spanning-type-span-diagram 𝒮) →
-      (n : ℕ) →
-      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-      coherence-square-maps
-        ( Ψ s n p)
-        ( tr
-          ( ev-pair
-            ( left-family-descent-data-pushout R)
-            ( left-map-span-diagram 𝒮 s))
-          ( coherence-cocone-standard-sequential-colimit n p))
-        ( Φ' s n (concat-s 𝒮 a₀ s n p))
-        ( tr
-          ( λ p →
-            left-family-descent-data-pushout R
-              ( left-map-span-diagram 𝒮 s ,
-                map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-          ( glue-pushout _ _ (s , refl , p)))
-    α s n p q =
-      map-eq-transpose-equiv
-        ( equiv-family-descent-data-pushout R
-          ( s ,
-            map-cocone-standard-sequential-colimit
-              ( succ-ℕ n)
-              ( concat-inv-s 𝒮 a₀ s
-                ( succ-ℕ n)
-                ( concat-s 𝒮 a₀ s n p))))
-        ( inv (coh-dep-cocone-a s n p q))
-
-    β :
-      (s : spanning-type-span-diagram 𝒮) →
-      (n : ℕ) →
-      (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
-      coherence-square-maps
-        ( Φ' s n p)
-        ( tr
-          ( ev-pair
-            ( right-family-descent-data-pushout R)
-            ( right-map-span-diagram 𝒮 s))
-          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
-        ( Ψ s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-        ( tr
-          ( λ p →
-            right-family-descent-data-pushout R
-              ( right-map-span-diagram 𝒮 s ,
-                map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-          ( glue-pushout _ _ (s , refl , p)))
-    β s n p q =
-      inv
-        ( ( ap
-            ( tr _ _)
-            ( is-section-map-inv-equiv
-              ( equiv-family-descent-data-pushout R
-                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-              ( _)) ∙
-          ( is-section-map-inv-equiv
-            ( equiv-tr _ _)
-            ( _))))
-
-    stages-cocones' :
-      (n : ℕ) →
-      Σ ( (b : codomain-span-diagram 𝒮) →
-          dependent-cocone-span-diagram
-            ( cocone-pushout-span-diagram
-              ( span-diagram-path-to-b 𝒮 a₀ b n))
-            ( λ p →
-              right-family-descent-data-pushout R
-                ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
-        ( λ dep-cocone-b →
-          Σ ( (a : domain-span-diagram 𝒮) →
-              dependent-cocone-span-diagram
-                ( cocone-pushout-span-diagram
-                  ( span-diagram-path-to-a 𝒮 a₀ a n))
-                ( λ p →
-                  left-family-descent-data-pushout R
-                    ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
-            ( λ dep-cocone-a →
-              (s : spanning-type-span-diagram 𝒮) →
-              (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
-              vertical-map-dependent-cocone _ _ _ _
-                ( dep-cocone-a (left-map-span-diagram 𝒮 s))
-                ( s , refl , p) ＝
-              Φ' s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)))
-    stages-cocones' zero-ℕ =
-      dep-cocone-b ,
-      dep-cocone-a ,
-      λ s p → refl
-      where
-      dep-cocone-b :
-        (b : codomain-span-diagram 𝒮) →
-        dependent-cocone-span-diagram
-          ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b 0))
-          ( λ p →
-            right-family-descent-data-pushout R
-              ( b , map-cocone-standard-sequential-colimit 1 p))
-      pr1 (dep-cocone-b b) (map-raise ())
-      pr1 (pr2 (dep-cocone-b ._)) (s , refl , map-raise refl) =
-        tr
-          ( ev-pair
-            ( right-family-descent-data-pushout R)
-            ( right-map-span-diagram 𝒮 s))
-          ( CB s 0 (map-raise refl))
-          ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit 0 (map-raise refl))
-            ( r₀))
-      pr2 (pr2 (dep-cocone-b ._)) (s , refl , map-raise ())
-      dep-cocone-a :
-        (a : domain-span-diagram 𝒮) →
-        dependent-cocone-span-diagram
-          ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a 0))
-          ( λ p →
-            left-family-descent-data-pushout R
-              ( a , map-cocone-standard-sequential-colimit 1 p))
-      pr1 (dep-cocone-a .a₀) (map-raise refl) =
-        tr
-          ( ev-pair (left-family-descent-data-pushout R) a₀)
-          ( coherence-cocone-standard-sequential-colimit 0 (map-raise refl))
-          ( r₀)
-      pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
-        Φ' s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
-      pr2 (pr2 (dep-cocone-a .a₀)) (s , refl , map-raise refl) =
-        ( α s 0 (map-raise refl) r₀) ∙
-        ( ap
-          ( Φ' s 0 _)
-          ( inv
-            ( compute-inr-dependent-cogap _ _
-              ( dep-cocone-b (right-map-span-diagram 𝒮 s))
-              ( s , refl , map-raise refl))))
-        -- map-eq-transpose-equiv
-        --   ( equiv-family-descent-data-pushout R
-        --     ( s ,
-        --       map-cocone-standard-sequential-colimit 1
-        --         ( concat-inv-s 𝒮 a₀ s 1 (concat-s 𝒮 a₀ s 0 (map-raise refl)))))
-        --   ( inv
-        --     ( ( ap
-        --         ( Φ s 0 (concat-s 𝒮 a₀ s 0 (map-raise refl)))
-        --         ( compute-inr-dependent-cogap _ _
-        --           ( dep-cocone-b (right-map-span-diagram 𝒮 s))
-        --           (s , refl , map-raise refl))) ∙
-        --       ( coh-dep-cocone-a s 0 (map-raise refl) r₀)))
-    stages-cocones' (succ-ℕ n) =
-      dep-cocone-b ,
-      dep-cocone-a ,
-      λ s p → refl
-      where
-      dep-cocone-b :
-        (b : codomain-span-diagram 𝒮) →
-        dependent-cocone-span-diagram
-          ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b (succ-ℕ n)))
-          ( λ p →
-            right-family-descent-data-pushout R
-              ( b , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-      pr1 (dep-cocone-b b) p =
-        tr
-          ( ev-pair (right-family-descent-data-pushout R) b)
-          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
-          ( dependent-cogap _ _ (pr1 (stages-cocones' n) b) p)
-      pr1 (pr2 (dep-cocone-b b)) (s , refl , p) =
-        tr
-          ( ev-pair
-            ( right-family-descent-data-pushout R)
-            ( right-map-span-diagram 𝒮 s))
-          ( CB s (succ-ℕ n) p)
-          ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
-            ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))
-      pr2 (pr2 (dep-cocone-b b)) (s , refl , p) =
-        ( β s n p _) ∙
-        ( ap
-          ( Ψ s (succ-ℕ n) _)
-          ( inv
-            ( ( compute-inr-dependent-cogap _ _
-                ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
-                ( s , refl , p)) ∙
-              ( pr2 (pr2 (stages-cocones' n)) s p))))
-        -- inv
-        --   ( ( ap
-        --       ( λ q →
-        --         tr
-        --           ( ev-pair
-        --             ( right-family-descent-data-pushout R)
-        --             ( right-map-span-diagram 𝒮 s))
-        --           ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-        --           ( map-family-descent-data-pushout R
-        --             ( s ,
-        --               ( map-cocone-standard-sequential-colimit
-        --                 ( succ-ℕ n)
-        --                 ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-        --             ( q)))
-        --       ( ( compute-inr-dependent-cogap _ _
-        --           ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
-        --           ( s , refl , p)) ∙
-        --         ( pr2 (pr2 (stages-cocones' n)) s p))) ∙
-        --     ( ap
-        --       ( tr
-        --         ( ev-pair
-        --           ( right-family-descent-data-pushout R)
-        --           ( right-map-span-diagram 𝒮 s))
-        --         ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-        --       ( is-section-map-inv-equiv
-        --         ( equiv-family-descent-data-pushout R
-        --           ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-        --         ( Φ s n p (dependent-cogap _ _
-        --           ( pr1 (stages-cocones' n) (right-map-span-diagram 𝒮 s)) p)))) ∙
-        --     ( is-section-map-inv-equiv
-        --       ( equiv-tr
-        --         ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-        --         ( CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-        --       ( _)))
-      dep-cocone-a :
-        (a : domain-span-diagram 𝒮) →
-        dependent-cocone-span-diagram
-          ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a (succ-ℕ n)))
-          ( λ p →
-            left-family-descent-data-pushout R
-              ( a , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-      pr1 (dep-cocone-a a) p =
-        tr
-          ( ev-pair (left-family-descent-data-pushout R) a)
-          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
-          ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a) p)
-      pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
-        -- inv-map-family-descent-data-pushout R
-        --   ( s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) (concat-inv-s 𝒮 a₀ s (succ-ℕ (succ-ℕ n)) p))
-        --   ( Φ s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p))
-        Φ' s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
-      pr2 (pr2 (dep-cocone-a a)) (s , refl , p) =
-        ( α s (succ-ℕ n) p _) ∙
-        ( ap
-          ( Φ' s (succ-ℕ n) _)
-          ( inv
-            ( compute-inr-dependent-cogap _ _
-              ( dep-cocone-b (right-map-span-diagram 𝒮 s))
-              ( s , refl , p))))
-        -- map-eq-transpose-equiv
-        --   ( equiv-family-descent-data-pushout R
-        --     ( s ,
-        --       map-cocone-standard-sequential-colimit
-        --         ( succ-ℕ (succ-ℕ n))
-        --         ( concat-inv-s 𝒮 a₀ s
-        --           ( succ-ℕ (succ-ℕ n))
-        --           ( concat-s 𝒮 a₀ s (succ-ℕ n) p))))
-        --   ( inv
-        --     ( ( ap
-        --         ( Φ s (succ-ℕ n) (concat-s 𝒮 a₀ s (succ-ℕ n) p))
-        --         ( compute-inr-dependent-cogap _ _
-        --           ( dep-cocone-b (right-map-span-diagram 𝒮 s))
-        --           ( s , refl , p))) ∙
-        --       ( coh-dep-cocone-a s
-        --         ( succ-ℕ n)
-        --         ( p)
-        --         ( dependent-cogap _ _
-        --           (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))))
-
-
-    tB :
-      (b : codomain-span-diagram 𝒮) (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
-      right-family-descent-data-pushout R
-        ( b , map-cocone-standard-sequential-colimit n p)
-    tB b zero-ℕ (map-raise ())
-    tB b (succ-ℕ n) = dependent-cogap _ _ (pr1 (stages-cocones' n) b)
-
-    tA :
-      (a : domain-span-diagram 𝒮) (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
-      left-family-descent-data-pushout R
-        ( a , map-cocone-standard-sequential-colimit n p)
-    tA .a₀ zero-ℕ (map-raise refl) = r₀
-    tA a (succ-ℕ n) = dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a)
-
-    ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
-    pr1 ind-singleton-zigzag-id-pushout' (a , p) =
-      dependent-cogap-standard-sequential-colimit
-        ( tA a , KA)
-        ( p)
-      where
-      KA :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
-        dependent-identification
-          ( ev-pair (left-family-descent-data-pushout R) a)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tA a n p)
-          ( tA a (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p))
-      KA zero-ℕ (map-raise refl) =
-        inv
-          ( compute-inl-dependent-cogap _ _
-            ( pr1 (pr2 (stages-cocones' 0)) a)
-            ( map-raise refl))
-      KA (succ-ℕ n) p =
-        inv
-          ( compute-inl-dependent-cogap _ _
-            ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) a)
-            ( p))
-    pr1 (pr2 ind-singleton-zigzag-id-pushout') (b , p) =
-      dependent-cogap-standard-sequential-colimit
-        ( tB b , KB)
-        ( p)
-      where
-      KB :
-        (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
-        dependent-identification
-          ( ev-pair (right-family-descent-data-pushout R) b)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tB b n p)
-          ( tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
-      KB zero-ℕ (map-raise ())
-      KB (succ-ℕ n) p =
-        inv
-          ( compute-inl-dependent-cogap _ _
-            ( pr1 (stages-cocones' (succ-ℕ n)) b)
-            ( p))
-    pr2 (pr2 ind-singleton-zigzag-id-pushout') (s , p) =
-      dependent-cogap-standard-sequential-colimit
-        ( tS , KS)
-        ( p)
-      where
-      [i] :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        tr
-          ( ev-pair
-            ( right-family-descent-data-pushout R)
-            ( right-map-span-diagram 𝒮 s))
-          ( CB s n p)
-          ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit n p)
-            ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
-        tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
-      [i] zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
-      [i] (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
-      tS :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p)
-          ( pr1
-            ( ind-singleton-zigzag-id-pushout')
-            ( left-map-span-diagram 𝒮 s ,
-              map-cocone-standard-sequential-colimit n p)) ＝
-        pr1
-          ( pr2 ind-singleton-zigzag-id-pushout')
-          ( right-map-span-diagram 𝒮 s ,
-            concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
-      tS n p =
-        ( ap
-          ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit n p))
-          ( compute-incl-dependent-cogap-standard-sequential-colimit _ n p)) ∙
-        ( map-equiv
-          ( inv-equiv-ap-emb
-            ( emb-equiv
-              ( equiv-tr
-                ( ev-pair
-                  ( right-family-descent-data-pushout R)
-                  ( right-map-span-diagram 𝒮 s))
-                ( CB s n p))))
-          ( [i] n p ∙
-            inv
-              ( ( apd
-                  ( dependent-cogap-standard-sequential-colimit (tB (right-map-span-diagram 𝒮 s) , _))
-                  ( CB s n p)) ∙
-                ( compute-incl-dependent-cogap-standard-sequential-colimit _ (succ-ℕ n) _))))
-      KS :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        tr
-          ( λ p →
-            map-family-descent-data-pushout R
-              ( s , p)
-              ( pr1
-                ( ind-singleton-zigzag-id-pushout')
-                ( left-map-span-diagram 𝒮 s , p)) ＝
-            pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p))
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tS n p) ＝
-        tS (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n p)
-      KS n p =
-        map-compute-dependent-identification-eq-value _ _
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( _)
-          ( _)
-          ( {!!})
-
-  is-identity-system-zigzag-id-pushout :
-    is-identity-system-descent-data-pushout
-      ( descent-data-zigzag-id-pushout 𝒮 a₀)
-      ( refl-id-pushout 𝒮 a₀)
-  is-identity-system-zigzag-id-pushout =
-    is-identity-system-descent-data-pushout-ind-singleton up-c
-      ( descent-data-zigzag-id-pushout 𝒮 a₀)
-      ( refl-id-pushout 𝒮 a₀)
-      ( ind-singleton-zigzag-id-pushout')
+    pasting-triangles-over :
+      htpy-over Q4
+        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
+        ( g2' ∘ f1')
+        ( f2' ∘ g1')
+    pasting-triangles-over =
+      concat-htpy-over
+        ( B2 ·r f1)
+        ( f2 ·l B1)
+        ( right-whisk-htpy-over B2 T2 f1')
+        ( left-whisk-htpy-over B1 T1 f2')
+
+  module _
+    (m : P2 → P3)
+    (m' : {p : P2} → Q2 p → Q3 (m p))
+    (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p) (s3 : (p : P3) → Q3 p)
+    (s4 : (p : P4) → Q4 p)
+    (G1 : (p : P1) → g1' (s1 p) ＝ s3 (g1 p))
+    (F1 : (p : P1) → f1' (s1 p) ＝ s2 (f1 p))
+    (F2 : (p : P3) → f2' (s3 p) ＝ s4 (f2 p))
+    (G2 : (p : P2) → g2' (s2 p) ＝ s4 (g2 p))
+    (M : (p : P2) → m' (s2 p) ＝ s3 (m p))
+    (B1 : coherence-triangle-maps' g1 m f1)
+    (B2 : coherence-triangle-maps g2 f2 m)
+    (T1 : htpy-over Q3 B1 (m' ∘ f1') g1')
+    (T2 : htpy-over Q4 B2 g2' (f2' ∘ m'))
+    where
+
+    pasting-sections-triangles-over :
+      section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 →
+      section-triangle-over m g2 f2 m' g2' f2' s2 s3 s4 M G2 F2 B2 T2 →
+      section-square-over s1 s2 s3 s4 G1 F1 F2 G2
+        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
+        ( pasting-triangles-over m m' B1 B2 T1 T2)
+    pasting-sections-triangles-over S1 S2 =
+      get-section-square-over s1 s2 s3 s4 G1 F1 F2 G2
+        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
+        ( pasting-triangles-over m m' B1 B2 T1 T2)
+        ( concat-section-htpy-over (B2 ·r f1) (f2 ·l B1)
+           ( right-whisk-htpy-over B2 T2 f1')
+           ( left-whisk-htpy-over B1 T1 f2')
+           s1 s4
+           ( comp-section-map-over g2 f1 g2' f1' s1 s2 s4 G2 F1)
+           ( comp-section-map-over (f2 ∘ m) f1 (f2' ∘ m') f1' s1 s2 s4
+             ( comp-section-map-over f2 m f2' m' s2 s3 s4 F2 M)
+             ( F1))
+           ( comp-section-map-over f2 g1 f2' g1' s1 s3 s4 F2 G1)
+           {!!}
+           {!!})
 ```
+^ remove this code fence
+-- module _
+--   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
+--   where
+
+--   type-stage-zigzag-construction-id-pushout : ℕ → UU (lsuc (l1 ⊔ l2 ⊔ l3))
+--   type-stage-zigzag-construction-id-pushout n =
+--     Σ ( codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
+--       ( λ Path-to-b →
+--         Σ ( domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
+--           ( λ Path-to-a →
+--             ( Σ ( (s : spanning-type-span-diagram 𝒮) →
+--                   Path-to-b (right-map-span-diagram 𝒮 s) →
+--                   Path-to-a (left-map-span-diagram 𝒮 s))
+--                 ( λ _ →
+--                   rec-ℕ
+--                     ( raise-unit (lsuc (l1 ⊔ l2 ⊔ l3)))
+--                     ( λ _ _ →
+--                       ( codomain-span-diagram 𝒮 →
+--                         span-diagram
+--                           ( l1 ⊔ l2 ⊔ l3)
+--                           ( l1 ⊔ l2 ⊔ l3)
+--                           ( l1 ⊔ l2 ⊔ l3)) ×
+--                       ( domain-span-diagram 𝒮 →
+--                         span-diagram
+--                           ( l1 ⊔ l2 ⊔ l3)
+--                           ( l1 ⊔ l2 ⊔ l3)
+--                           ( l1 ⊔ l2 ⊔ l3)))
+--                     ( n)))))
+
+-- module _
+--   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
+--   (a₀ : domain-span-diagram 𝒮)
+--   where
+
+--   stage-zigzag-construction-id-pushout :
+--     (n : ℕ) → type-stage-zigzag-construction-id-pushout 𝒮 n
+--   stage-zigzag-construction-id-pushout zero-ℕ =
+--     Path-to-b ,
+--     Path-to-a ,
+--     ( λ s → raise-ex-falso _) ,
+--     raise-star
+--     where
+--     Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+--     Path-to-b _ = raise-empty _
+--     Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+--     Path-to-a a = raise (l2 ⊔ l3) (a₀ ＝ a)
+--   stage-zigzag-construction-id-pushout (succ-ℕ n) =
+--     Path-to-b ,
+--     Path-to-a ,
+--     ( λ s p → inr-pushout _ _ (s , refl , p)) ,
+--     span-diagram-B ,
+--     span-diagram-A
+--     where
+--     span-diagram-B :
+--       codomain-span-diagram 𝒮 →
+--       span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
+--     span-diagram-B b =
+--       make-span-diagram
+--         ( pr2 ∘ pr2)
+--         ( tot
+--           ( λ s →
+--             tot
+--               ( λ r (p : pr1 (stage-zigzag-construction-id-pushout n) b) →
+--                 pr1
+--                   ( pr2 (pr2 (stage-zigzag-construction-id-pushout n)))
+--                   ( s)
+--                   ( tr (pr1 (stage-zigzag-construction-id-pushout n)) r p))))
+--     Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+--     Path-to-b b = standard-pushout (span-diagram-B b)
+--     span-diagram-A :
+--       domain-span-diagram 𝒮 →
+--       span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
+--     span-diagram-A a =
+--       make-span-diagram
+--         ( pr2 ∘ pr2)
+--         ( tot
+--           ( λ s →
+--             tot
+--               ( λ r (p : pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a) →
+--                 inr-standard-pushout
+--                   ( span-diagram-B (right-map-span-diagram 𝒮 s))
+--                   ( ( s) ,
+--                     ( refl) ,
+--                     ( tr
+--                       ( pr1 (pr2 (stage-zigzag-construction-id-pushout n)))
+--                       ( r)
+--                       ( p))))))
+--     Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+--     Path-to-a a = standard-pushout (span-diagram-A a)
+
+--   span-diagram-path-to-b :
+--     codomain-span-diagram 𝒮 → ℕ →
+--     span-diagram
+--       ( l1 ⊔ l2 ⊔ l3)
+--       ( l1 ⊔ l2 ⊔ l3)
+--       ( l1 ⊔ l2 ⊔ l3)
+--   span-diagram-path-to-b b n =
+--     pr1 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) b
+
+--   span-diagram-path-to-a :
+--     domain-span-diagram 𝒮 → ℕ →
+--     span-diagram
+--       ( l1 ⊔ l2 ⊔ l3)
+--       ( l1 ⊔ l2 ⊔ l3)
+--       ( l1 ⊔ l2 ⊔ l3)
+--   span-diagram-path-to-a a n =
+--     pr2 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) a
+
+--   Path-to-b : codomain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
+--   Path-to-b b n = pr1 (stage-zigzag-construction-id-pushout n) b
+
+--   Path-to-a : domain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
+--   Path-to-a a n = pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a
+
+--   inl-Path-to-b :
+--     (b : codomain-span-diagram 𝒮) (n : ℕ) → Path-to-b b n → Path-to-b b (succ-ℕ n)
+--   inl-Path-to-b b n =
+--     inl-standard-pushout
+--       ( span-diagram-path-to-b b n)
+
+--   inl-Path-to-a :
+--     (a : domain-span-diagram 𝒮) (n : ℕ) → Path-to-a a n → Path-to-a a (succ-ℕ n)
+--   inl-Path-to-a a n =
+--     inl-standard-pushout
+--       ( span-diagram-path-to-a a n)
+
+--   concat-inv-s :
+--     (s : spanning-type-span-diagram 𝒮) →
+--     (n : ℕ) →
+--     Path-to-b (right-map-span-diagram 𝒮 s) n →
+--     Path-to-a (left-map-span-diagram 𝒮 s) n
+--   concat-inv-s s n = pr1 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
+
+--   concat-s :
+--     (s : spanning-type-span-diagram 𝒮) →
+--     (n : ℕ) →
+--     Path-to-a (left-map-span-diagram 𝒮 s) n →
+--     Path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n)
+--   concat-s s n p =
+--     inr-standard-pushout
+--       ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) n)
+--       ( s , refl , p)
+
+--   right-sequential-diagram-zigzag-id-pushout :
+--     codomain-span-diagram 𝒮 →
+--     sequential-diagram (l1 ⊔ l2 ⊔ l3)
+--   pr1 (right-sequential-diagram-zigzag-id-pushout b) = Path-to-b b
+--   pr2 (right-sequential-diagram-zigzag-id-pushout b) = inl-Path-to-b b
+
+--   left-sequential-diagram-zigzag-id-pushout :
+--     domain-span-diagram 𝒮 →
+--     sequential-diagram (l1 ⊔ l2 ⊔ l3)
+--   pr1 (left-sequential-diagram-zigzag-id-pushout a) = Path-to-a a
+--   pr2 (left-sequential-diagram-zigzag-id-pushout a) = inl-Path-to-a a
+
+--   zigzag-sequential-diagram-zigzag-id-pushout :
+--     (s : spanning-type-span-diagram 𝒮) →
+--     zigzag-sequential-diagram
+--       ( left-sequential-diagram-zigzag-id-pushout
+--         ( left-map-span-diagram 𝒮 s))
+--       ( shift-once-sequential-diagram
+--         ( right-sequential-diagram-zigzag-id-pushout
+--           ( right-map-span-diagram 𝒮 s)))
+--   pr1 (zigzag-sequential-diagram-zigzag-id-pushout s) =
+--     concat-s s
+--   pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s)) n =
+--     concat-inv-s s (succ-ℕ n)
+--   pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
+--     glue-standard-pushout
+--       ( span-diagram-path-to-a (left-map-span-diagram 𝒮 s) n)
+--       ( s , refl , p)
+--   pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
+--     glue-standard-pushout
+--       ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n))
+--       ( s , refl , p)
+
+--   left-id-pushout : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+--   left-id-pushout a =
+--     standard-sequential-colimit (left-sequential-diagram-zigzag-id-pushout a)
+
+--   refl-id-pushout : left-id-pushout a₀
+--   refl-id-pushout =
+--     map-cocone-standard-sequential-colimit 0 (map-raise refl)
+
+--   right-id-pushout : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+--   right-id-pushout b =
+--     standard-sequential-colimit (right-sequential-diagram-zigzag-id-pushout b)
+
+--   equiv-id-pushout :
+--     (s : spanning-type-span-diagram 𝒮) →
+--     left-id-pushout (left-map-span-diagram 𝒮 s) ≃
+--     right-id-pushout (right-map-span-diagram 𝒮 s)
+--   equiv-id-pushout s =
+--     equiv-colimit-zigzag-sequential-diagram _ _
+--       ( up-standard-sequential-colimit)
+--       ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+--       ( zigzag-sequential-diagram-zigzag-id-pushout s)
+
+--   -- concat-inv-s-inf :
+--   --   (s : spanning-type-span-diagram 𝒮) →
+--   --   right-id-pushout (right-map-span-diagram 𝒮 s) →
+--   --   left-id-pushout (left-map-span-diagram 𝒮 s)
+--   -- concat-inv-s-inf s =
+--   --   map-inv-equiv (equiv-id-pushout s)
+
+--   concat-s-inf :
+--     (s : spanning-type-span-diagram 𝒮) →
+--     left-id-pushout (left-map-span-diagram 𝒮 s) →
+--     right-id-pushout (right-map-span-diagram 𝒮 s)
+--   concat-s-inf s =
+--     map-equiv (equiv-id-pushout s)
+
+--   descent-data-zigzag-id-pushout : descent-data-pushout 𝒮 (l1 ⊔ l2 ⊔ l3)
+--   pr1 descent-data-zigzag-id-pushout = left-id-pushout
+--   pr1 (pr2 descent-data-zigzag-id-pushout) = right-id-pushout
+--   pr2 (pr2 descent-data-zigzag-id-pushout) = equiv-id-pushout
+-- ```
+
+-- ## Theorem
+
+-- ### TODO
+
+-- ```agda
+-- nat-lemma :
+--   {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
+--   {P : A → UU l3} {Q : B → UU l4}
+--   (f : A → B) (h : (a : A) → P a → Q (f a))
+--   {x y : A} {p : x ＝ y}
+--   {q : f x ＝ f y} (α : ap f p ＝ q) →
+--   coherence-square-maps
+--     ( tr P p)
+--     ( h x)
+--     ( h y)
+--     ( tr Q q)
+-- nat-lemma f h {p = p} refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
+
+-- apd-lemma :
+--   {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
+--   (f : (a : A) → B a) (g : (a : A) → B a → C a) {x y : A} (p : x ＝ y) →
+--   apd (λ a → g a (f a)) p ＝ inv (preserves-tr g p (f x)) ∙ ap (g y) (apd f p)
+-- apd-lemma f g refl = refl
+
+-- lem :
+--   {l : Level} {X : UU l} {x y z u v : X} →
+--   (p : y ＝ x) (q : y ＝ z) (r : z ＝ u) (s : x ＝ v) (t : u ＝ v) →
+--   (inv p ∙ (q ∙ r) ＝ s ∙ inv t) → q ∙ r ∙ t ＝ p ∙ s
+-- lem refl q r refl refl x = right-unit ∙ x
+
+-- module _
+--   {l1 l2 l3 l4 : Level} {𝒮 : span-diagram l1 l2 l3}
+--   {X : UU l4} {c : cocone-span-diagram 𝒮 X}
+--   (up-c : universal-property-pushout _ _ c)
+--   (a₀ : domain-span-diagram 𝒮)
+--   where
+
+--   module _
+--     {l5 : Level}
+--     (R : descent-data-pushout
+--       ( span-diagram-flattening-descent-data-pushout
+--         ( descent-data-zigzag-id-pushout 𝒮 a₀))
+--       ( l5))
+--     (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
+--     where
+
+--     private
+--       CB :
+--         (s : spanning-type-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--         concat-s-inf 𝒮 a₀ s
+--           ( map-cocone-standard-sequential-colimit n p) ＝
+--         map-cocone-standard-sequential-colimit (succ-ℕ n)
+--           ( concat-s 𝒮 a₀ s n p)
+--       CB s =
+--         htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--           ( up-standard-sequential-colimit)
+--           ( shift-once-cocone-sequential-diagram
+--             ( cocone-standard-sequential-colimit
+--               ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
+--           ( hom-diagram-zigzag-sequential-diagram
+--             ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+
+--       Ψ :
+--         (s : spanning-type-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--         left-family-descent-data-pushout R
+--           ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p) →
+--         right-family-descent-data-pushout R
+--           ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
+--       Ψ s n p =
+--         ( tr
+--           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--           ( CB s n p)) ∘
+--         ( map-family-descent-data-pushout R
+--           ( s , map-cocone-standard-sequential-colimit n p))
+
+--       Φ :
+--         (s : spanning-type-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+--         right-family-descent-data-pushout R
+--           ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
+--         right-family-descent-data-pushout R
+--           ( right-map-span-diagram 𝒮 s ,
+--             concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+--       Φ s n p =
+--         ( tr
+--           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--           ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))) ∘
+--         ( tr
+--           ( λ p →
+--             right-family-descent-data-pushout R
+--               ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+--           ( glue-pushout _ _ (s , refl , p))) ∘
+--         ( tr
+--           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
+
+--       Φ' :
+--         (s : spanning-type-span-diagram 𝒮) →
+--         (n : ℕ) →
+--         (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+--         right-family-descent-data-pushout R
+--           ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
+--         left-family-descent-data-pushout R
+--           ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+--       Φ' s n p =
+--         ( inv-map-family-descent-data-pushout R
+--           ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))) ∘
+--         ( Φ s n p)
+
+--     coh-dep-cocone-a :
+--       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+--       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--       coherence-square-maps
+--         ( ( tr
+--             ( λ p →
+--               left-family-descent-data-pushout R
+--                 ( left-map-span-diagram 𝒮 s ,
+--                   map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--             ( glue-pushout _ _ (s , refl , p))) ∘
+--           ( tr
+--             ( ev-pair
+--               ( left-family-descent-data-pushout R)
+--               ( left-map-span-diagram 𝒮 s))
+--             ( coherence-cocone-standard-sequential-colimit n p)))
+--         ( map-family-descent-data-pushout R
+--           ( s , map-cocone-standard-sequential-colimit n p))
+--         ( map-family-descent-data-pushout R
+--           ( s ,
+--             map-cocone-standard-sequential-colimit (succ-ℕ n)
+--               ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
+--         ( ( tr
+--             ( ev-pair
+--               ( right-family-descent-data-pushout R)
+--               ( right-map-span-diagram 𝒮 s))
+--             ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
+--           ( tr
+--             ( λ p →
+--               right-family-descent-data-pushout R
+--                 ( right-map-span-diagram 𝒮 s ,
+--                   map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+--             ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
+--           ( tr
+--             ( ev-pair
+--               ( right-family-descent-data-pushout R)
+--               ( right-map-span-diagram 𝒮 s))
+--             ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))) ∘
+--           ( tr
+--             ( ev-pair
+--               ( right-family-descent-data-pushout R)
+--               ( right-map-span-diagram 𝒮 s))
+--             ( CB s n p)))
+--     coh-dep-cocone-a s n p =
+--       ( ( inv-htpy
+--           ( ( tr-concat _ _) ∙h
+--             ( ( tr _ _) ·l
+--               ( ( tr-concat _ _) ∙h
+--                 ( horizontal-concat-htpy
+--                   ( λ _ → substitution-law-tr _ _ _)
+--                   ( tr-concat _ _)))))) ·r
+--         ( map-family-descent-data-pushout R
+--           ( s , map-cocone-standard-sequential-colimit n p))) ∙h
+--       ( nat-lemma
+--           ( concat-s-inf 𝒮 a₀ s)
+--           ( ev-pair (map-family-descent-data-pushout R) s)
+--           ( [i] p)) ∙h
+--       ( ( map-family-descent-data-pushout R
+--           ( s ,
+--             map-cocone-standard-sequential-colimit
+--               ( succ-ℕ n)
+--               ( concat-inv-s 𝒮 a₀ s
+--                 ( succ-ℕ n)
+--                 ( concat-s 𝒮 a₀ s n p)))) ·l
+--         ( ( tr-concat _ _) ∙h
+--           ( λ q → substitution-law-tr _ _ _)))
+--       where
+--       [i] :
+--         ( ( concat-s-inf 𝒮 a₀ s) ·l
+--           ( ( coherence-cocone-standard-sequential-colimit n) ∙h
+--             ( ( map-cocone-standard-sequential-colimit
+--               { A =
+--                 left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+--                   ( left-map-span-diagram 𝒮 s)}
+--               ( succ-ℕ n)) ·l
+--             ( λ p → glue-pushout _ _ (s , refl , p))))) ~
+--         ( ( CB s n) ∙h
+--           ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
+--               ( concat-s 𝒮 a₀ s n)) ∙h
+--           ( ( map-cocone-standard-sequential-colimit
+--               { A =
+--                 right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+--                   ( right-map-span-diagram 𝒮 s)}
+--               ( succ-ℕ (succ-ℕ n))) ·l
+--             ( λ p → glue-pushout _ _ ( s , refl , concat-s 𝒮 a₀ s n p))) ∙h
+--           ( ( inv-htpy (CB s (succ-ℕ n))) ·r
+--             ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
+--       [i] =
+--         ( distributive-left-whisker-comp-concat _ _ _) ∙h
+--         ( right-transpose-htpy-concat _ _ _
+--           ( ( left-whisker-concat-coherence-square-homotopies _ _ _ _ _
+--               ( λ p →
+--                 inv
+--                   ( nat-coherence-square-maps _ _ _ _
+--                     ( CB s (succ-ℕ n))
+--                     ( glue-pushout _ _ (s , refl , p))))) ∙h
+--             ( map-inv-equiv
+--               ( equiv-right-transpose-htpy-concat _ _ _)
+--               ( ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                   ( up-standard-sequential-colimit)
+--                   ( shift-once-cocone-sequential-diagram
+--                     ( cocone-standard-sequential-colimit
+--                       ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+--                         ( right-map-span-diagram 𝒮 s))))
+--                   ( hom-diagram-zigzag-sequential-diagram
+--                     ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+--                   ( n)) ∙h
+--                 ( ap-concat-htpy
+--                   ( CB s n)
+--                   ( ( ap-concat-htpy _
+--                       ( ( distributive-left-whisker-comp-concat
+--                           ( map-cocone-standard-sequential-colimit
+--                             { A =
+--                               right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+--                                 ( right-map-span-diagram 𝒮 s)}
+--                             ( succ-ℕ (succ-ℕ n)))
+--                           ( _)
+--                           ( _)) ∙h
+--                         ( ap-concat-htpy _
+--                           ( ( left-whisker-comp² _
+--                               ( left-whisker-inv-htpy _ _)) ∙h
+--                             ( left-whisker-inv-htpy _ _))))) ∙h
+--                     ( inv-htpy-assoc-htpy _ _ _))) ∙h
+--                 ( inv-htpy-assoc-htpy _ _ _))))) ∙h
+--         ( ap-concat-htpy' _
+--           ( inv-htpy-assoc-htpy _ _ _))
+
+--     α :
+--       (s : spanning-type-span-diagram 𝒮) →
+--       (n : ℕ) →
+--       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--       coherence-square-maps
+--         ( Ψ s n p)
+--         ( tr
+--           ( ev-pair
+--             ( left-family-descent-data-pushout R)
+--             ( left-map-span-diagram 𝒮 s))
+--           ( coherence-cocone-standard-sequential-colimit n p))
+--         ( Φ' s n (concat-s 𝒮 a₀ s n p))
+--         ( tr
+--           ( λ p →
+--             left-family-descent-data-pushout R
+--               ( left-map-span-diagram 𝒮 s ,
+--                 map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--           ( glue-pushout _ _ (s , refl , p)))
+--     α s n p q =
+--       map-eq-transpose-equiv
+--         ( equiv-family-descent-data-pushout R
+--           ( s ,
+--             map-cocone-standard-sequential-colimit
+--               ( succ-ℕ n)
+--               ( concat-inv-s 𝒮 a₀ s
+--                 ( succ-ℕ n)
+--                 ( concat-s 𝒮 a₀ s n p))))
+--         ( inv (coh-dep-cocone-a s n p q))
+
+--     β :
+--       (s : spanning-type-span-diagram 𝒮) →
+--       (n : ℕ) →
+--       (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+--       coherence-square-maps
+--         ( Φ' s n p)
+--         ( tr
+--           ( ev-pair
+--             ( right-family-descent-data-pushout R)
+--             ( right-map-span-diagram 𝒮 s))
+--           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
+--         ( Ψ s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+--         ( tr
+--           ( λ p →
+--             right-family-descent-data-pushout R
+--               ( right-map-span-diagram 𝒮 s ,
+--                 map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+--           ( glue-pushout _ _ (s , refl , p)))
+--     β s n p q =
+--       inv
+--         ( ( ap
+--             ( tr _ _)
+--             ( is-section-map-inv-equiv
+--               ( equiv-family-descent-data-pushout R
+--                 ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+--               ( _)) ∙
+--           ( is-section-map-inv-equiv
+--             ( equiv-tr _ _)
+--             ( _))))
+
+--     -- Note for refactoring: after contracting away the last component and the
+--     -- vertical map, the definition of prism2 will fail to typecheck, since
+--     -- currently the coherence computes to <X> ∙ refl, which needs to be taken
+--     -- into account; contracting away this data would simplify the later
+--     -- homotopy algebra.
+--     stages-cocones' :
+--       (n : ℕ) →
+--       Σ ( (b : codomain-span-diagram 𝒮) →
+--           dependent-cocone-span-diagram
+--             ( cocone-pushout-span-diagram
+--               ( span-diagram-path-to-b 𝒮 a₀ b n))
+--             ( λ p →
+--               right-family-descent-data-pushout R
+--                 ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
+--         ( λ dep-cocone-b →
+--           Σ ( (a : domain-span-diagram 𝒮) →
+--               dependent-cocone-span-diagram
+--                 ( cocone-pushout-span-diagram
+--                   ( span-diagram-path-to-a 𝒮 a₀ a n))
+--                 ( λ p →
+--                   left-family-descent-data-pushout R
+--                     ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
+--             ( λ dep-cocone-a →
+--               (s : spanning-type-span-diagram 𝒮) →
+--               (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+--               vertical-map-dependent-cocone _ _ _ _
+--                 ( dep-cocone-a (left-map-span-diagram 𝒮 s))
+--                 ( s , refl , p) ＝
+--               Φ' s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)))
+--     stages-cocones' zero-ℕ =
+--       dep-cocone-b ,
+--       dep-cocone-a ,
+--       λ s p → refl
+--       where
+--       dep-cocone-b :
+--         (b : codomain-span-diagram 𝒮) →
+--         dependent-cocone-span-diagram
+--           ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b 0))
+--           ( λ p →
+--             right-family-descent-data-pushout R
+--               ( b , map-cocone-standard-sequential-colimit 1 p))
+--       pr1 (dep-cocone-b b) (map-raise ())
+--       pr1 (pr2 (dep-cocone-b ._)) (s , refl , map-raise refl) =
+--         tr
+--           ( ev-pair
+--             ( right-family-descent-data-pushout R)
+--             ( right-map-span-diagram 𝒮 s))
+--           ( CB s 0 (map-raise refl))
+--           ( map-family-descent-data-pushout R
+--             ( s , map-cocone-standard-sequential-colimit 0 (map-raise refl))
+--             ( r₀))
+--       pr2 (pr2 (dep-cocone-b ._)) (s , refl , map-raise ())
+--       dep-cocone-a :
+--         (a : domain-span-diagram 𝒮) →
+--         dependent-cocone-span-diagram
+--           ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a 0))
+--           ( λ p →
+--             left-family-descent-data-pushout R
+--               ( a , map-cocone-standard-sequential-colimit 1 p))
+--       pr1 (dep-cocone-a .a₀) (map-raise refl) =
+--         tr
+--           ( ev-pair (left-family-descent-data-pushout R) a₀)
+--           ( coherence-cocone-standard-sequential-colimit 0 (map-raise refl))
+--           ( r₀)
+--       pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
+--         Φ' s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
+--       pr2 (pr2 (dep-cocone-a .a₀)) (s , refl , map-raise refl) =
+--         ( α s 0 (map-raise refl) r₀) ∙
+--         ( ap
+--           ( Φ' s 0 _)
+--           ( inv
+--             ( compute-inr-dependent-cogap _ _
+--               ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+--               ( s , refl , map-raise refl))))
+--     stages-cocones' (succ-ℕ n) =
+--       dep-cocone-b ,
+--       dep-cocone-a ,
+--       λ s p → refl
+--       where
+--       dep-cocone-b :
+--         (b : codomain-span-diagram 𝒮) →
+--         dependent-cocone-span-diagram
+--           ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b (succ-ℕ n)))
+--           ( λ p →
+--             right-family-descent-data-pushout R
+--               ( b , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+--       pr1 (dep-cocone-b b) p =
+--         tr
+--           ( ev-pair (right-family-descent-data-pushout R) b)
+--           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
+--           ( dependent-cogap _ _ (pr1 (stages-cocones' n) b) p)
+--       pr1 (pr2 (dep-cocone-b b)) (s , refl , p) =
+--         tr
+--           ( ev-pair
+--             ( right-family-descent-data-pushout R)
+--             ( right-map-span-diagram 𝒮 s))
+--           ( CB s (succ-ℕ n) p)
+--           ( map-family-descent-data-pushout R
+--             ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
+--             ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))
+--       pr2 (pr2 (dep-cocone-b b)) (s , refl , p) =
+--         ( β s n p _) ∙
+--         ( ap
+--           ( Ψ s (succ-ℕ n) _)
+--           ( inv
+--             ( ( compute-inr-dependent-cogap _ _
+--                 ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
+--                 ( s , refl , p)) ∙
+--               ( pr2 (pr2 (stages-cocones' n)) s p))))
+--       dep-cocone-a :
+--         (a : domain-span-diagram 𝒮) →
+--         dependent-cocone-span-diagram
+--           ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a (succ-ℕ n)))
+--           ( λ p →
+--             left-family-descent-data-pushout R
+--               ( a , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+--       pr1 (dep-cocone-a a) p =
+--         tr
+--           ( ev-pair (left-family-descent-data-pushout R) a)
+--           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
+--           ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a) p)
+--       pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
+--         Φ' s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
+--       pr2 (pr2 (dep-cocone-a a)) (s , refl , p) =
+--         ( α s (succ-ℕ n) p _) ∙
+--         ( ap
+--           ( Φ' s (succ-ℕ n) _)
+--           ( inv
+--             ( compute-inr-dependent-cogap _ _
+--               ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+--               ( s , refl , p))))
+
+
+--     tB :
+--       (b : codomain-span-diagram 𝒮) (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
+--       right-family-descent-data-pushout R
+--         ( b , map-cocone-standard-sequential-colimit n p)
+--     tB b zero-ℕ (map-raise ())
+--     tB b (succ-ℕ n) = dependent-cogap _ _ (pr1 (stages-cocones' n) b)
+
+--     tA :
+--       (a : domain-span-diagram 𝒮) (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
+--       left-family-descent-data-pushout R
+--         ( a , map-cocone-standard-sequential-colimit n p)
+--     tA .a₀ zero-ℕ (map-raise refl) = r₀
+--     tA a (succ-ℕ n) = dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a)
+
+--     ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
+--     pr1 ind-singleton-zigzag-id-pushout' (a , p) =
+--       dependent-cogap-standard-sequential-colimit
+--         ( tA a , KA)
+--         ( p)
+--       where
+--       KA :
+--         (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
+--         dependent-identification
+--           ( ev-pair (left-family-descent-data-pushout R) a)
+--           ( coherence-cocone-standard-sequential-colimit n p)
+--           ( tA a n p)
+--           ( tA a (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p))
+--       KA zero-ℕ (map-raise refl) =
+--         inv
+--           ( compute-inl-dependent-cogap _ _
+--             ( pr1 (pr2 (stages-cocones' 0)) a)
+--             ( map-raise refl))
+--       KA (succ-ℕ n) p =
+--         inv
+--           ( compute-inl-dependent-cogap _ _
+--             ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) a)
+--             ( p))
+--     pr1 (pr2 ind-singleton-zigzag-id-pushout') (b , p) =
+--       dependent-cogap-standard-sequential-colimit
+--         ( tB b , KB)
+--         ( p)
+--       where
+--       KB :
+--         (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
+--         dependent-identification
+--           ( ev-pair (right-family-descent-data-pushout R) b)
+--           ( coherence-cocone-standard-sequential-colimit n p)
+--           ( tB b n p)
+--           ( tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
+--       KB zero-ℕ (map-raise ())
+--       KB (succ-ℕ n) p =
+--         inv
+--           ( compute-inl-dependent-cogap _ _
+--             ( pr1 (stages-cocones' (succ-ℕ n)) b)
+--             ( p))
+--     pr2 (pr2 ind-singleton-zigzag-id-pushout') (s , p) =
+--       dependent-cogap-standard-sequential-colimit
+--         ( tS , KS)
+--         ( p)
+--       where
+--       [i] :
+--         (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--         tr
+--           ( ev-pair
+--             ( right-family-descent-data-pushout R)
+--             ( right-map-span-diagram 𝒮 s))
+--           ( CB s n p)
+--           ( map-family-descent-data-pushout R
+--             ( s , map-cocone-standard-sequential-colimit n p)
+--             ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+--         tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
+--       [i] zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
+--       [i] (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
+--       tS :
+--         (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--         map-family-descent-data-pushout R
+--           ( s , map-cocone-standard-sequential-colimit n p)
+--           ( pr1
+--             ( ind-singleton-zigzag-id-pushout')
+--             ( left-map-span-diagram 𝒮 s ,
+--               map-cocone-standard-sequential-colimit n p)) ＝
+--         pr1
+--           ( pr2 ind-singleton-zigzag-id-pushout')
+--           ( right-map-span-diagram 𝒮 s ,
+--             concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
+--       tS n p =
+--         ( ap
+--           ( map-family-descent-data-pushout R
+--             ( s , map-cocone-standard-sequential-colimit n p))
+--           ( compute-incl-dependent-cogap-standard-sequential-colimit _ n p)) ∙
+--         ( map-equiv
+--           ( inv-equiv-ap-emb
+--             ( emb-equiv
+--               ( equiv-tr
+--                 ( ev-pair
+--                   ( right-family-descent-data-pushout R)
+--                   ( right-map-span-diagram 𝒮 s))
+--                 ( CB s n p))))
+--           ( [i] n p ∙
+--             inv
+--               ( ( apd
+--                   ( dependent-cogap-standard-sequential-colimit (tB (right-map-span-diagram 𝒮 s) , _))
+--                   ( CB s n p)) ∙
+--                 ( compute-incl-dependent-cogap-standard-sequential-colimit _ (succ-ℕ n) _))))
+--       KS :
+--         (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--         tr
+--           ( λ p →
+--             map-family-descent-data-pushout R
+--               ( s , p)
+--               ( pr1
+--                 ( ind-singleton-zigzag-id-pushout')
+--                 ( left-map-span-diagram 𝒮 s , p)) ＝
+--             pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p))
+--           ( coherence-cocone-standard-sequential-colimit n p)
+--           ( tS n p) ＝
+--         tS (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n p)
+--       KS n p =
+--         map-compute-dependent-identification-eq-value _ _
+--           ( coherence-cocone-standard-sequential-colimit n p)
+--           ( _)
+--           ( _)
+--           ( {!!})
+
+--     tS-in-diagram :
+--       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+--       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--       ( tr (ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+--         ( CB s n p)
+--         ( map-family-descent-data-pushout R _ (tA (left-map-span-diagram 𝒮 s) n p))) ＝
+--       ( tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
+--     tS-in-diagram s zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
+--     tS-in-diagram s (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
+
+--     module vertices
+--       (s : spanning-type-span-diagram 𝒮)
+--       where
+--       PAn : (n : ℕ) → UU (l1 ⊔ l2 ⊔ l3)
+--       PAn = Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s)
+--       QAn : {n : ℕ} → PAn n → UU l5
+--       QAn {n} p = left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p)
+--       PBn : (n : ℕ) → UU (l1 ⊔ l2 ⊔ l3)
+--       PBn = Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) ∘ succ-ℕ
+--       QBn : {n : ℕ} → PBn n → UU l5
+--       QBn {n} p = right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
+--       fn : {n : ℕ} → PAn n → PBn n
+--       fn = concat-s 𝒮 a₀ s _
+--       gn : {n : ℕ} → PAn n → PAn (succ-ℕ n)
+--       gn = inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) _
+--       hn : {n : ℕ} → PBn n → PBn (succ-ℕ n)
+--       hn = inl-Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) _
+--       mn : {n : ℕ} → PBn n → PAn (succ-ℕ n)
+--       mn {n} = concat-inv-s 𝒮 a₀ s (succ-ℕ n)
+--       sAn : {n : ℕ} (p : PAn n) → QAn p
+--       sAn = tA (left-map-span-diagram 𝒮 s) _
+--       sBn : {n : ℕ} (p : PBn n) → QBn p
+--       sBn = tB (right-map-span-diagram 𝒮 s) _
+--       f'n : {n : ℕ} {p : PAn n} → QAn p → QBn (fn p)
+--       f'n {n} {p} = Ψ s n p
+--       g'n : {n : ℕ} {p : PAn n} → QAn p → QAn (gn p)
+--       g'n {n} {p} =
+--         tr
+--           ( ev-pair
+--             ( left-family-descent-data-pushout R)
+--             ( left-map-span-diagram 𝒮 s))
+--           ( coherence-cocone-standard-sequential-colimit n p)
+--       h'n : {n : ℕ} {p : PBn n} → QBn p → QBn (hn p)
+--       h'n {n} {p} =
+--         tr
+--           ( ev-pair
+--             ( right-family-descent-data-pushout R)
+--             ( right-map-span-diagram 𝒮 s))
+--           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
+--       m'n : {n : ℕ} {p : PBn n} → QBn p → QAn (mn p)
+--       m'n = Φ' s _ _
+
+--     module sides
+--       (s : spanning-type-span-diagram 𝒮) (n : ℕ)
+--       where
+--       open vertices s
+--       left :
+--         {p : PAn n} → f'n (sAn p) ＝ sBn (fn p)
+--       left = tS-in-diagram s n _
+--       right :
+--         {p : PAn (succ-ℕ n)} →
+--         f'n (sAn p) ＝ sBn (fn p)
+--       right = tS-in-diagram s (succ-ℕ n) _
+--       bottom :
+--         {p : PAn n} → hn (fn p) ＝ fn (gn p)
+--       bottom =
+--         naturality-map-hom-diagram-zigzag-sequential-diagram
+--           ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
+--           ( n)
+--           ( _)
+--       bottom1 :
+--         {p : PAn n} → gn p ＝ mn (fn p)
+--       bottom1 = glue-pushout _ _ _
+--       bottom2 :
+--         {p : PBn n} → hn p ＝ fn (mn p)
+--       bottom2 = glue-pushout _ _ _
+--       far :
+--         {p : PAn n} → g'n (sAn p) ＝ sAn (gn p)
+--       far = far' n _
+--         where
+--         far' : (n : ℕ) (p : PAn n) → g'n (sAn p) ＝ sAn (gn p)
+--         far' zero-ℕ (map-raise refl) = inv (compute-inl-dependent-cogap _ _ _ _)
+--         far' (succ-ℕ n) p = inv (compute-inl-dependent-cogap _ _ _ _)
+--       near :
+--         {p : PBn n} → h'n (sBn p) ＝ sBn (hn p)
+--       near = inv (compute-inl-dependent-cogap _ _ _ _)
+--       mid :
+--         {p : PBn n} → m'n (sBn p) ＝ sAn (mn p)
+--       mid = mid' _ _
+--         where
+--         mid' : (n : ℕ) (p : PBn n) → m'n (sBn p) ＝ sAn (mn p)
+--         mid' zero-ℕ p = inv (compute-inr-dependent-cogap _ _ _ _)
+--         mid' (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
+--       top1 :
+--         {p : PAn n} (q : QAn p) →
+--         tr QAn bottom1 (g'n q) ＝ m'n (f'n q)
+--       top1 = α s n _
+--       top2 :
+--         {p : PBn n} (q : QBn p) →
+--         tr QBn bottom2 (h'n q) ＝ f'n (m'n q)
+--       top2 = β s n _
+--       top :
+--         {p : PAn n} (q : QAn p) →
+--         tr QBn bottom (h'n (f'n q)) ＝ f'n (g'n q)
+--       top = {!!}
+
+--     module CUBE
+--       (s : spanning-type-span-diagram 𝒮) (n : ℕ)
+--       where
+--       open vertices s
+--       open sides s n
+
+--       CUBE : (p : PAn n) → UU _
+--       CUBE p =
+--         ( top (sAn p) ∙ ap f'n far ∙ right) ＝
+--         ( ap (tr QBn bottom ∘ h'n) left ∙
+--           ap (tr QBn bottom) near ∙
+--           apd sBn bottom)
+
+--       PRISM1 : (p : PAn n) → UU _
+--       PRISM1 p =
+--         ( top1 (sAn p) ∙ ap m'n left ∙ mid) ＝
+--         ( ap (tr QAn bottom1) far ∙ apd sAn bottom1)
+
+--       PRISM2 : (p : PBn n) → UU _
+--       PRISM2 p =
+--         top2 (sBn p) ∙ ap f'n mid ∙ right ＝
+--         ap (tr QBn bottom2) near ∙ apd sBn bottom2
+
+--     module cube
+--       (s : spanning-type-span-diagram 𝒮)
+--       where abstract
+--       open vertices s
+--       open sides s
+--       open CUBE s
+
+--       -- THE COMMENTED CODE WORKS, DON'T DELETE IT!
+--       -- It just takes too long to typecheck it in its current state
+--       prism1 : (n : ℕ) → (p : PAn n) → PRISM1 n p
+--       prism1 = {!!}
+--       -- prism1 zero-ℕ (map-raise refl) =
+--       --   lem _ _ _ _ _
+--       --     ( ( ap
+--       --         ( _∙ (top1 0 (sAn _) ∙ ap m'n (left 0)))
+--       --         ( ( inv (ap-inv (tr QAn (bottom1 0)) (far 0))) ∙
+--       --           ( ap² (tr QAn (bottom1 0)) (inv-inv _)))) ∙
+--       --       ( [i]) ∙
+--       --       ( ap
+--       --         ( apd sAn (bottom1 0) ∙_)
+--       --         ( inv (inv-inv _))))
+--       --   where
+--       --     open import foundation.action-on-higher-identifications-functions
+--       --     [i] =
+--       --       inv
+--       --         ( compute-glue-dependent-cogap _ _
+--       --           ( pr1 (pr2 (stages-cocones' 0)) (left-map-span-diagram 𝒮 s))
+--       --           ( s , refl , (map-raise refl)))
+--       -- prism1 (succ-ℕ n) p =
+--       --   lem _ _ _ _ _
+--       --     ( ( ap
+--       --         ( _∙ (top1 (succ-ℕ n) (sAn _) ∙ ap m'n (left (succ-ℕ n))))
+--       --         ( ( inv (ap-inv (tr QAn (bottom1 (succ-ℕ n))) (far (succ-ℕ n)))) ∙
+--       --           ( ap² (tr QAn (bottom1 (succ-ℕ n))) (inv-inv _)))) ∙
+--       --       ( [i]) ∙
+--       --       ( ap
+--       --         ( apd sAn (bottom1 (succ-ℕ n)) ∙_)
+--       --         ( inv (inv-inv _))))
+--       --   where
+--       --     open import foundation.action-on-higher-identifications-functions
+--       --     [i] =
+--       --       inv
+--       --         ( compute-glue-dependent-cogap _ _
+--       --           ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) (left-map-span-diagram 𝒮 s))
+--       --           ( s , refl , p))
+
+--       prism2 : (n : ℕ) → (p : PBn n) → PRISM2 n p
+--       prism2 = {!!}
+--       -- prism2 0 p =
+--       --   lem _ _ _ _ _
+--       --     ( ( ap
+--       --         ( _∙ (top2 0 (sBn p) ∙ ap f'n (mid 0)))
+--       --         ( ( inv (ap-inv (tr QBn (bottom2 0)) (near 0))) ∙
+--       --           ( ap² (tr (QBn {1}) (bottom2 0)) (inv-inv _)))) ∙
+--       --       ( inv [ii]) ∙
+--       --       ( ap
+--       --         ( apd sBn (bottom2 0) ∙_)
+--       --         ( inv (inv-inv _))))
+--       --   where
+--       --     open import foundation.action-on-higher-identifications-functions
+--       --     [i] =
+--       --       -- inv
+--       --         ( compute-glue-dependent-cogap _ _
+--       --           ( pr1 (stages-cocones' 1) (right-map-span-diagram 𝒮 s))
+--       --           ( s , refl , p))
+--       --     [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 0 (sBn p) ∙ ap f'n (inv q))) right-unit
+--       -- prism2 (succ-ℕ n) p =
+--       --   lem _ _ _ _ _
+--       --     ( ( ap
+--       --         ( _∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (mid (succ-ℕ n))))
+--       --         ( ( inv (ap-inv (tr QBn (bottom2 (succ-ℕ n))) (near (succ-ℕ n)))) ∙
+--       --           ( ap² (tr QBn (bottom2 (succ-ℕ n))) (inv-inv _)))) ∙
+--       --       ( inv [ii]) ∙
+--       --       ( ap
+--       --         ( apd sBn (bottom2 (succ-ℕ n)) ∙_)
+--       --         ( inv (inv-inv _))))
+--       --   where
+--       --     open import foundation.action-on-higher-identifications-functions
+--       --     [i] =
+--       --       -- inv
+--       --         ( compute-glue-dependent-cogap _ _
+--       --           ( pr1 (stages-cocones' (succ-ℕ (succ-ℕ n))) (right-map-span-diagram 𝒮 s))
+--       --           ( s , refl , p))
+--       --     [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (inv q))) right-unit
+
+--       cube :
+--         (n : ℕ) → (p : PAn n) → CUBE n p
+--       cube = {!!}
+
+--     KS-in-diagram :
+--       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+--       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+--       sides.top s n (vertices.sAn s p) ∙
+--        ap (vertices.f'n s) (sides.far s n)
+--        ∙ sides.right s n
+--        ＝
+--        ap (tr (vertices.QBn s) (sides.bottom s n) ∘ vertices.h'n s)
+--        (sides.left s n)
+--        ∙ ap (tr (vertices.QBn s) (sides.bottom s n)) (sides.near s n)
+--        ∙ apd (vertices.sBn s) (sides.bottom s n)
+--     KS-in-diagram = cube.cube
+
+--   is-identity-system-zigzag-id-pushout :
+--     is-identity-system-descent-data-pushout
+--       ( descent-data-zigzag-id-pushout 𝒮 a₀)
+--       ( refl-id-pushout 𝒮 a₀)
+--   is-identity-system-zigzag-id-pushout =
+--     is-identity-system-descent-data-pushout-ind-singleton up-c
+--       ( descent-data-zigzag-id-pushout 𝒮 a₀)
+--       ( refl-id-pushout 𝒮 a₀)
+--       ( ind-singleton-zigzag-id-pushout')
+-- ```
diff --git a/src/synthetic-homotopy-theory/zigzags-sequential-diagrams.lagda.md b/src/synthetic-homotopy-theory/zigzags-sequential-diagrams.lagda.md
index 71068b80e1..c521df41bf 100644
--- a/src/synthetic-homotopy-theory/zigzags-sequential-diagrams.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzags-sequential-diagrams.lagda.md
@@ -247,10 +247,9 @@ module _
   (z : zigzag-sequential-diagram A B)
   where
 
-  hom-diagram-zigzag-sequential-diagram : hom-sequential-diagram A B
-  pr1 hom-diagram-zigzag-sequential-diagram =
-    map-zigzag-sequential-diagram z
-  pr2 hom-diagram-zigzag-sequential-diagram n =
+  naturality-map-hom-diagram-zigzag-sequential-diagram :
+    naturality-hom-sequential-diagram A B (map-zigzag-sequential-diagram z)
+  naturality-map-hom-diagram-zigzag-sequential-diagram n =
     horizontal-pasting-up-diagonal-coherence-triangle-maps
       ( map-sequential-diagram A n)
       ( map-zigzag-sequential-diagram z n)
@@ -259,6 +258,12 @@ module _
       ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
       ( lower-triangle-zigzag-sequential-diagram z n)
 
+  hom-diagram-zigzag-sequential-diagram : hom-sequential-diagram A B
+  pr1 hom-diagram-zigzag-sequential-diagram =
+    map-zigzag-sequential-diagram z
+  pr2 hom-diagram-zigzag-sequential-diagram =
+    naturality-map-hom-diagram-zigzag-sequential-diagram
+
 module _
   {l1 l2 : Level} {A : sequential-diagram l1} {B : sequential-diagram l2}
   (z : zigzag-sequential-diagram A B)

From be588383c80d127d9841a3d09197388bad1bc82b Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Thu, 16 Jan 2025 17:19:23 +0100
Subject: [PATCH 13/33] More infra

---
 ...nstruction-identity-type-pushouts.lagda.md | 2396 +++++++++--------
 1 file changed, 1329 insertions(+), 1067 deletions(-)

diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index cb4e84aa09..0c756569a9 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -64,8 +64,10 @@ colimits of pushouts.
 
 ```agda
 open import foundation.commuting-triangles-of-maps
+open import foundation.whiskering-homotopies-concatenation
 open import foundation.homotopy-induction
 open import foundation.dependent-homotopies
+
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2}
@@ -79,6 +81,20 @@ module _
   htpy-over : UU (l1 ⊔ l3 ⊔ l4)
   htpy-over = {a : A} (a' : A' a) → dependent-identification B' (H a) (f' a') (g' a')
 
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2}
+  {A' : A → UU l3} (B' : B → UU l4)
+  {f g : A → B}
+  (H : f ~ g)
+  (f' : {a : A} → A' a → B' (f a))
+  (g' : {a : A} → A' a → B' (g a))
+  where
+
+  inv-htpy-over : htpy-over B' H f' g' → htpy-over B' (inv-htpy H) g' f'
+  inv-htpy-over H' a' =
+    map-eq-transpose-equiv-inv (equiv-tr B' (H _)) (inv (H' a'))
+
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
   {A : UU l1} {B : UU l2} {X : UU l3}
@@ -106,15 +122,43 @@ module _
   {s : B → X} (s' : {b : B} → B' b → X' (s b))
   where
 
+  LWMOTIF : {a : A} (a' : A' a) (g : A → B) (H : f ~ g) → UU (l5 ⊔ l6)
+  LWMOTIF {a} a' g H =
+    {g'a' : B' (g a)} →
+    (H' : tr B' (H a) (f' a') ＝ g'a') →
+    tr X' (ap s (H a)) (s' (f' a')) ＝ s' (g'a')
+
   left-whisk-htpy-over : htpy-over X' (s ·l H) (s' ∘ f') (s' ∘ g')
-  left-whisk-htpy-over =
+  left-whisk-htpy-over {a} a' =
     ind-htpy f
-      ( λ g H →
-        {g' : {a : A} → A' a → B' (g a)} (H' : htpy-over B' H f' g') →
-        htpy-over X' (s ·l H) (s' ∘ f') (s' ∘ g'))
-      ( λ H' → s' ·l H')
+      ( LWMOTIF a')
+      ( ap s')
       ( H)
-      ( H')
+      ( H' a')
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f : A → B}
+  {f' g' : {a : A} → A' a → B' (f a)}
+  (H' : {a : A} → f' {a} ~ g')
+  {s : B → X} (s' : {b : B} → B' b → X' (s b))
+  where
+
+  open import foundation.function-extensionality
+
+  compute-left-whisk-htpy-over :
+    {a : A} (a' : A' a) →
+    left-whisk-htpy-over {B' = B'} {X' = X'} {f = f} refl-htpy H' s' a' ＝ ap s' (H' a')
+  compute-left-whisk-htpy-over a' =
+    htpy-eq
+      ( htpy-eq-implicit
+        ( compute-ind-htpy f
+          ( LWMOTIF {B' = B'} {X' = X'} refl-htpy H' s' a')
+          ( ap s'))
+        ( g' a'))
+      ( H' a')
 
 module _
   {l1 l2 l3 l4 : Level}
@@ -131,48 +175,6 @@ module _
   concat-htpy-over {a} a' =
     concat-dependent-identification B' (H a) (K a) (H' a') (K' a')
 
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
-  (f : A → B) (g : A → X) (m : B → X)
-  (f' : {a : A} → A' a → B' (f a))
-  (g' : {a : A} → A' a → X' (g a))
-  (m' : {b : B} → B' b → X' (m b))
-  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sX : (x : X) → X' x)
-  (F : (a : A) → f' (sA a) ＝ sB (f a))
-  (G : (a : A) → g' (sA a) ＝ sX (g a))
-  (M : (b : B) → m' (sB b) ＝ sX (m b))
-  where
-
-  section-triangle-over :
-    (H : coherence-triangle-maps g m f) →
-    (H' : htpy-over X' H g' (m' ∘ f')) →
-    UU (l1 ⊔ l6)
-  section-triangle-over H H' =
-    (a : A) →
-    H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
-    ap (tr X' (H a)) (G a) ∙ apd sX (H a)
-
-  section-triangle-over' :
-    (H : coherence-triangle-maps' g m f) →
-    (H' : htpy-over X' H (m' ∘ f') g') →
-    UU (l1 ⊔ l6)
-  section-triangle-over' H H' =
-    (a : A) →
-    ( H' (sA a) ∙ G a) ＝
-    ( ap (tr X' (H a) ∘ m') (F a) ∙ ap (tr X' (H a)) (M (f a)) ∙ apd sX (H a))
-
-  -- actually ≐ section-triangle-over 🤔
-  -- section-triangle-over-inv :
-  --   (H : coherence-triangle-maps g m f) →
-  --   (H' : {a : A} (a' : A' a) → dependent-identification X' (H a) (g' a') (m' (f' a'))) →
-  --   UU (l1 ⊔ l6)
-  -- section-triangle-over-inv H H' =
-  --   (a : A) →
-  --   H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
-  --   ap (tr X' (H a)) (G a) ∙ apd sX (H a)
-
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
@@ -201,6 +203,7 @@ module _
   comp-section-map-over G F =
     g' ·l F ∙h G ·r f
 
+
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
@@ -221,6 +224,159 @@ module _
     H' (sA a) ∙ G a ＝
     ap (tr B' (H a)) (F a) ∙ apd sB (H a)
 
+module _
+  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+  {A' : A → UU l5} {B' : B → UU l6} {C' : C → UU l7} {D' : D → UU l8}
+  {f : A → B} {g : B → C} {h : C → D}
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {b : B} → B' b → C' (g b)}
+  {h' : {c : C} → C' c → D' (h c)}
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (sC : (c : C) → C' c)
+  (sD : (d : D) → D' d)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sB sC)
+  (H : section-map-over h h' sC sD)
+  where
+
+  assoc-comp-section-map-over :
+    section-htpy-over
+      ( refl-htpy {f = h ∘ g ∘ f})
+      ( refl-htpy {f = h' ∘ g' ∘ f'})
+      sA sD
+      ( comp-section-map-over (h ∘ g) f (h' ∘ g') f' sA sB sD
+        ( comp-section-map-over h g h' g' sB sC sD H G)
+        ( F))
+      ( comp-section-map-over h (g ∘ f) h' (g' ∘ f') sA sC sD H
+        ( comp-section-map-over g f g' f' sA sB sC G F))
+  assoc-comp-section-map-over =
+    inv-htpy
+      ( right-unit-htpy ∙h
+        left-unit-law-left-whisker-comp _ ∙h
+        inv-htpy-assoc-htpy _ _ _ ∙h
+        right-whisker-concat-htpy
+          ( ( right-whisker-concat-htpy
+              ( inv-preserves-comp-left-whisker-comp h' g' F)
+              ( h' ·l G ·r f)) ∙h
+            ( inv-htpy
+              ( distributive-left-whisker-comp-concat h'
+                ( g' ·l F)
+                ( G ·r f))))
+          ( H ·r g ·r f))
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  (α : section-htpy-over H H' sA sB F G)
+  (s : X → A)
+  (s' : {x : X} → X' x → A' (s x))
+  (sX : (x : X) → X' x)
+  (S : section-map-over s s' sX sA)
+  where
+
+  right-whisk-section-htpy-over :
+    section-htpy-over (H ·r s)
+      ( right-whisk-htpy-over H H' s')
+      sX sB
+      ( comp-section-map-over f s f' s' sX sA sB F S)
+      ( comp-section-map-over g s g' s' sX sA sB G S)
+  right-whisk-section-htpy-over =
+    ind-htpy f
+      ( λ g H →
+          {g' : {a : A} → A' a → B' (g a)}
+          (H' : htpy-over B' H f' g')
+          (G : section-map-over g g' sA sB)
+          (α : section-htpy-over H H' sA sB F G) →
+          section-htpy-over (H ·r s)
+            ( right-whisk-htpy-over H H' s')
+            sX sB
+            ( comp-section-map-over f s f' s' sX sA sB F S)
+            ( comp-section-map-over g s g' s' sX sA sB G S))
+      ( λ H' G α x →
+        ind-htpy (f' {s x})
+          ( λ g'sx H'sx →
+            (Gsx : g'sx (sA (s x)) ＝ sB (f (s x)))
+            (αsx : H'sx (sA (s x)) ∙ Gsx ＝ ap (tr B' refl) (F (s x)) ∙ apd sB refl) →
+            H'sx (s' (sX x)) ∙ ((ap g'sx (S x)) ∙ Gsx) ＝
+            ap (tr B' refl) (ap f' (S x) ∙ (F (s x))) ∙ apd sB refl)
+          ( λ Gsx αsx → inv (right-unit ∙ (ap-id _ ∙ ap (ap f' (S x) ∙_) (inv (αsx ∙ (right-unit ∙ ap-id _))))))
+          ( H')
+          ( G (s x))
+          ( α (s x)))
+      ( H)
+      ( H')
+      ( G)
+      ( α)
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  (α : section-htpy-over H H' sA sB F G)
+  (s : B → X)
+  (s' : {b : B} → B' b → X' (s b))
+  (sX : (x : X) → X' x)
+  (S : section-map-over s s' sB sX)
+  where
+
+  open import foundation.function-extensionality
+
+  left-whisk-section-htpy-over :
+    section-htpy-over (s ·l H)
+      ( left-whisk-htpy-over H H' s')
+      sA sX
+      ( comp-section-map-over s f s' f' sA sB sX S F)
+      ( comp-section-map-over s g s' g' sA sB sX S G)
+  left-whisk-section-htpy-over =
+    ind-htpy f
+      ( λ g H →
+        {g' : {a : A} → A' a → B' (g a)} →
+        (H' : htpy-over B' H f' g')
+        (G : section-map-over g g' sA sB)
+        (α : section-htpy-over H H' sA sB F G) →
+        section-htpy-over (s ·l H)
+          ( left-whisk-htpy-over H H' s')
+          sA sX
+          ( comp-section-map-over s f s' f' sA sB sX S F)
+          ( comp-section-map-over s g s' g' sA sB sX S G))
+      ( λ H' G α a →
+        ap (_∙ (ap s' (G a) ∙ S (f a)))
+          ( compute-left-whisk-htpy-over H' s' (sA a)) ∙
+        ind-htpy f'
+          ( λ g'a H'a →
+            (Ga : g'a (sA a) ＝ sB (f a)) →
+            (αa : H'a (sA a) ∙ Ga ＝ ap (tr B' refl) (F a) ∙ apd sB refl) →
+            ap s' (H'a (sA a)) ∙ (ap s' Ga ∙ S (f a)) ＝ ap (tr X' refl) (ap s' (F a) ∙ S (f a)) ∙ apd sX refl)
+          ( λ Ga αa → inv (right-unit ∙ (ap-id _ ∙ ap (_∙ S (f a)) (inv (ap (ap s') (αa ∙ (right-unit ∙ ap-id _)))))))
+          ( H')
+          ( G a)
+          ( α a))
+      ( H)
+      ( H')
+      ( G)
+      ( α)
+
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
@@ -291,6 +447,73 @@ module _
       ( α)
       ( β)
 
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  (f : A → B) (g : A → X) (m : B → X)
+  (f' : {a : A} → A' a → B' (f a))
+  (g' : {a : A} → A' a → X' (g a))
+  (m' : {b : B} → B' b → X' (m b))
+  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sX : (x : X) → X' x)
+  (F : (a : A) → f' (sA a) ＝ sB (f a))
+  (G : (a : A) → g' (sA a) ＝ sX (g a))
+  (M : (b : B) → m' (sB b) ＝ sX (m b))
+  where
+
+  section-triangle-over :
+    (H : coherence-triangle-maps g m f) →
+    (H' : htpy-over X' H g' (m' ∘ f')) →
+    UU (l1 ⊔ l6)
+  section-triangle-over H H' =
+    (a : A) →
+    H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
+    ap (tr X' (H a)) (G a) ∙ apd sX (H a)
+
+  unget-section-triangle-over :
+    (H : coherence-triangle-maps g m f) →
+    (H' : htpy-over X' H g' (m' ∘ f')) →
+    section-triangle-over H H' →
+    section-htpy-over H H' sA sX G
+      ( comp-section-map-over m f m' f' sA sB sX M F)
+  unget-section-triangle-over H H' α = inv-htpy-assoc-htpy _ _ _ ∙h α
+
+  section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    UU (l1 ⊔ l6)
+  section-triangle-over' H H' =
+    (a : A) →
+    H' (sA a) ∙ G a ＝
+    ap (tr X' (H a) ∘ m') (F a) ∙ ap (tr X' (H a)) (M (f a)) ∙ apd sX (H a)
+
+  unget-section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    section-triangle-over' H H' →
+    section-htpy-over H H' sA sX
+      ( comp-section-map-over m f m' f' sA sB sX M F)
+      ( G)
+  unget-section-triangle-over' H H' α =
+    α ∙h
+    ( λ a →
+      ap
+        ( _∙ apd sX (H a))
+        ( ( ap
+            ( _∙ ap (tr X' (H a)) (M (f a)))
+            ( ap-comp (tr X' (H a)) m' (F a))) ∙
+          ( inv (ap-concat (tr X' (H a)) (ap m' (F a)) (M (f a))))))
+
+  -- actually ≐ section-triangle-over 🤔
+  -- section-triangle-over-inv :
+  --   (H : coherence-triangle-maps g m f) →
+  --   (H' : {a : A} (a' : A' a) → dependent-identification X' (H a) (g' a') (m' (f' a'))) →
+  --   UU (l1 ⊔ l6)
+  -- section-triangle-over-inv H H' =
+  --   (a : A) →
+  --   H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
+  --   ap (tr X' (H a)) (G a) ∙ apd sX (H a)
+
 module _
   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
   {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
@@ -326,7 +549,11 @@ module _
         ( comp-section-map-over g2 f1 g2' f1' s1 s2 s4 G2 F1)
         ( comp-section-map-over f2 g1 f2' g1' s1 s3 s4 F2 G1) →
       section-square-over
-    get-section-square-over = {!!}
+    get-section-square-over α p =
+      assoc _ _ _ ∙
+      α p ∙
+      ap (_∙ apd s4 (H p))
+        (ap-concat (tr Q4 (H p)) _ _ ∙ ap (_∙ _) (inv (ap-comp _ g2' (F1 p))))
 
   module _
     (m : P2 → P3)
@@ -384,1022 +611,1057 @@ module _
              ( comp-section-map-over f2 m f2' m' s2 s3 s4 F2 M)
              ( F1))
            ( comp-section-map-over f2 g1 f2' g1' s1 s3 s4 F2 G1)
-           {!!}
-           {!!})
+           ( [ii])
+           ( concat-section-htpy-over refl-htpy (f2 ·l B1) refl-htpy
+             ( left-whisk-htpy-over B1 T1 f2')
+             s1 s4 _ _ _
+             ( assoc-comp-section-map-over _ _ _ _ F1 M F2)
+             ( [iv])))
+      where
+        [i] = unget-section-triangle-over m g2 f2 m' g2' f2' s2 s3 s4 M G2 F2 B2 T2 S2
+        [ii] = right-whisk-section-htpy-over B2 T2 s2 s4 _ _ [i] f1 f1' s1 F1
+        [iii] = unget-section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 S1
+        [iv] = left-whisk-section-htpy-over B1 T1 s1 s3 _ _ [iii] f2 f2' s4 F2
+
+module _
+  {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
+  where
+
+  type-stage-zigzag-construction-id-pushout : ℕ → UU (lsuc (l1 ⊔ l2 ⊔ l3))
+  type-stage-zigzag-construction-id-pushout n =
+    Σ ( codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
+      ( λ Path-to-b →
+        Σ ( domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
+          ( λ Path-to-a →
+            ( Σ ( (s : spanning-type-span-diagram 𝒮) →
+                  Path-to-b (right-map-span-diagram 𝒮 s) →
+                  Path-to-a (left-map-span-diagram 𝒮 s))
+                ( λ _ →
+                  rec-ℕ
+                    ( raise-unit (lsuc (l1 ⊔ l2 ⊔ l3)))
+                    ( λ _ _ →
+                      ( codomain-span-diagram 𝒮 →
+                        span-diagram
+                          ( l1 ⊔ l2 ⊔ l3)
+                          ( l1 ⊔ l2 ⊔ l3)
+                          ( l1 ⊔ l2 ⊔ l3)) ×
+                      ( domain-span-diagram 𝒮 →
+                        span-diagram
+                          ( l1 ⊔ l2 ⊔ l3)
+                          ( l1 ⊔ l2 ⊔ l3)
+                          ( l1 ⊔ l2 ⊔ l3)))
+                    ( n)))))
+
+module _
+  {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
+  (a₀ : domain-span-diagram 𝒮)
+  where
+
+  stage-zigzag-construction-id-pushout :
+    (n : ℕ) → type-stage-zigzag-construction-id-pushout 𝒮 n
+  stage-zigzag-construction-id-pushout zero-ℕ =
+    Path-to-b ,
+    Path-to-a ,
+    ( λ s → raise-ex-falso _) ,
+    raise-star
+    where
+    Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+    Path-to-b _ = raise-empty _
+    Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+    Path-to-a a = raise (l2 ⊔ l3) (a₀ ＝ a)
+  stage-zigzag-construction-id-pushout (succ-ℕ n) =
+    Path-to-b ,
+    Path-to-a ,
+    ( λ s p → inr-pushout _ _ (s , refl , p)) ,
+    span-diagram-B ,
+    span-diagram-A
+    where
+    span-diagram-B :
+      codomain-span-diagram 𝒮 →
+      span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
+    span-diagram-B b =
+      make-span-diagram
+        ( pr2 ∘ pr2)
+        ( tot
+          ( λ s →
+            tot
+              ( λ r (p : pr1 (stage-zigzag-construction-id-pushout n) b) →
+                pr1
+                  ( pr2 (pr2 (stage-zigzag-construction-id-pushout n)))
+                  ( s)
+                  ( tr (pr1 (stage-zigzag-construction-id-pushout n)) r p))))
+    Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+    Path-to-b b = standard-pushout (span-diagram-B b)
+    span-diagram-A :
+      domain-span-diagram 𝒮 →
+      span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
+    span-diagram-A a =
+      make-span-diagram
+        ( pr2 ∘ pr2)
+        ( tot
+          ( λ s →
+            tot
+              ( λ r (p : pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a) →
+                inr-standard-pushout
+                  ( span-diagram-B (right-map-span-diagram 𝒮 s))
+                  ( ( s) ,
+                    ( refl) ,
+                    ( tr
+                      ( pr1 (pr2 (stage-zigzag-construction-id-pushout n)))
+                      ( r)
+                      ( p))))))
+    Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+    Path-to-a a = standard-pushout (span-diagram-A a)
+
+  span-diagram-path-to-b :
+    codomain-span-diagram 𝒮 → ℕ →
+    span-diagram
+      ( l1 ⊔ l2 ⊔ l3)
+      ( l1 ⊔ l2 ⊔ l3)
+      ( l1 ⊔ l2 ⊔ l3)
+  span-diagram-path-to-b b n =
+    pr1 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) b
+
+  span-diagram-path-to-a :
+    domain-span-diagram 𝒮 → ℕ →
+    span-diagram
+      ( l1 ⊔ l2 ⊔ l3)
+      ( l1 ⊔ l2 ⊔ l3)
+      ( l1 ⊔ l2 ⊔ l3)
+  span-diagram-path-to-a a n =
+    pr2 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) a
+
+  Path-to-b : codomain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
+  Path-to-b b n = pr1 (stage-zigzag-construction-id-pushout n) b
+
+  Path-to-a : domain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
+  Path-to-a a n = pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a
+
+  inl-Path-to-b :
+    (b : codomain-span-diagram 𝒮) (n : ℕ) → Path-to-b b n → Path-to-b b (succ-ℕ n)
+  inl-Path-to-b b n =
+    inl-standard-pushout
+      ( span-diagram-path-to-b b n)
+
+  inl-Path-to-a :
+    (a : domain-span-diagram 𝒮) (n : ℕ) → Path-to-a a n → Path-to-a a (succ-ℕ n)
+  inl-Path-to-a a n =
+    inl-standard-pushout
+      ( span-diagram-path-to-a a n)
+
+  concat-inv-s :
+    (s : spanning-type-span-diagram 𝒮) →
+    (n : ℕ) →
+    Path-to-b (right-map-span-diagram 𝒮 s) n →
+    Path-to-a (left-map-span-diagram 𝒮 s) n
+  concat-inv-s s n = pr1 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
+
+  concat-s :
+    (s : spanning-type-span-diagram 𝒮) →
+    (n : ℕ) →
+    Path-to-a (left-map-span-diagram 𝒮 s) n →
+    Path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n)
+  concat-s s n p =
+    inr-standard-pushout
+      ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) n)
+      ( s , refl , p)
+
+  right-sequential-diagram-zigzag-id-pushout :
+    codomain-span-diagram 𝒮 →
+    sequential-diagram (l1 ⊔ l2 ⊔ l3)
+  pr1 (right-sequential-diagram-zigzag-id-pushout b) = Path-to-b b
+  pr2 (right-sequential-diagram-zigzag-id-pushout b) = inl-Path-to-b b
+
+  left-sequential-diagram-zigzag-id-pushout :
+    domain-span-diagram 𝒮 →
+    sequential-diagram (l1 ⊔ l2 ⊔ l3)
+  pr1 (left-sequential-diagram-zigzag-id-pushout a) = Path-to-a a
+  pr2 (left-sequential-diagram-zigzag-id-pushout a) = inl-Path-to-a a
+
+  zigzag-sequential-diagram-zigzag-id-pushout :
+    (s : spanning-type-span-diagram 𝒮) →
+    zigzag-sequential-diagram
+      ( left-sequential-diagram-zigzag-id-pushout
+        ( left-map-span-diagram 𝒮 s))
+      ( shift-once-sequential-diagram
+        ( right-sequential-diagram-zigzag-id-pushout
+          ( right-map-span-diagram 𝒮 s)))
+  pr1 (zigzag-sequential-diagram-zigzag-id-pushout s) =
+    concat-s s
+  pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s)) n =
+    concat-inv-s s (succ-ℕ n)
+  pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
+    glue-standard-pushout
+      ( span-diagram-path-to-a (left-map-span-diagram 𝒮 s) n)
+      ( s , refl , p)
+  pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
+    glue-standard-pushout
+      ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n))
+      ( s , refl , p)
+
+  left-id-pushout : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+  left-id-pushout a =
+    standard-sequential-colimit (left-sequential-diagram-zigzag-id-pushout a)
+
+  refl-id-pushout : left-id-pushout a₀
+  refl-id-pushout =
+    map-cocone-standard-sequential-colimit 0 (map-raise refl)
+
+  right-id-pushout : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
+  right-id-pushout b =
+    standard-sequential-colimit (right-sequential-diagram-zigzag-id-pushout b)
+
+  equiv-id-pushout :
+    (s : spanning-type-span-diagram 𝒮) →
+    left-id-pushout (left-map-span-diagram 𝒮 s) ≃
+    right-id-pushout (right-map-span-diagram 𝒮 s)
+  equiv-id-pushout s =
+    equiv-colimit-zigzag-sequential-diagram _ _
+      ( up-standard-sequential-colimit)
+      ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+      ( zigzag-sequential-diagram-zigzag-id-pushout s)
+
+  -- concat-inv-s-inf :
+  --   (s : spanning-type-span-diagram 𝒮) →
+  --   right-id-pushout (right-map-span-diagram 𝒮 s) →
+  --   left-id-pushout (left-map-span-diagram 𝒮 s)
+  -- concat-inv-s-inf s =
+  --   map-inv-equiv (equiv-id-pushout s)
+
+  concat-s-inf :
+    (s : spanning-type-span-diagram 𝒮) →
+    left-id-pushout (left-map-span-diagram 𝒮 s) →
+    right-id-pushout (right-map-span-diagram 𝒮 s)
+  concat-s-inf s =
+    map-equiv (equiv-id-pushout s)
+
+  descent-data-zigzag-id-pushout : descent-data-pushout 𝒮 (l1 ⊔ l2 ⊔ l3)
+  pr1 descent-data-zigzag-id-pushout = left-id-pushout
+  pr1 (pr2 descent-data-zigzag-id-pushout) = right-id-pushout
+  pr2 (pr2 descent-data-zigzag-id-pushout) = equiv-id-pushout
+```
+
+## Theorem
+
+### TODO
+
+```agda
+nat-lemma :
+  {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
+  {P : A → UU l3} {Q : B → UU l4}
+  (f : A → B) (h : (a : A) → P a → Q (f a))
+  {x y : A} {p : x ＝ y}
+  {q : f x ＝ f y} (α : ap f p ＝ q) →
+  coherence-square-maps
+    ( tr P p)
+    ( h x)
+    ( h y)
+    ( tr Q q)
+nat-lemma f h {p = p} refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
+
+apd-lemma :
+  {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
+  (f : (a : A) → B a) (g : (a : A) → B a → C a) {x y : A} (p : x ＝ y) →
+  apd (λ a → g a (f a)) p ＝ inv (preserves-tr g p (f x)) ∙ ap (g y) (apd f p)
+apd-lemma f g refl = refl
+
+lem :
+  {l : Level} {X : UU l} {x y z u v : X} →
+  (p : y ＝ x) (q : y ＝ z) (r : z ＝ u) (s : x ＝ v) (t : u ＝ v) →
+  (inv p ∙ (q ∙ r) ＝ s ∙ inv t) → q ∙ r ∙ t ＝ p ∙ s
+lem refl q r refl refl x = right-unit ∙ x
+
+module _
+  {l1 l2 l3 l4 : Level} {𝒮 : span-diagram l1 l2 l3}
+  {X : UU l4} {c : cocone-span-diagram 𝒮 X}
+  (up-c : universal-property-pushout _ _ c)
+  (a₀ : domain-span-diagram 𝒮)
+  where
+
+  module _
+    {l5 : Level}
+    (R : descent-data-pushout
+      ( span-diagram-flattening-descent-data-pushout
+        ( descent-data-zigzag-id-pushout 𝒮 a₀))
+      ( l5))
+    (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
+    where
+
+    private
+      CB :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        concat-s-inf 𝒮 a₀ s
+          ( map-cocone-standard-sequential-colimit n p) ＝
+        map-cocone-standard-sequential-colimit (succ-ℕ n)
+          ( concat-s 𝒮 a₀ s n p)
+      CB s =
+        htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+          ( up-standard-sequential-colimit)
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit
+              ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
+          ( hom-diagram-zigzag-sequential-diagram
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+
+      Ψ :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        left-family-descent-data-pushout R
+          ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p) →
+        right-family-descent-data-pushout R
+          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
+      Ψ s n p =
+        ( tr
+          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+          ( CB s n p)) ∘
+        ( map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p))
+
+      Φ :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+        right-family-descent-data-pushout R
+          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
+        right-family-descent-data-pushout R
+          ( right-map-span-diagram 𝒮 s ,
+            concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+      Φ s n p =
+        ( tr
+          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+          ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))) ∘
+        ( tr
+          ( λ p →
+            right-family-descent-data-pushout R
+              ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+          ( glue-pushout _ _ (s , refl , p))) ∘
+        ( tr
+          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
+
+      Φ' :
+        (s : spanning-type-span-diagram 𝒮) →
+        (n : ℕ) →
+        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+        right-family-descent-data-pushout R
+          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
+        left-family-descent-data-pushout R
+          ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+      Φ' s n p =
+        ( inv-map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))) ∘
+        ( Φ s n p)
+
+    coh-dep-cocone-a :
+      (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+      coherence-square-maps
+        ( ( tr
+            ( λ p →
+              left-family-descent-data-pushout R
+                ( left-map-span-diagram 𝒮 s ,
+                  map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+            ( glue-pushout _ _ (s , refl , p))) ∘
+          ( tr
+            ( ev-pair
+              ( left-family-descent-data-pushout R)
+              ( left-map-span-diagram 𝒮 s))
+            ( coherence-cocone-standard-sequential-colimit n p)))
+        ( map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p))
+        ( map-family-descent-data-pushout R
+          ( s ,
+            map-cocone-standard-sequential-colimit (succ-ℕ n)
+              ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
+        ( ( tr
+            ( ev-pair
+              ( right-family-descent-data-pushout R)
+              ( right-map-span-diagram 𝒮 s))
+            ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
+          ( tr
+            ( λ p →
+              right-family-descent-data-pushout R
+                ( right-map-span-diagram 𝒮 s ,
+                  map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+            ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
+          ( tr
+            ( ev-pair
+              ( right-family-descent-data-pushout R)
+              ( right-map-span-diagram 𝒮 s))
+            ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))) ∘
+          ( tr
+            ( ev-pair
+              ( right-family-descent-data-pushout R)
+              ( right-map-span-diagram 𝒮 s))
+            ( CB s n p)))
+    coh-dep-cocone-a s n p =
+      ( ( inv-htpy
+          ( ( tr-concat _ _) ∙h
+            ( ( tr _ _) ·l
+              ( ( tr-concat _ _) ∙h
+                ( horizontal-concat-htpy
+                  ( λ _ → substitution-law-tr _ _ _)
+                  ( tr-concat _ _)))))) ·r
+        ( map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p))) ∙h
+      ( nat-lemma
+          ( concat-s-inf 𝒮 a₀ s)
+          ( ev-pair (map-family-descent-data-pushout R) s)
+          ( [i] p)) ∙h
+      ( ( map-family-descent-data-pushout R
+          ( s ,
+            map-cocone-standard-sequential-colimit
+              ( succ-ℕ n)
+              ( concat-inv-s 𝒮 a₀ s
+                ( succ-ℕ n)
+                ( concat-s 𝒮 a₀ s n p)))) ·l
+        ( ( tr-concat _ _) ∙h
+          ( λ q → substitution-law-tr _ _ _)))
+      where
+      [i] :
+        ( ( concat-s-inf 𝒮 a₀ s) ·l
+          ( ( coherence-cocone-standard-sequential-colimit n) ∙h
+            ( ( map-cocone-standard-sequential-colimit
+              { A =
+                left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                  ( left-map-span-diagram 𝒮 s)}
+              ( succ-ℕ n)) ·l
+            ( λ p → glue-pushout _ _ (s , refl , p))))) ~
+        ( ( CB s n) ∙h
+          ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
+              ( concat-s 𝒮 a₀ s n)) ∙h
+          ( ( map-cocone-standard-sequential-colimit
+              { A =
+                right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                  ( right-map-span-diagram 𝒮 s)}
+              ( succ-ℕ (succ-ℕ n))) ·l
+            ( λ p → glue-pushout _ _ ( s , refl , concat-s 𝒮 a₀ s n p))) ∙h
+          ( ( inv-htpy (CB s (succ-ℕ n))) ·r
+            ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
+      [i] =
+        ( distributive-left-whisker-comp-concat _ _ _) ∙h
+        ( right-transpose-htpy-concat _ _ _
+          ( ( left-whisker-concat-coherence-square-homotopies _ _ _ _ _
+              ( λ p →
+                inv
+                  ( nat-coherence-square-maps _ _ _ _
+                    ( CB s (succ-ℕ n))
+                    ( glue-pushout _ _ (s , refl , p))))) ∙h
+            ( map-inv-equiv
+              ( equiv-right-transpose-htpy-concat _ _ _)
+              ( ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+                  ( up-standard-sequential-colimit)
+                  ( shift-once-cocone-sequential-diagram
+                    ( cocone-standard-sequential-colimit
+                      ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                        ( right-map-span-diagram 𝒮 s))))
+                  ( hom-diagram-zigzag-sequential-diagram
+                    ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+                  ( n)) ∙h
+                ( ap-concat-htpy
+                  ( CB s n)
+                  ( ( ap-concat-htpy _
+                      ( ( distributive-left-whisker-comp-concat
+                          ( map-cocone-standard-sequential-colimit
+                            { A =
+                              right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+                                ( right-map-span-diagram 𝒮 s)}
+                            ( succ-ℕ (succ-ℕ n)))
+                          ( _)
+                          ( _)) ∙h
+                        ( ap-concat-htpy _
+                          ( ( left-whisker-comp² _
+                              ( left-whisker-inv-htpy _ _)) ∙h
+                            ( left-whisker-inv-htpy _ _))))) ∙h
+                    ( inv-htpy-assoc-htpy _ _ _))) ∙h
+                ( inv-htpy-assoc-htpy _ _ _))))) ∙h
+        ( ap-concat-htpy' _
+          ( inv-htpy-assoc-htpy _ _ _))
+
+    α :
+      (s : spanning-type-span-diagram 𝒮) →
+      (n : ℕ) →
+      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+      coherence-square-maps
+        ( Ψ s n p)
+        ( tr
+          ( ev-pair
+            ( left-family-descent-data-pushout R)
+            ( left-map-span-diagram 𝒮 s))
+          ( coherence-cocone-standard-sequential-colimit n p))
+        ( Φ' s n (concat-s 𝒮 a₀ s n p))
+        ( tr
+          ( λ p →
+            left-family-descent-data-pushout R
+              ( left-map-span-diagram 𝒮 s ,
+                map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+          ( glue-pushout _ _ (s , refl , p)))
+    α s n p q =
+      map-eq-transpose-equiv
+        ( equiv-family-descent-data-pushout R
+          ( s ,
+            map-cocone-standard-sequential-colimit
+              ( succ-ℕ n)
+              ( concat-inv-s 𝒮 a₀ s
+                ( succ-ℕ n)
+                ( concat-s 𝒮 a₀ s n p))))
+        ( inv (coh-dep-cocone-a s n p q))
+
+    β :
+      (s : spanning-type-span-diagram 𝒮) →
+      (n : ℕ) →
+      (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+      coherence-square-maps
+        ( Φ' s n p)
+        ( tr
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
+        ( Ψ s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+        ( tr
+          ( λ p →
+            right-family-descent-data-pushout R
+              ( right-map-span-diagram 𝒮 s ,
+                map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+          ( glue-pushout _ _ (s , refl , p)))
+    β s n p q =
+      inv
+        ( ( ap
+            ( tr _ _)
+            ( is-section-map-inv-equiv
+              ( equiv-family-descent-data-pushout R
+                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+              ( _)) ∙
+          ( is-section-map-inv-equiv
+            ( equiv-tr _ _)
+            ( _))))
+
+    -- Note for refactoring: after contracting away the last component and the
+    -- vertical map, the definition of prism2 will fail to typecheck, since
+    -- currently the coherence computes to <X> ∙ refl, which needs to be taken
+    -- into account; contracting away this data would simplify the later
+    -- homotopy algebra.
+    stages-cocones' :
+      (n : ℕ) →
+      Σ ( (b : codomain-span-diagram 𝒮) →
+          dependent-cocone-span-diagram
+            ( cocone-pushout-span-diagram
+              ( span-diagram-path-to-b 𝒮 a₀ b n))
+            ( λ p →
+              right-family-descent-data-pushout R
+                ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
+        ( λ dep-cocone-b →
+          Σ ( (a : domain-span-diagram 𝒮) →
+              dependent-cocone-span-diagram
+                ( cocone-pushout-span-diagram
+                  ( span-diagram-path-to-a 𝒮 a₀ a n))
+                ( λ p →
+                  left-family-descent-data-pushout R
+                    ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
+            ( λ dep-cocone-a →
+              (s : spanning-type-span-diagram 𝒮) →
+              (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+              vertical-map-dependent-cocone _ _ _ _
+                ( dep-cocone-a (left-map-span-diagram 𝒮 s))
+                ( s , refl , p) ＝
+              Φ' s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)))
+    stages-cocones' zero-ℕ =
+      dep-cocone-b ,
+      dep-cocone-a ,
+      λ s p → refl
+      where
+      dep-cocone-b :
+        (b : codomain-span-diagram 𝒮) →
+        dependent-cocone-span-diagram
+          ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b 0))
+          ( λ p →
+            right-family-descent-data-pushout R
+              ( b , map-cocone-standard-sequential-colimit 1 p))
+      pr1 (dep-cocone-b b) (map-raise ())
+      pr1 (pr2 (dep-cocone-b ._)) (s , refl , map-raise refl) =
+        tr
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( CB s 0 (map-raise refl))
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit 0 (map-raise refl))
+            ( r₀))
+      pr2 (pr2 (dep-cocone-b ._)) (s , refl , map-raise ())
+      dep-cocone-a :
+        (a : domain-span-diagram 𝒮) →
+        dependent-cocone-span-diagram
+          ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a 0))
+          ( λ p →
+            left-family-descent-data-pushout R
+              ( a , map-cocone-standard-sequential-colimit 1 p))
+      pr1 (dep-cocone-a .a₀) (map-raise refl) =
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a₀)
+          ( coherence-cocone-standard-sequential-colimit 0 (map-raise refl))
+          ( r₀)
+      pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
+        Φ' s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
+      pr2 (pr2 (dep-cocone-a .a₀)) (s , refl , map-raise refl) =
+        ( α s 0 (map-raise refl) r₀) ∙
+        ( ap
+          ( Φ' s 0 _)
+          ( inv
+            ( compute-inr-dependent-cogap _ _
+              ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+              ( s , refl , map-raise refl))))
+    stages-cocones' (succ-ℕ n) =
+      dep-cocone-b ,
+      dep-cocone-a ,
+      λ s p → refl
+      where
+      dep-cocone-b :
+        (b : codomain-span-diagram 𝒮) →
+        dependent-cocone-span-diagram
+          ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b (succ-ℕ n)))
+          ( λ p →
+            right-family-descent-data-pushout R
+              ( b , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+      pr1 (dep-cocone-b b) p =
+        tr
+          ( ev-pair (right-family-descent-data-pushout R) b)
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
+          ( dependent-cogap _ _ (pr1 (stages-cocones' n) b) p)
+      pr1 (pr2 (dep-cocone-b b)) (s , refl , p) =
+        tr
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( CB s (succ-ℕ n) p)
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
+            ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))
+      pr2 (pr2 (dep-cocone-b b)) (s , refl , p) =
+        ( β s n p _) ∙
+        ( ap
+          ( Ψ s (succ-ℕ n) _)
+          ( inv
+            ( ( compute-inr-dependent-cogap _ _
+                ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
+                ( s , refl , p)) ∙
+              ( pr2 (pr2 (stages-cocones' n)) s p))))
+      dep-cocone-a :
+        (a : domain-span-diagram 𝒮) →
+        dependent-cocone-span-diagram
+          ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a (succ-ℕ n)))
+          ( λ p →
+            left-family-descent-data-pushout R
+              ( a , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+      pr1 (dep-cocone-a a) p =
+        tr
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
+          ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a) p)
+      pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
+        Φ' s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
+      pr2 (pr2 (dep-cocone-a a)) (s , refl , p) =
+        ( α s (succ-ℕ n) p _) ∙
+        ( ap
+          ( Φ' s (succ-ℕ n) _)
+          ( inv
+            ( compute-inr-dependent-cogap _ _
+              ( dep-cocone-b (right-map-span-diagram 𝒮 s))
+              ( s , refl , p))))
+
+
+    tB :
+      (b : codomain-span-diagram 𝒮) (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
+      right-family-descent-data-pushout R
+        ( b , map-cocone-standard-sequential-colimit n p)
+    tB b zero-ℕ (map-raise ())
+    tB b (succ-ℕ n) = dependent-cogap _ _ (pr1 (stages-cocones' n) b)
+
+    tA :
+      (a : domain-span-diagram 𝒮) (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
+      left-family-descent-data-pushout R
+        ( a , map-cocone-standard-sequential-colimit n p)
+    tA .a₀ zero-ℕ (map-raise refl) = r₀
+    tA a (succ-ℕ n) = dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a)
+
+    ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
+    pr1 ind-singleton-zigzag-id-pushout' (a , p) =
+      dependent-cogap-standard-sequential-colimit
+        ( tA a , KA)
+        ( p)
+      where
+      KA :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
+        dependent-identification
+          ( ev-pair (left-family-descent-data-pushout R) a)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tA a n p)
+          ( tA a (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p))
+      KA zero-ℕ (map-raise refl) =
+        inv
+          ( compute-inl-dependent-cogap _ _
+            ( pr1 (pr2 (stages-cocones' 0)) a)
+            ( map-raise refl))
+      KA (succ-ℕ n) p =
+        inv
+          ( compute-inl-dependent-cogap _ _
+            ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) a)
+            ( p))
+    pr1 (pr2 ind-singleton-zigzag-id-pushout') (b , p) =
+      dependent-cogap-standard-sequential-colimit
+        ( tB b , KB)
+        ( p)
+      where
+      KB :
+        (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
+        dependent-identification
+          ( ev-pair (right-family-descent-data-pushout R) b)
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tB b n p)
+          ( tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
+      KB zero-ℕ (map-raise ())
+      KB (succ-ℕ n) p =
+        inv
+          ( compute-inl-dependent-cogap _ _
+            ( pr1 (stages-cocones' (succ-ℕ n)) b)
+            ( p))
+    pr2 (pr2 ind-singleton-zigzag-id-pushout') (s , p) =
+      dependent-cogap-standard-sequential-colimit
+        ( tS , KS)
+        ( p)
+      where
+      [i] :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        tr
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( CB s n p)
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit n p)
+            ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
+        tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
+      [i] zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
+      [i] (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
+      tS :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        map-family-descent-data-pushout R
+          ( s , map-cocone-standard-sequential-colimit n p)
+          ( pr1
+            ( ind-singleton-zigzag-id-pushout')
+            ( left-map-span-diagram 𝒮 s ,
+              map-cocone-standard-sequential-colimit n p)) ＝
+        pr1
+          ( pr2 ind-singleton-zigzag-id-pushout')
+          ( right-map-span-diagram 𝒮 s ,
+            concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
+      tS n p =
+        ( ap
+          ( map-family-descent-data-pushout R
+            ( s , map-cocone-standard-sequential-colimit n p))
+          ( compute-incl-dependent-cogap-standard-sequential-colimit _ n p)) ∙
+        ( map-equiv
+          ( inv-equiv-ap-emb
+            ( emb-equiv
+              ( equiv-tr
+                ( ev-pair
+                  ( right-family-descent-data-pushout R)
+                  ( right-map-span-diagram 𝒮 s))
+                ( CB s n p))))
+          ( [i] n p ∙
+            inv
+              ( ( apd
+                  ( dependent-cogap-standard-sequential-colimit (tB (right-map-span-diagram 𝒮 s) , _))
+                  ( CB s n p)) ∙
+                ( compute-incl-dependent-cogap-standard-sequential-colimit _ (succ-ℕ n) _))))
+      KS :
+        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+        tr
+          ( λ p →
+            map-family-descent-data-pushout R
+              ( s , p)
+              ( pr1
+                ( ind-singleton-zigzag-id-pushout')
+                ( left-map-span-diagram 𝒮 s , p)) ＝
+            pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p))
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( tS n p) ＝
+        tS (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n p)
+      KS n p =
+        map-compute-dependent-identification-eq-value _ _
+          ( coherence-cocone-standard-sequential-colimit n p)
+          ( _)
+          ( _)
+          ( {!!})
+
+    tS-in-diagram :
+      (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+      ( tr (ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+        ( CB s n p)
+        ( map-family-descent-data-pushout R _ (tA (left-map-span-diagram 𝒮 s) n p))) ＝
+      ( tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
+    tS-in-diagram s zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
+    tS-in-diagram s (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
+
+    module vertices
+      (s : spanning-type-span-diagram 𝒮)
+      where
+      PAn : (n : ℕ) → UU (l1 ⊔ l2 ⊔ l3)
+      PAn = Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s)
+      QAn : {n : ℕ} → PAn n → UU l5
+      QAn {n} p = left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p)
+      PBn : (n : ℕ) → UU (l1 ⊔ l2 ⊔ l3)
+      PBn = Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) ∘ succ-ℕ
+      QBn : {n : ℕ} → PBn n → UU l5
+      QBn {n} p = right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
+      fn : {n : ℕ} → PAn n → PBn n
+      fn = concat-s 𝒮 a₀ s _
+      gn : {n : ℕ} → PAn n → PAn (succ-ℕ n)
+      gn = inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) _
+      hn : {n : ℕ} → PBn n → PBn (succ-ℕ n)
+      hn = inl-Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) _
+      mn : {n : ℕ} → PBn n → PAn (succ-ℕ n)
+      mn {n} = concat-inv-s 𝒮 a₀ s (succ-ℕ n)
+      sAn : {n : ℕ} (p : PAn n) → QAn p
+      sAn = tA (left-map-span-diagram 𝒮 s) _
+      sBn : {n : ℕ} (p : PBn n) → QBn p
+      sBn = tB (right-map-span-diagram 𝒮 s) _
+      f'n : {n : ℕ} {p : PAn n} → QAn p → QBn (fn p)
+      f'n {n} {p} = Ψ s n p
+      g'n : {n : ℕ} {p : PAn n} → QAn p → QAn (gn p)
+      g'n {n} {p} =
+        tr
+          ( ev-pair
+            ( left-family-descent-data-pushout R)
+            ( left-map-span-diagram 𝒮 s))
+          ( coherence-cocone-standard-sequential-colimit n p)
+      h'n : {n : ℕ} {p : PBn n} → QBn p → QBn (hn p)
+      h'n {n} {p} =
+        tr
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
+      m'n : {n : ℕ} {p : PBn n} → QBn p → QAn (mn p)
+      m'n = Φ' s _ _
+
+    module sides
+      (s : spanning-type-span-diagram 𝒮) (n : ℕ)
+      where
+      open vertices s
+      left :
+        {p : PAn n} → f'n (sAn p) ＝ sBn (fn p)
+      left = tS-in-diagram s n _
+      right :
+        {p : PAn (succ-ℕ n)} →
+        f'n (sAn p) ＝ sBn (fn p)
+      right = tS-in-diagram s (succ-ℕ n) _
+      bottom :
+        {p : PAn n} → hn (fn p) ＝ fn (gn p)
+      bottom =
+        naturality-map-hom-diagram-zigzag-sequential-diagram
+          ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
+          ( n)
+          ( _)
+      bottom1 :
+        {p : PAn n} → gn p ＝ mn (fn p)
+      bottom1 = glue-pushout _ _ _
+      bottom2 :
+        {p : PBn n} → hn p ＝ fn (mn p)
+      bottom2 = glue-pushout _ _ _
+      far :
+        {p : PAn n} → g'n (sAn p) ＝ sAn (gn p)
+      far = far' n _
+        where
+        far' : (n : ℕ) (p : PAn n) → g'n (sAn p) ＝ sAn (gn p)
+        far' zero-ℕ (map-raise refl) = inv (compute-inl-dependent-cogap _ _ _ _)
+        far' (succ-ℕ n) p = inv (compute-inl-dependent-cogap _ _ _ _)
+      near :
+        {p : PBn n} → h'n (sBn p) ＝ sBn (hn p)
+      near = inv (compute-inl-dependent-cogap _ _ _ _)
+      mid :
+        {p : PBn n} → m'n (sBn p) ＝ sAn (mn p)
+      mid = mid' _ _
+        where
+        mid' : (n : ℕ) (p : PBn n) → m'n (sBn p) ＝ sAn (mn p)
+        mid' zero-ℕ p = inv (compute-inr-dependent-cogap _ _ _ _)
+        mid' (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
+      top1 :
+        {p : PAn n} (q : QAn p) →
+        tr QAn bottom1 (g'n q) ＝ m'n (f'n q)
+      top1 = α s n _
+      top2 :
+        {p : PBn n} (q : QBn p) →
+        tr QBn bottom2 (h'n q) ＝ f'n (m'n q)
+      top2 = β s n _
+      top :
+        {p : PAn n} (q : QAn p) →
+        tr QBn bottom (h'n (f'n q)) ＝ f'n (g'n q)
+      top =
+        pasting-triangles-over gn fn fn hn g'n f'n f'n h'n mn m'n
+          ( inv-htpy (λ p → bottom1 {p}))
+          ( λ p → bottom2 {p})
+          ( inv-htpy-over QAn (λ _ → bottom1) g'n (m'n ∘ f'n) top1)
+          ( top2)
+
+    module CUBE
+      (s : spanning-type-span-diagram 𝒮) (n : ℕ)
+      where
+      open vertices s
+      open sides s n
+
+      CUBE : UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
+      CUBE =
+        section-square-over gn fn fn hn g'n f'n f'n h'n sAn sBn sAn sBn
+          ( λ p → far {p})
+          ( λ p → left {p})
+          ( λ p → right {p})
+          ( λ p → near {p})
+          ( λ p → bottom {p})
+          ( top)
+
+      PRISM1 : UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
+      PRISM1 =
+        section-triangle-over fn gn mn f'n g'n m'n sAn sBn sAn
+          ( λ p → left {p})
+          ( λ p → far {p})
+          ( λ p → mid {p})
+          ( λ p → bottom1 {p})
+          ( top1)
+
+      PRISM2 : UU (l1 ⊔ l2 ⊔ l3 ⊔ l5)
+      PRISM2 =
+        section-triangle-over mn hn fn m'n h'n f'n sBn sAn sBn
+          ( λ p → mid {p})
+          ( λ p → near {p})
+          ( λ p → right {p})
+          ( λ p → bottom2 {p})
+          ( top2)
+
+    module cube
+      (s : spanning-type-span-diagram 𝒮)
+      where abstract
+      open vertices s
+      open sides s
+      open CUBE s
+
+      -- THE COMMENTED CODE WORKS, DON'T DELETE IT!
+      -- It just takes too long to typecheck it in its current state
+      prism1 : (n : ℕ) → PRISM1 n
+      prism1 = {!!}
+      -- prism1 zero-ℕ (map-raise refl) =
+      --   lem _ _ _ _ _
+      --     ( ( ap
+      --         ( _∙ (top1 0 (sAn _) ∙ ap m'n (left 0)))
+      --         ( ( inv (ap-inv (tr QAn (bottom1 0)) (far 0))) ∙
+      --           ( ap² (tr QAn (bottom1 0)) (inv-inv _)))) ∙
+      --       ( [i]) ∙
+      --       ( ap
+      --         ( apd sAn (bottom1 0) ∙_)
+      --         ( inv (inv-inv _))))
+      --   where
+      --     open import foundation.action-on-higher-identifications-functions
+      --     [i] =
+      --       inv
+      --         ( compute-glue-dependent-cogap _ _
+      --           ( pr1 (pr2 (stages-cocones' 0)) (left-map-span-diagram 𝒮 s))
+      --           ( s , refl , (map-raise refl)))
+      -- prism1 (succ-ℕ n) p =
+      --   lem _ _ _ _ _
+      --     ( ( ap
+      --         ( _∙ (top1 (succ-ℕ n) (sAn _) ∙ ap m'n (left (succ-ℕ n))))
+      --         ( ( inv (ap-inv (tr QAn (bottom1 (succ-ℕ n))) (far (succ-ℕ n)))) ∙
+      --           ( ap² (tr QAn (bottom1 (succ-ℕ n))) (inv-inv _)))) ∙
+      --       ( [i]) ∙
+      --       ( ap
+      --         ( apd sAn (bottom1 (succ-ℕ n)) ∙_)
+      --         ( inv (inv-inv _))))
+      --   where
+      --     open import foundation.action-on-higher-identifications-functions
+      --     [i] =
+      --       inv
+      --         ( compute-glue-dependent-cogap _ _
+      --           ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) (left-map-span-diagram 𝒮 s))
+      --           ( s , refl , p))
+
+      prism2 : (n : ℕ) → PRISM2 n
+      prism2 = {!!}
+      -- prism2 0 p =
+      --   lem _ _ _ _ _
+      --     ( ( ap
+      --         ( _∙ (top2 0 (sBn p) ∙ ap f'n (mid 0)))
+      --         ( ( inv (ap-inv (tr QBn (bottom2 0)) (near 0))) ∙
+      --           ( ap² (tr (QBn {1}) (bottom2 0)) (inv-inv _)))) ∙
+      --       ( inv [ii]) ∙
+      --       ( ap
+      --         ( apd sBn (bottom2 0) ∙_)
+      --         ( inv (inv-inv _))))
+      --   where
+      --     open import foundation.action-on-higher-identifications-functions
+      --     [i] =
+      --       -- inv
+      --         ( compute-glue-dependent-cogap _ _
+      --           ( pr1 (stages-cocones' 1) (right-map-span-diagram 𝒮 s))
+      --           ( s , refl , p))
+      --     [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 0 (sBn p) ∙ ap f'n (inv q))) right-unit
+      -- prism2 (succ-ℕ n) p =
+      --   lem _ _ _ _ _
+      --     ( ( ap
+      --         ( _∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (mid (succ-ℕ n))))
+      --         ( ( inv (ap-inv (tr QBn (bottom2 (succ-ℕ n))) (near (succ-ℕ n)))) ∙
+      --           ( ap² (tr QBn (bottom2 (succ-ℕ n))) (inv-inv _)))) ∙
+      --       ( inv [ii]) ∙
+      --       ( ap
+      --         ( apd sBn (bottom2 (succ-ℕ n)) ∙_)
+      --         ( inv (inv-inv _))))
+      --   where
+      --     open import foundation.action-on-higher-identifications-functions
+      --     [i] =
+      --       -- inv
+      --         ( compute-glue-dependent-cogap _ _
+      --           ( pr1 (stages-cocones' (succ-ℕ (succ-ℕ n))) (right-map-span-diagram 𝒮 s))
+      --           ( s , refl , p))
+      --     [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (inv q))) right-unit
+
+      cube : (n : ℕ) → CUBE n
+      cube n =
+        pasting-sections-triangles-over gn fn fn hn g'n f'n f'n h'n mn m'n sAn sBn sAn sBn
+          ( λ p → far n {p})
+          ( λ p → left n {p})
+          ( λ p → right n {p})
+          ( λ p → near n {p})
+          ( λ p → mid n {p})
+          ( inv-htpy (λ p → bottom1 n {p}))
+          ( λ p → bottom2 n {p})
+          ( {!inv-htpy-over!})
+          ( top2 n)
+          ( {!!})
+          ( {!!})
+
+    KS-in-diagram :
+      (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+      sides.top s n (vertices.sAn s p) ∙
+       ap (vertices.f'n s) (sides.far s n)
+       ∙ sides.right s n
+       ＝
+       ap (tr (vertices.QBn s) (sides.bottom s n) ∘ vertices.h'n s)
+       (sides.left s n)
+       ∙ ap (tr (vertices.QBn s) (sides.bottom s n)) (sides.near s n)
+       ∙ apd (vertices.sBn s) (sides.bottom s n)
+    KS-in-diagram = cube.cube
+
+  is-identity-system-zigzag-id-pushout :
+    is-identity-system-descent-data-pushout
+      ( descent-data-zigzag-id-pushout 𝒮 a₀)
+      ( refl-id-pushout 𝒮 a₀)
+  is-identity-system-zigzag-id-pushout =
+    is-identity-system-descent-data-pushout-ind-singleton up-c
+      ( descent-data-zigzag-id-pushout 𝒮 a₀)
+      ( refl-id-pushout 𝒮 a₀)
+      ( ind-singleton-zigzag-id-pushout')
 ```
-^ remove this code fence
--- module _
---   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
---   where
-
---   type-stage-zigzag-construction-id-pushout : ℕ → UU (lsuc (l1 ⊔ l2 ⊔ l3))
---   type-stage-zigzag-construction-id-pushout n =
---     Σ ( codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
---       ( λ Path-to-b →
---         Σ ( domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3))
---           ( λ Path-to-a →
---             ( Σ ( (s : spanning-type-span-diagram 𝒮) →
---                   Path-to-b (right-map-span-diagram 𝒮 s) →
---                   Path-to-a (left-map-span-diagram 𝒮 s))
---                 ( λ _ →
---                   rec-ℕ
---                     ( raise-unit (lsuc (l1 ⊔ l2 ⊔ l3)))
---                     ( λ _ _ →
---                       ( codomain-span-diagram 𝒮 →
---                         span-diagram
---                           ( l1 ⊔ l2 ⊔ l3)
---                           ( l1 ⊔ l2 ⊔ l3)
---                           ( l1 ⊔ l2 ⊔ l3)) ×
---                       ( domain-span-diagram 𝒮 →
---                         span-diagram
---                           ( l1 ⊔ l2 ⊔ l3)
---                           ( l1 ⊔ l2 ⊔ l3)
---                           ( l1 ⊔ l2 ⊔ l3)))
---                     ( n)))))
-
--- module _
---   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
---   (a₀ : domain-span-diagram 𝒮)
---   where
-
---   stage-zigzag-construction-id-pushout :
---     (n : ℕ) → type-stage-zigzag-construction-id-pushout 𝒮 n
---   stage-zigzag-construction-id-pushout zero-ℕ =
---     Path-to-b ,
---     Path-to-a ,
---     ( λ s → raise-ex-falso _) ,
---     raise-star
---     where
---     Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
---     Path-to-b _ = raise-empty _
---     Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
---     Path-to-a a = raise (l2 ⊔ l3) (a₀ ＝ a)
---   stage-zigzag-construction-id-pushout (succ-ℕ n) =
---     Path-to-b ,
---     Path-to-a ,
---     ( λ s p → inr-pushout _ _ (s , refl , p)) ,
---     span-diagram-B ,
---     span-diagram-A
---     where
---     span-diagram-B :
---       codomain-span-diagram 𝒮 →
---       span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
---     span-diagram-B b =
---       make-span-diagram
---         ( pr2 ∘ pr2)
---         ( tot
---           ( λ s →
---             tot
---               ( λ r (p : pr1 (stage-zigzag-construction-id-pushout n) b) →
---                 pr1
---                   ( pr2 (pr2 (stage-zigzag-construction-id-pushout n)))
---                   ( s)
---                   ( tr (pr1 (stage-zigzag-construction-id-pushout n)) r p))))
---     Path-to-b : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
---     Path-to-b b = standard-pushout (span-diagram-B b)
---     span-diagram-A :
---       domain-span-diagram 𝒮 →
---       span-diagram (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3) (l1 ⊔ l2 ⊔ l3)
---     span-diagram-A a =
---       make-span-diagram
---         ( pr2 ∘ pr2)
---         ( tot
---           ( λ s →
---             tot
---               ( λ r (p : pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a) →
---                 inr-standard-pushout
---                   ( span-diagram-B (right-map-span-diagram 𝒮 s))
---                   ( ( s) ,
---                     ( refl) ,
---                     ( tr
---                       ( pr1 (pr2 (stage-zigzag-construction-id-pushout n)))
---                       ( r)
---                       ( p))))))
---     Path-to-a : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
---     Path-to-a a = standard-pushout (span-diagram-A a)
-
---   span-diagram-path-to-b :
---     codomain-span-diagram 𝒮 → ℕ →
---     span-diagram
---       ( l1 ⊔ l2 ⊔ l3)
---       ( l1 ⊔ l2 ⊔ l3)
---       ( l1 ⊔ l2 ⊔ l3)
---   span-diagram-path-to-b b n =
---     pr1 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) b
-
---   span-diagram-path-to-a :
---     domain-span-diagram 𝒮 → ℕ →
---     span-diagram
---       ( l1 ⊔ l2 ⊔ l3)
---       ( l1 ⊔ l2 ⊔ l3)
---       ( l1 ⊔ l2 ⊔ l3)
---   span-diagram-path-to-a a n =
---     pr2 (pr2 (pr2 (pr2 (stage-zigzag-construction-id-pushout (succ-ℕ n))))) a
-
---   Path-to-b : codomain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
---   Path-to-b b n = pr1 (stage-zigzag-construction-id-pushout n) b
-
---   Path-to-a : domain-span-diagram 𝒮 → ℕ → UU (l1 ⊔ l2 ⊔ l3)
---   Path-to-a a n = pr1 (pr2 (stage-zigzag-construction-id-pushout n)) a
-
---   inl-Path-to-b :
---     (b : codomain-span-diagram 𝒮) (n : ℕ) → Path-to-b b n → Path-to-b b (succ-ℕ n)
---   inl-Path-to-b b n =
---     inl-standard-pushout
---       ( span-diagram-path-to-b b n)
-
---   inl-Path-to-a :
---     (a : domain-span-diagram 𝒮) (n : ℕ) → Path-to-a a n → Path-to-a a (succ-ℕ n)
---   inl-Path-to-a a n =
---     inl-standard-pushout
---       ( span-diagram-path-to-a a n)
-
---   concat-inv-s :
---     (s : spanning-type-span-diagram 𝒮) →
---     (n : ℕ) →
---     Path-to-b (right-map-span-diagram 𝒮 s) n →
---     Path-to-a (left-map-span-diagram 𝒮 s) n
---   concat-inv-s s n = pr1 (pr2 (pr2 (stage-zigzag-construction-id-pushout n))) s
-
---   concat-s :
---     (s : spanning-type-span-diagram 𝒮) →
---     (n : ℕ) →
---     Path-to-a (left-map-span-diagram 𝒮 s) n →
---     Path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n)
---   concat-s s n p =
---     inr-standard-pushout
---       ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) n)
---       ( s , refl , p)
-
---   right-sequential-diagram-zigzag-id-pushout :
---     codomain-span-diagram 𝒮 →
---     sequential-diagram (l1 ⊔ l2 ⊔ l3)
---   pr1 (right-sequential-diagram-zigzag-id-pushout b) = Path-to-b b
---   pr2 (right-sequential-diagram-zigzag-id-pushout b) = inl-Path-to-b b
-
---   left-sequential-diagram-zigzag-id-pushout :
---     domain-span-diagram 𝒮 →
---     sequential-diagram (l1 ⊔ l2 ⊔ l3)
---   pr1 (left-sequential-diagram-zigzag-id-pushout a) = Path-to-a a
---   pr2 (left-sequential-diagram-zigzag-id-pushout a) = inl-Path-to-a a
-
---   zigzag-sequential-diagram-zigzag-id-pushout :
---     (s : spanning-type-span-diagram 𝒮) →
---     zigzag-sequential-diagram
---       ( left-sequential-diagram-zigzag-id-pushout
---         ( left-map-span-diagram 𝒮 s))
---       ( shift-once-sequential-diagram
---         ( right-sequential-diagram-zigzag-id-pushout
---           ( right-map-span-diagram 𝒮 s)))
---   pr1 (zigzag-sequential-diagram-zigzag-id-pushout s) =
---     concat-s s
---   pr1 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s)) n =
---     concat-inv-s s (succ-ℕ n)
---   pr1 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
---     glue-standard-pushout
---       ( span-diagram-path-to-a (left-map-span-diagram 𝒮 s) n)
---       ( s , refl , p)
---   pr2 (pr2 (pr2 (zigzag-sequential-diagram-zigzag-id-pushout s))) n p =
---     glue-standard-pushout
---       ( span-diagram-path-to-b (right-map-span-diagram 𝒮 s) (succ-ℕ n))
---       ( s , refl , p)
-
---   left-id-pushout : domain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
---   left-id-pushout a =
---     standard-sequential-colimit (left-sequential-diagram-zigzag-id-pushout a)
-
---   refl-id-pushout : left-id-pushout a₀
---   refl-id-pushout =
---     map-cocone-standard-sequential-colimit 0 (map-raise refl)
-
---   right-id-pushout : codomain-span-diagram 𝒮 → UU (l1 ⊔ l2 ⊔ l3)
---   right-id-pushout b =
---     standard-sequential-colimit (right-sequential-diagram-zigzag-id-pushout b)
-
---   equiv-id-pushout :
---     (s : spanning-type-span-diagram 𝒮) →
---     left-id-pushout (left-map-span-diagram 𝒮 s) ≃
---     right-id-pushout (right-map-span-diagram 𝒮 s)
---   equiv-id-pushout s =
---     equiv-colimit-zigzag-sequential-diagram _ _
---       ( up-standard-sequential-colimit)
---       ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
---       ( zigzag-sequential-diagram-zigzag-id-pushout s)
-
---   -- concat-inv-s-inf :
---   --   (s : spanning-type-span-diagram 𝒮) →
---   --   right-id-pushout (right-map-span-diagram 𝒮 s) →
---   --   left-id-pushout (left-map-span-diagram 𝒮 s)
---   -- concat-inv-s-inf s =
---   --   map-inv-equiv (equiv-id-pushout s)
-
---   concat-s-inf :
---     (s : spanning-type-span-diagram 𝒮) →
---     left-id-pushout (left-map-span-diagram 𝒮 s) →
---     right-id-pushout (right-map-span-diagram 𝒮 s)
---   concat-s-inf s =
---     map-equiv (equiv-id-pushout s)
-
---   descent-data-zigzag-id-pushout : descent-data-pushout 𝒮 (l1 ⊔ l2 ⊔ l3)
---   pr1 descent-data-zigzag-id-pushout = left-id-pushout
---   pr1 (pr2 descent-data-zigzag-id-pushout) = right-id-pushout
---   pr2 (pr2 descent-data-zigzag-id-pushout) = equiv-id-pushout
--- ```
-
--- ## Theorem
-
--- ### TODO
-
--- ```agda
--- nat-lemma :
---   {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
---   {P : A → UU l3} {Q : B → UU l4}
---   (f : A → B) (h : (a : A) → P a → Q (f a))
---   {x y : A} {p : x ＝ y}
---   {q : f x ＝ f y} (α : ap f p ＝ q) →
---   coherence-square-maps
---     ( tr P p)
---     ( h x)
---     ( h y)
---     ( tr Q q)
--- nat-lemma f h {p = p} refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
-
--- apd-lemma :
---   {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
---   (f : (a : A) → B a) (g : (a : A) → B a → C a) {x y : A} (p : x ＝ y) →
---   apd (λ a → g a (f a)) p ＝ inv (preserves-tr g p (f x)) ∙ ap (g y) (apd f p)
--- apd-lemma f g refl = refl
-
--- lem :
---   {l : Level} {X : UU l} {x y z u v : X} →
---   (p : y ＝ x) (q : y ＝ z) (r : z ＝ u) (s : x ＝ v) (t : u ＝ v) →
---   (inv p ∙ (q ∙ r) ＝ s ∙ inv t) → q ∙ r ∙ t ＝ p ∙ s
--- lem refl q r refl refl x = right-unit ∙ x
-
--- module _
---   {l1 l2 l3 l4 : Level} {𝒮 : span-diagram l1 l2 l3}
---   {X : UU l4} {c : cocone-span-diagram 𝒮 X}
---   (up-c : universal-property-pushout _ _ c)
---   (a₀ : domain-span-diagram 𝒮)
---   where
-
---   module _
---     {l5 : Level}
---     (R : descent-data-pushout
---       ( span-diagram-flattening-descent-data-pushout
---         ( descent-data-zigzag-id-pushout 𝒮 a₀))
---       ( l5))
---     (r₀ : left-family-descent-data-pushout R (a₀ , refl-id-pushout 𝒮 a₀))
---     where
-
---     private
---       CB :
---         (s : spanning-type-span-diagram 𝒮) →
---         (n : ℕ) →
---         (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---         concat-s-inf 𝒮 a₀ s
---           ( map-cocone-standard-sequential-colimit n p) ＝
---         map-cocone-standard-sequential-colimit (succ-ℕ n)
---           ( concat-s 𝒮 a₀ s n p)
---       CB s =
---         htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---           ( up-standard-sequential-colimit)
---           ( shift-once-cocone-sequential-diagram
---             ( cocone-standard-sequential-colimit
---               ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀ (right-map-span-diagram 𝒮 s))))
---           ( hom-diagram-zigzag-sequential-diagram
---             ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-
---       Ψ :
---         (s : spanning-type-span-diagram 𝒮) →
---         (n : ℕ) →
---         (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---         left-family-descent-data-pushout R
---           ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p) →
---         right-family-descent-data-pushout R
---           ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
---       Ψ s n p =
---         ( tr
---           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---           ( CB s n p)) ∘
---         ( map-family-descent-data-pushout R
---           ( s , map-cocone-standard-sequential-colimit n p))
-
---       Φ :
---         (s : spanning-type-span-diagram 𝒮) →
---         (n : ℕ) →
---         (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
---         right-family-descent-data-pushout R
---           ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
---         right-family-descent-data-pushout R
---           ( right-map-span-diagram 𝒮 s ,
---             concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
---       Φ s n p =
---         ( tr
---           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---           ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))) ∘
---         ( tr
---           ( λ p →
---             right-family-descent-data-pushout R
---               ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
---           ( glue-pushout _ _ (s , refl , p))) ∘
---         ( tr
---           ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
-
---       Φ' :
---         (s : spanning-type-span-diagram 𝒮) →
---         (n : ℕ) →
---         (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
---         right-family-descent-data-pushout R
---           ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
---         left-family-descent-data-pushout R
---           ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
---       Φ' s n p =
---         ( inv-map-family-descent-data-pushout R
---           ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))) ∘
---         ( Φ s n p)
-
---     coh-dep-cocone-a :
---       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
---       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---       coherence-square-maps
---         ( ( tr
---             ( λ p →
---               left-family-descent-data-pushout R
---                 ( left-map-span-diagram 𝒮 s ,
---                   map-cocone-standard-sequential-colimit (succ-ℕ n) p))
---             ( glue-pushout _ _ (s , refl , p))) ∘
---           ( tr
---             ( ev-pair
---               ( left-family-descent-data-pushout R)
---               ( left-map-span-diagram 𝒮 s))
---             ( coherence-cocone-standard-sequential-colimit n p)))
---         ( map-family-descent-data-pushout R
---           ( s , map-cocone-standard-sequential-colimit n p))
---         ( map-family-descent-data-pushout R
---           ( s ,
---             map-cocone-standard-sequential-colimit (succ-ℕ n)
---               ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
---         ( ( tr
---             ( ev-pair
---               ( right-family-descent-data-pushout R)
---               ( right-map-span-diagram 𝒮 s))
---             ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
---           ( tr
---             ( λ p →
---               right-family-descent-data-pushout R
---                 ( right-map-span-diagram 𝒮 s ,
---                   map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
---             ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
---           ( tr
---             ( ev-pair
---               ( right-family-descent-data-pushout R)
---               ( right-map-span-diagram 𝒮 s))
---             ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))) ∘
---           ( tr
---             ( ev-pair
---               ( right-family-descent-data-pushout R)
---               ( right-map-span-diagram 𝒮 s))
---             ( CB s n p)))
---     coh-dep-cocone-a s n p =
---       ( ( inv-htpy
---           ( ( tr-concat _ _) ∙h
---             ( ( tr _ _) ·l
---               ( ( tr-concat _ _) ∙h
---                 ( horizontal-concat-htpy
---                   ( λ _ → substitution-law-tr _ _ _)
---                   ( tr-concat _ _)))))) ·r
---         ( map-family-descent-data-pushout R
---           ( s , map-cocone-standard-sequential-colimit n p))) ∙h
---       ( nat-lemma
---           ( concat-s-inf 𝒮 a₀ s)
---           ( ev-pair (map-family-descent-data-pushout R) s)
---           ( [i] p)) ∙h
---       ( ( map-family-descent-data-pushout R
---           ( s ,
---             map-cocone-standard-sequential-colimit
---               ( succ-ℕ n)
---               ( concat-inv-s 𝒮 a₀ s
---                 ( succ-ℕ n)
---                 ( concat-s 𝒮 a₀ s n p)))) ·l
---         ( ( tr-concat _ _) ∙h
---           ( λ q → substitution-law-tr _ _ _)))
---       where
---       [i] :
---         ( ( concat-s-inf 𝒮 a₀ s) ·l
---           ( ( coherence-cocone-standard-sequential-colimit n) ∙h
---             ( ( map-cocone-standard-sequential-colimit
---               { A =
---                 left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
---                   ( left-map-span-diagram 𝒮 s)}
---               ( succ-ℕ n)) ·l
---             ( λ p → glue-pushout _ _ (s , refl , p))))) ~
---         ( ( CB s n) ∙h
---           ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
---               ( concat-s 𝒮 a₀ s n)) ∙h
---           ( ( map-cocone-standard-sequential-colimit
---               { A =
---                 right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
---                   ( right-map-span-diagram 𝒮 s)}
---               ( succ-ℕ (succ-ℕ n))) ·l
---             ( λ p → glue-pushout _ _ ( s , refl , concat-s 𝒮 a₀ s n p))) ∙h
---           ( ( inv-htpy (CB s (succ-ℕ n))) ·r
---             ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
---       [i] =
---         ( distributive-left-whisker-comp-concat _ _ _) ∙h
---         ( right-transpose-htpy-concat _ _ _
---           ( ( left-whisker-concat-coherence-square-homotopies _ _ _ _ _
---               ( λ p →
---                 inv
---                   ( nat-coherence-square-maps _ _ _ _
---                     ( CB s (succ-ℕ n))
---                     ( glue-pushout _ _ (s , refl , p))))) ∙h
---             ( map-inv-equiv
---               ( equiv-right-transpose-htpy-concat _ _ _)
---               ( ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                   ( up-standard-sequential-colimit)
---                   ( shift-once-cocone-sequential-diagram
---                     ( cocone-standard-sequential-colimit
---                       ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
---                         ( right-map-span-diagram 𝒮 s))))
---                   ( hom-diagram-zigzag-sequential-diagram
---                     ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
---                   ( n)) ∙h
---                 ( ap-concat-htpy
---                   ( CB s n)
---                   ( ( ap-concat-htpy _
---                       ( ( distributive-left-whisker-comp-concat
---                           ( map-cocone-standard-sequential-colimit
---                             { A =
---                               right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
---                                 ( right-map-span-diagram 𝒮 s)}
---                             ( succ-ℕ (succ-ℕ n)))
---                           ( _)
---                           ( _)) ∙h
---                         ( ap-concat-htpy _
---                           ( ( left-whisker-comp² _
---                               ( left-whisker-inv-htpy _ _)) ∙h
---                             ( left-whisker-inv-htpy _ _))))) ∙h
---                     ( inv-htpy-assoc-htpy _ _ _))) ∙h
---                 ( inv-htpy-assoc-htpy _ _ _))))) ∙h
---         ( ap-concat-htpy' _
---           ( inv-htpy-assoc-htpy _ _ _))
-
---     α :
---       (s : spanning-type-span-diagram 𝒮) →
---       (n : ℕ) →
---       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---       coherence-square-maps
---         ( Ψ s n p)
---         ( tr
---           ( ev-pair
---             ( left-family-descent-data-pushout R)
---             ( left-map-span-diagram 𝒮 s))
---           ( coherence-cocone-standard-sequential-colimit n p))
---         ( Φ' s n (concat-s 𝒮 a₀ s n p))
---         ( tr
---           ( λ p →
---             left-family-descent-data-pushout R
---               ( left-map-span-diagram 𝒮 s ,
---                 map-cocone-standard-sequential-colimit (succ-ℕ n) p))
---           ( glue-pushout _ _ (s , refl , p)))
---     α s n p q =
---       map-eq-transpose-equiv
---         ( equiv-family-descent-data-pushout R
---           ( s ,
---             map-cocone-standard-sequential-colimit
---               ( succ-ℕ n)
---               ( concat-inv-s 𝒮 a₀ s
---                 ( succ-ℕ n)
---                 ( concat-s 𝒮 a₀ s n p))))
---         ( inv (coh-dep-cocone-a s n p q))
-
---     β :
---       (s : spanning-type-span-diagram 𝒮) →
---       (n : ℕ) →
---       (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
---       coherence-square-maps
---         ( Φ' s n p)
---         ( tr
---           ( ev-pair
---             ( right-family-descent-data-pushout R)
---             ( right-map-span-diagram 𝒮 s))
---           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
---         ( Ψ s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
---         ( tr
---           ( λ p →
---             right-family-descent-data-pushout R
---               ( right-map-span-diagram 𝒮 s ,
---                 map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
---           ( glue-pushout _ _ (s , refl , p)))
---     β s n p q =
---       inv
---         ( ( ap
---             ( tr _ _)
---             ( is-section-map-inv-equiv
---               ( equiv-family-descent-data-pushout R
---                 ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
---               ( _)) ∙
---           ( is-section-map-inv-equiv
---             ( equiv-tr _ _)
---             ( _))))
-
---     -- Note for refactoring: after contracting away the last component and the
---     -- vertical map, the definition of prism2 will fail to typecheck, since
---     -- currently the coherence computes to <X> ∙ refl, which needs to be taken
---     -- into account; contracting away this data would simplify the later
---     -- homotopy algebra.
---     stages-cocones' :
---       (n : ℕ) →
---       Σ ( (b : codomain-span-diagram 𝒮) →
---           dependent-cocone-span-diagram
---             ( cocone-pushout-span-diagram
---               ( span-diagram-path-to-b 𝒮 a₀ b n))
---             ( λ p →
---               right-family-descent-data-pushout R
---                 ( b , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
---         ( λ dep-cocone-b →
---           Σ ( (a : domain-span-diagram 𝒮) →
---               dependent-cocone-span-diagram
---                 ( cocone-pushout-span-diagram
---                   ( span-diagram-path-to-a 𝒮 a₀ a n))
---                 ( λ p →
---                   left-family-descent-data-pushout R
---                     ( a , map-cocone-standard-sequential-colimit (succ-ℕ n) p)))
---             ( λ dep-cocone-a →
---               (s : spanning-type-span-diagram 𝒮) →
---               (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
---               vertical-map-dependent-cocone _ _ _ _
---                 ( dep-cocone-a (left-map-span-diagram 𝒮 s))
---                 ( s , refl , p) ＝
---               Φ' s n p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)))
---     stages-cocones' zero-ℕ =
---       dep-cocone-b ,
---       dep-cocone-a ,
---       λ s p → refl
---       where
---       dep-cocone-b :
---         (b : codomain-span-diagram 𝒮) →
---         dependent-cocone-span-diagram
---           ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b 0))
---           ( λ p →
---             right-family-descent-data-pushout R
---               ( b , map-cocone-standard-sequential-colimit 1 p))
---       pr1 (dep-cocone-b b) (map-raise ())
---       pr1 (pr2 (dep-cocone-b ._)) (s , refl , map-raise refl) =
---         tr
---           ( ev-pair
---             ( right-family-descent-data-pushout R)
---             ( right-map-span-diagram 𝒮 s))
---           ( CB s 0 (map-raise refl))
---           ( map-family-descent-data-pushout R
---             ( s , map-cocone-standard-sequential-colimit 0 (map-raise refl))
---             ( r₀))
---       pr2 (pr2 (dep-cocone-b ._)) (s , refl , map-raise ())
---       dep-cocone-a :
---         (a : domain-span-diagram 𝒮) →
---         dependent-cocone-span-diagram
---           ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a 0))
---           ( λ p →
---             left-family-descent-data-pushout R
---               ( a , map-cocone-standard-sequential-colimit 1 p))
---       pr1 (dep-cocone-a .a₀) (map-raise refl) =
---         tr
---           ( ev-pair (left-family-descent-data-pushout R) a₀)
---           ( coherence-cocone-standard-sequential-colimit 0 (map-raise refl))
---           ( r₀)
---       pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
---         Φ' s 0 p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
---       pr2 (pr2 (dep-cocone-a .a₀)) (s , refl , map-raise refl) =
---         ( α s 0 (map-raise refl) r₀) ∙
---         ( ap
---           ( Φ' s 0 _)
---           ( inv
---             ( compute-inr-dependent-cogap _ _
---               ( dep-cocone-b (right-map-span-diagram 𝒮 s))
---               ( s , refl , map-raise refl))))
---     stages-cocones' (succ-ℕ n) =
---       dep-cocone-b ,
---       dep-cocone-a ,
---       λ s p → refl
---       where
---       dep-cocone-b :
---         (b : codomain-span-diagram 𝒮) →
---         dependent-cocone-span-diagram
---           ( cocone-pushout-span-diagram (span-diagram-path-to-b 𝒮 a₀ b (succ-ℕ n)))
---           ( λ p →
---             right-family-descent-data-pushout R
---               ( b , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
---       pr1 (dep-cocone-b b) p =
---         tr
---           ( ev-pair (right-family-descent-data-pushout R) b)
---           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
---           ( dependent-cogap _ _ (pr1 (stages-cocones' n) b) p)
---       pr1 (pr2 (dep-cocone-b b)) (s , refl , p) =
---         tr
---           ( ev-pair
---             ( right-family-descent-data-pushout R)
---             ( right-map-span-diagram 𝒮 s))
---           ( CB s (succ-ℕ n) p)
---           ( map-family-descent-data-pushout R
---             ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
---             ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s)) p))
---       pr2 (pr2 (dep-cocone-b b)) (s , refl , p) =
---         ( β s n p _) ∙
---         ( ap
---           ( Ψ s (succ-ℕ n) _)
---           ( inv
---             ( ( compute-inr-dependent-cogap _ _
---                 ( pr1 (pr2 (stages-cocones' n)) (left-map-span-diagram 𝒮 s))
---                 ( s , refl , p)) ∙
---               ( pr2 (pr2 (stages-cocones' n)) s p))))
---       dep-cocone-a :
---         (a : domain-span-diagram 𝒮) →
---         dependent-cocone-span-diagram
---           ( cocone-pushout-span-diagram (span-diagram-path-to-a 𝒮 a₀ a (succ-ℕ n)))
---           ( λ p →
---             left-family-descent-data-pushout R
---               ( a , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
---       pr1 (dep-cocone-a a) p =
---         tr
---           ( ev-pair (left-family-descent-data-pushout R) a)
---           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
---           ( dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a) p)
---       pr1 (pr2 (dep-cocone-a a)) (s , refl , p) =
---         Φ' s (succ-ℕ n) p (dependent-cogap _ _ (dep-cocone-b (right-map-span-diagram 𝒮 s)) p)
---       pr2 (pr2 (dep-cocone-a a)) (s , refl , p) =
---         ( α s (succ-ℕ n) p _) ∙
---         ( ap
---           ( Φ' s (succ-ℕ n) _)
---           ( inv
---             ( compute-inr-dependent-cogap _ _
---               ( dep-cocone-b (right-map-span-diagram 𝒮 s))
---               ( s , refl , p))))
-
-
---     tB :
---       (b : codomain-span-diagram 𝒮) (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
---       right-family-descent-data-pushout R
---         ( b , map-cocone-standard-sequential-colimit n p)
---     tB b zero-ℕ (map-raise ())
---     tB b (succ-ℕ n) = dependent-cogap _ _ (pr1 (stages-cocones' n) b)
-
---     tA :
---       (a : domain-span-diagram 𝒮) (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
---       left-family-descent-data-pushout R
---         ( a , map-cocone-standard-sequential-colimit n p)
---     tA .a₀ zero-ℕ (map-raise refl) = r₀
---     tA a (succ-ℕ n) = dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a)
-
---     ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
---     pr1 ind-singleton-zigzag-id-pushout' (a , p) =
---       dependent-cogap-standard-sequential-colimit
---         ( tA a , KA)
---         ( p)
---       where
---       KA :
---         (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
---         dependent-identification
---           ( ev-pair (left-family-descent-data-pushout R) a)
---           ( coherence-cocone-standard-sequential-colimit n p)
---           ( tA a n p)
---           ( tA a (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p))
---       KA zero-ℕ (map-raise refl) =
---         inv
---           ( compute-inl-dependent-cogap _ _
---             ( pr1 (pr2 (stages-cocones' 0)) a)
---             ( map-raise refl))
---       KA (succ-ℕ n) p =
---         inv
---           ( compute-inl-dependent-cogap _ _
---             ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) a)
---             ( p))
---     pr1 (pr2 ind-singleton-zigzag-id-pushout') (b , p) =
---       dependent-cogap-standard-sequential-colimit
---         ( tB b , KB)
---         ( p)
---       where
---       KB :
---         (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
---         dependent-identification
---           ( ev-pair (right-family-descent-data-pushout R) b)
---           ( coherence-cocone-standard-sequential-colimit n p)
---           ( tB b n p)
---           ( tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
---       KB zero-ℕ (map-raise ())
---       KB (succ-ℕ n) p =
---         inv
---           ( compute-inl-dependent-cogap _ _
---             ( pr1 (stages-cocones' (succ-ℕ n)) b)
---             ( p))
---     pr2 (pr2 ind-singleton-zigzag-id-pushout') (s , p) =
---       dependent-cogap-standard-sequential-colimit
---         ( tS , KS)
---         ( p)
---       where
---       [i] :
---         (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---         tr
---           ( ev-pair
---             ( right-family-descent-data-pushout R)
---             ( right-map-span-diagram 𝒮 s))
---           ( CB s n p)
---           ( map-family-descent-data-pushout R
---             ( s , map-cocone-standard-sequential-colimit n p)
---             ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
---         tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
---       [i] zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
---       [i] (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
---       tS :
---         (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---         map-family-descent-data-pushout R
---           ( s , map-cocone-standard-sequential-colimit n p)
---           ( pr1
---             ( ind-singleton-zigzag-id-pushout')
---             ( left-map-span-diagram 𝒮 s ,
---               map-cocone-standard-sequential-colimit n p)) ＝
---         pr1
---           ( pr2 ind-singleton-zigzag-id-pushout')
---           ( right-map-span-diagram 𝒮 s ,
---             concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
---       tS n p =
---         ( ap
---           ( map-family-descent-data-pushout R
---             ( s , map-cocone-standard-sequential-colimit n p))
---           ( compute-incl-dependent-cogap-standard-sequential-colimit _ n p)) ∙
---         ( map-equiv
---           ( inv-equiv-ap-emb
---             ( emb-equiv
---               ( equiv-tr
---                 ( ev-pair
---                   ( right-family-descent-data-pushout R)
---                   ( right-map-span-diagram 𝒮 s))
---                 ( CB s n p))))
---           ( [i] n p ∙
---             inv
---               ( ( apd
---                   ( dependent-cogap-standard-sequential-colimit (tB (right-map-span-diagram 𝒮 s) , _))
---                   ( CB s n p)) ∙
---                 ( compute-incl-dependent-cogap-standard-sequential-colimit _ (succ-ℕ n) _))))
---       KS :
---         (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---         tr
---           ( λ p →
---             map-family-descent-data-pushout R
---               ( s , p)
---               ( pr1
---                 ( ind-singleton-zigzag-id-pushout')
---                 ( left-map-span-diagram 𝒮 s , p)) ＝
---             pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p))
---           ( coherence-cocone-standard-sequential-colimit n p)
---           ( tS n p) ＝
---         tS (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n p)
---       KS n p =
---         map-compute-dependent-identification-eq-value _ _
---           ( coherence-cocone-standard-sequential-colimit n p)
---           ( _)
---           ( _)
---           ( {!!})
-
---     tS-in-diagram :
---       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
---       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---       ( tr (ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
---         ( CB s n p)
---         ( map-family-descent-data-pushout R _ (tA (left-map-span-diagram 𝒮 s) n p))) ＝
---       ( tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
---     tS-in-diagram s zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
---     tS-in-diagram s (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
-
---     module vertices
---       (s : spanning-type-span-diagram 𝒮)
---       where
---       PAn : (n : ℕ) → UU (l1 ⊔ l2 ⊔ l3)
---       PAn = Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s)
---       QAn : {n : ℕ} → PAn n → UU l5
---       QAn {n} p = left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p)
---       PBn : (n : ℕ) → UU (l1 ⊔ l2 ⊔ l3)
---       PBn = Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) ∘ succ-ℕ
---       QBn : {n : ℕ} → PBn n → UU l5
---       QBn {n} p = right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
---       fn : {n : ℕ} → PAn n → PBn n
---       fn = concat-s 𝒮 a₀ s _
---       gn : {n : ℕ} → PAn n → PAn (succ-ℕ n)
---       gn = inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) _
---       hn : {n : ℕ} → PBn n → PBn (succ-ℕ n)
---       hn = inl-Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) _
---       mn : {n : ℕ} → PBn n → PAn (succ-ℕ n)
---       mn {n} = concat-inv-s 𝒮 a₀ s (succ-ℕ n)
---       sAn : {n : ℕ} (p : PAn n) → QAn p
---       sAn = tA (left-map-span-diagram 𝒮 s) _
---       sBn : {n : ℕ} (p : PBn n) → QBn p
---       sBn = tB (right-map-span-diagram 𝒮 s) _
---       f'n : {n : ℕ} {p : PAn n} → QAn p → QBn (fn p)
---       f'n {n} {p} = Ψ s n p
---       g'n : {n : ℕ} {p : PAn n} → QAn p → QAn (gn p)
---       g'n {n} {p} =
---         tr
---           ( ev-pair
---             ( left-family-descent-data-pushout R)
---             ( left-map-span-diagram 𝒮 s))
---           ( coherence-cocone-standard-sequential-colimit n p)
---       h'n : {n : ℕ} {p : PBn n} → QBn p → QBn (hn p)
---       h'n {n} {p} =
---         tr
---           ( ev-pair
---             ( right-family-descent-data-pushout R)
---             ( right-map-span-diagram 𝒮 s))
---           ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p)
---       m'n : {n : ℕ} {p : PBn n} → QBn p → QAn (mn p)
---       m'n = Φ' s _ _
-
---     module sides
---       (s : spanning-type-span-diagram 𝒮) (n : ℕ)
---       where
---       open vertices s
---       left :
---         {p : PAn n} → f'n (sAn p) ＝ sBn (fn p)
---       left = tS-in-diagram s n _
---       right :
---         {p : PAn (succ-ℕ n)} →
---         f'n (sAn p) ＝ sBn (fn p)
---       right = tS-in-diagram s (succ-ℕ n) _
---       bottom :
---         {p : PAn n} → hn (fn p) ＝ fn (gn p)
---       bottom =
---         naturality-map-hom-diagram-zigzag-sequential-diagram
---           ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
---           ( n)
---           ( _)
---       bottom1 :
---         {p : PAn n} → gn p ＝ mn (fn p)
---       bottom1 = glue-pushout _ _ _
---       bottom2 :
---         {p : PBn n} → hn p ＝ fn (mn p)
---       bottom2 = glue-pushout _ _ _
---       far :
---         {p : PAn n} → g'n (sAn p) ＝ sAn (gn p)
---       far = far' n _
---         where
---         far' : (n : ℕ) (p : PAn n) → g'n (sAn p) ＝ sAn (gn p)
---         far' zero-ℕ (map-raise refl) = inv (compute-inl-dependent-cogap _ _ _ _)
---         far' (succ-ℕ n) p = inv (compute-inl-dependent-cogap _ _ _ _)
---       near :
---         {p : PBn n} → h'n (sBn p) ＝ sBn (hn p)
---       near = inv (compute-inl-dependent-cogap _ _ _ _)
---       mid :
---         {p : PBn n} → m'n (sBn p) ＝ sAn (mn p)
---       mid = mid' _ _
---         where
---         mid' : (n : ℕ) (p : PBn n) → m'n (sBn p) ＝ sAn (mn p)
---         mid' zero-ℕ p = inv (compute-inr-dependent-cogap _ _ _ _)
---         mid' (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
---       top1 :
---         {p : PAn n} (q : QAn p) →
---         tr QAn bottom1 (g'n q) ＝ m'n (f'n q)
---       top1 = α s n _
---       top2 :
---         {p : PBn n} (q : QBn p) →
---         tr QBn bottom2 (h'n q) ＝ f'n (m'n q)
---       top2 = β s n _
---       top :
---         {p : PAn n} (q : QAn p) →
---         tr QBn bottom (h'n (f'n q)) ＝ f'n (g'n q)
---       top = {!!}
-
---     module CUBE
---       (s : spanning-type-span-diagram 𝒮) (n : ℕ)
---       where
---       open vertices s
---       open sides s n
-
---       CUBE : (p : PAn n) → UU _
---       CUBE p =
---         ( top (sAn p) ∙ ap f'n far ∙ right) ＝
---         ( ap (tr QBn bottom ∘ h'n) left ∙
---           ap (tr QBn bottom) near ∙
---           apd sBn bottom)
-
---       PRISM1 : (p : PAn n) → UU _
---       PRISM1 p =
---         ( top1 (sAn p) ∙ ap m'n left ∙ mid) ＝
---         ( ap (tr QAn bottom1) far ∙ apd sAn bottom1)
-
---       PRISM2 : (p : PBn n) → UU _
---       PRISM2 p =
---         top2 (sBn p) ∙ ap f'n mid ∙ right ＝
---         ap (tr QBn bottom2) near ∙ apd sBn bottom2
-
---     module cube
---       (s : spanning-type-span-diagram 𝒮)
---       where abstract
---       open vertices s
---       open sides s
---       open CUBE s
-
---       -- THE COMMENTED CODE WORKS, DON'T DELETE IT!
---       -- It just takes too long to typecheck it in its current state
---       prism1 : (n : ℕ) → (p : PAn n) → PRISM1 n p
---       prism1 = {!!}
---       -- prism1 zero-ℕ (map-raise refl) =
---       --   lem _ _ _ _ _
---       --     ( ( ap
---       --         ( _∙ (top1 0 (sAn _) ∙ ap m'n (left 0)))
---       --         ( ( inv (ap-inv (tr QAn (bottom1 0)) (far 0))) ∙
---       --           ( ap² (tr QAn (bottom1 0)) (inv-inv _)))) ∙
---       --       ( [i]) ∙
---       --       ( ap
---       --         ( apd sAn (bottom1 0) ∙_)
---       --         ( inv (inv-inv _))))
---       --   where
---       --     open import foundation.action-on-higher-identifications-functions
---       --     [i] =
---       --       inv
---       --         ( compute-glue-dependent-cogap _ _
---       --           ( pr1 (pr2 (stages-cocones' 0)) (left-map-span-diagram 𝒮 s))
---       --           ( s , refl , (map-raise refl)))
---       -- prism1 (succ-ℕ n) p =
---       --   lem _ _ _ _ _
---       --     ( ( ap
---       --         ( _∙ (top1 (succ-ℕ n) (sAn _) ∙ ap m'n (left (succ-ℕ n))))
---       --         ( ( inv (ap-inv (tr QAn (bottom1 (succ-ℕ n))) (far (succ-ℕ n)))) ∙
---       --           ( ap² (tr QAn (bottom1 (succ-ℕ n))) (inv-inv _)))) ∙
---       --       ( [i]) ∙
---       --       ( ap
---       --         ( apd sAn (bottom1 (succ-ℕ n)) ∙_)
---       --         ( inv (inv-inv _))))
---       --   where
---       --     open import foundation.action-on-higher-identifications-functions
---       --     [i] =
---       --       inv
---       --         ( compute-glue-dependent-cogap _ _
---       --           ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) (left-map-span-diagram 𝒮 s))
---       --           ( s , refl , p))
-
---       prism2 : (n : ℕ) → (p : PBn n) → PRISM2 n p
---       prism2 = {!!}
---       -- prism2 0 p =
---       --   lem _ _ _ _ _
---       --     ( ( ap
---       --         ( _∙ (top2 0 (sBn p) ∙ ap f'n (mid 0)))
---       --         ( ( inv (ap-inv (tr QBn (bottom2 0)) (near 0))) ∙
---       --           ( ap² (tr (QBn {1}) (bottom2 0)) (inv-inv _)))) ∙
---       --       ( inv [ii]) ∙
---       --       ( ap
---       --         ( apd sBn (bottom2 0) ∙_)
---       --         ( inv (inv-inv _))))
---       --   where
---       --     open import foundation.action-on-higher-identifications-functions
---       --     [i] =
---       --       -- inv
---       --         ( compute-glue-dependent-cogap _ _
---       --           ( pr1 (stages-cocones' 1) (right-map-span-diagram 𝒮 s))
---       --           ( s , refl , p))
---       --     [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 0 (sBn p) ∙ ap f'n (inv q))) right-unit
---       -- prism2 (succ-ℕ n) p =
---       --   lem _ _ _ _ _
---       --     ( ( ap
---       --         ( _∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (mid (succ-ℕ n))))
---       --         ( ( inv (ap-inv (tr QBn (bottom2 (succ-ℕ n))) (near (succ-ℕ n)))) ∙
---       --           ( ap² (tr QBn (bottom2 (succ-ℕ n))) (inv-inv _)))) ∙
---       --       ( inv [ii]) ∙
---       --       ( ap
---       --         ( apd sBn (bottom2 (succ-ℕ n)) ∙_)
---       --         ( inv (inv-inv _))))
---       --   where
---       --     open import foundation.action-on-higher-identifications-functions
---       --     [i] =
---       --       -- inv
---       --         ( compute-glue-dependent-cogap _ _
---       --           ( pr1 (stages-cocones' (succ-ℕ (succ-ℕ n))) (right-map-span-diagram 𝒮 s))
---       --           ( s , refl , p))
---       --     [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (inv q))) right-unit
-
---       cube :
---         (n : ℕ) → (p : PAn n) → CUBE n p
---       cube = {!!}
-
---     KS-in-diagram :
---       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
---       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
---       sides.top s n (vertices.sAn s p) ∙
---        ap (vertices.f'n s) (sides.far s n)
---        ∙ sides.right s n
---        ＝
---        ap (tr (vertices.QBn s) (sides.bottom s n) ∘ vertices.h'n s)
---        (sides.left s n)
---        ∙ ap (tr (vertices.QBn s) (sides.bottom s n)) (sides.near s n)
---        ∙ apd (vertices.sBn s) (sides.bottom s n)
---     KS-in-diagram = cube.cube
-
---   is-identity-system-zigzag-id-pushout :
---     is-identity-system-descent-data-pushout
---       ( descent-data-zigzag-id-pushout 𝒮 a₀)
---       ( refl-id-pushout 𝒮 a₀)
---   is-identity-system-zigzag-id-pushout =
---     is-identity-system-descent-data-pushout-ind-singleton up-c
---       ( descent-data-zigzag-id-pushout 𝒮 a₀)
---       ( refl-id-pushout 𝒮 a₀)
---       ( ind-singleton-zigzag-id-pushout')
--- ```

From b12c102a3b81d09f63d4fa6958b2ba240ce6ff30 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Thu, 16 Jan 2025 23:38:10 +0100
Subject: [PATCH 14/33] Paste prisms into cubes

---
 ...nstruction-identity-type-pushouts.lagda.md | 116 ++++++++++++++++--
 1 file changed, 104 insertions(+), 12 deletions(-)

diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index 0c756569a9..daa3941fdb 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -224,6 +224,58 @@ module _
     H' (sA a) ∙ G a ＝
     ap (tr B' (H a)) (F a) ∙ apd sB (H a)
 
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  where
+
+  inv-section-htpy-over :
+    section-htpy-over H H' sA sB F G →
+    section-htpy-over
+      ( inv-htpy H)
+      ( inv-htpy-over B' H f' g' H')
+      ( sA)
+      ( sB)
+      ( G)
+      ( F)
+  inv-section-htpy-over α =
+    ind-htpy f
+      ( λ g H →
+        {g' : {a : A} → A' a → B' (g a)} →
+        (H' : htpy-over B' H f' g') →
+        (G : section-map-over g g' sA sB) →
+        section-htpy-over H H' sA sB F G →
+        section-htpy-over
+          ( inv-htpy H)
+          ( inv-htpy-over B' H f' g' H')
+          sA sB G F)
+      ( λ H' G α a →
+        ind-htpy f'
+          ( λ g'a H'a →
+            (Ga : g'a (sA a) ＝ sB (f a)) →
+            (αa : H'a (sA a) ∙ Ga ＝ ap (tr B' refl) (F a) ∙ apd sB refl) →
+            map-eq-transpose-equiv-inv (equiv-tr B' refl) (inv (H'a (sA a))) ∙ F a ＝
+            ap (tr B' refl) Ga ∙ apd sB refl)
+          ( λ Ga αa →
+            ap (_∙ F a) (compute-refl-eq-transpose-equiv-inv (equiv-tr B' refl)) ∙
+            inv (right-unit ∙ ap-id _ ∙ (αa ∙ right-unit ∙ ap-id _)))
+          ( H')
+          ( G a)
+          ( α a))
+      ( H)
+      ( H')
+      ( G)
+      ( α)
+
 module _
   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
@@ -487,6 +539,27 @@ module _
     H' (sA a) ∙ G a ＝
     ap (tr X' (H a) ∘ m') (F a) ∙ ap (tr X' (H a)) (M (f a)) ∙ apd sX (H a)
 
+
+  open import foundation.functoriality-dependent-function-types
+  equiv-get-section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    section-triangle-over' H H' ≃
+    section-htpy-over H H' sA sX
+      ( comp-section-map-over m f m' f' sA sB sX M F)
+      ( G)
+  equiv-get-section-triangle-over' H H' =
+    equiv-Π-equiv-family
+      ( λ a →
+        equiv-concat'
+          ( H' (sA a) ∙ G a)
+          ( ap
+            ( _∙ apd sX (H a))
+            ( ( ap
+                ( _∙ ap (tr X' (H a)) (M (f a)))
+                ( ap-comp (tr X' (H a)) m' (F a))) ∙
+              ( inv (ap-concat (tr X' (H a)) (ap m' (F a)) (M (f a)))))))
+
   unget-section-triangle-over' :
     (H : coherence-triangle-maps' g m f) →
     (H' : htpy-over X' H (m' ∘ f') g') →
@@ -494,15 +567,18 @@ module _
     section-htpy-over H H' sA sX
       ( comp-section-map-over m f m' f' sA sB sX M F)
       ( G)
-  unget-section-triangle-over' H H' α =
-    α ∙h
-    ( λ a →
-      ap
-        ( _∙ apd sX (H a))
-        ( ( ap
-            ( _∙ ap (tr X' (H a)) (M (f a)))
-            ( ap-comp (tr X' (H a)) m' (F a))) ∙
-          ( inv (ap-concat (tr X' (H a)) (ap m' (F a)) (M (f a))))))
+  unget-section-triangle-over' H H' =
+    map-equiv (equiv-get-section-triangle-over' H H')
+
+  get-section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    section-htpy-over H H' sA sX
+      ( comp-section-map-over m f m' f' sA sB sX M F)
+      ( G) →
+    section-triangle-over' H H'
+  get-section-triangle-over' H H' =
+    map-inv-equiv (equiv-get-section-triangle-over' H H')
 
   -- actually ≐ section-triangle-over 🤔
   -- section-triangle-over-inv :
@@ -1637,10 +1713,26 @@ module _
           ( λ p → mid n {p})
           ( inv-htpy (λ p → bottom1 n {p}))
           ( λ p → bottom2 n {p})
-          ( {!inv-htpy-over!})
+          ( inv-htpy-over QAn (λ p → bottom1 n {p}) g'n (m'n ∘ f'n) (top1 n))
           ( top2 n)
-          ( {!!})
-          ( {!!})
+          ( get-section-triangle-over' fn gn mn f'n g'n m'n sAn sBn sAn
+            ( λ p → left n {p})
+            ( λ p → far n {p})
+            ( λ p → mid n {p})
+            ( inv-htpy (λ p → bottom1 n {p}))
+            ( inv-htpy-over QAn (λ p → bottom1 n {p}) g'n (m'n ∘ f'n) (top1 n))
+            ( inv-section-htpy-over
+              ( λ p → bottom1 n {p})
+              ( top1 n)
+              sAn sAn _ _
+              (unget-section-triangle-over fn gn mn f'n g'n m'n sAn sBn sAn
+                ( λ p → left n {p})
+                ( λ p → far n {p})
+                ( λ p → mid n {p})
+                ( λ p → bottom1 n {p})
+                ( top1 n)
+                ( prism1 n))))
+          ( prism2 n)
 
     KS-in-diagram :
       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →

From a8d452a5e3bcb7cafae95388b9dbe9031f5db60a Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Fri, 17 Jan 2025 14:56:15 +0100
Subject: [PATCH 15/33] Move stuff-over

---
 .../stuff-over.lagda.md                       | 664 ++++++++++++++++++
 ...nstruction-identity-type-pushouts.lagda.md | 637 +----------------
 2 files changed, 666 insertions(+), 635 deletions(-)
 create mode 100644 src/synthetic-homotopy-theory/stuff-over.lagda.md

diff --git a/src/synthetic-homotopy-theory/stuff-over.lagda.md b/src/synthetic-homotopy-theory/stuff-over.lagda.md
new file mode 100644
index 0000000000..3e74048c0c
--- /dev/null
+++ b/src/synthetic-homotopy-theory/stuff-over.lagda.md
@@ -0,0 +1,664 @@
+# Stuff over other stuff
+
+```agda
+module synthetic-homotopy-theory.stuff-over where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import foundation.action-on-identifications-dependent-functions
+open import foundation.action-on-identifications-functions
+open import foundation.commuting-squares-of-maps
+open import foundation.commuting-triangles-of-maps
+open import foundation.dependent-identifications
+open import foundation.equivalences
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-function-types
+open import foundation.homotopies
+open import foundation.homotopy-induction
+open import foundation.identity-types
+open import foundation.transport-along-identifications
+open import foundation.transposition-identifications-along-equivalences
+open import foundation.universe-levels
+open import foundation.whiskering-homotopies-composition
+open import foundation.whiskering-homotopies-concatenation
+```
+
+</details>
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2}
+  {A' : A → UU l3} (B' : B → UU l4)
+  {f g : A → B}
+  (H : f ~ g)
+  (f' : {a : A} → A' a → B' (f a))
+  (g' : {a : A} → A' a → B' (g a))
+  where
+
+  htpy-over : UU (l1 ⊔ l3 ⊔ l4)
+  htpy-over = {a : A} (a' : A' a) → dependent-identification B' (H a) (f' a') (g' a')
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2}
+  {A' : A → UU l3} (B' : B → UU l4)
+  {f g : A → B}
+  (H : f ~ g)
+  (f' : {a : A} → A' a → B' (f a))
+  (g' : {a : A} → A' a → B' (g a))
+  where
+
+  inv-htpy-over : htpy-over B' H f' g' → htpy-over B' (inv-htpy H) g' f'
+  inv-htpy-over H' a' =
+    map-eq-transpose-equiv-inv (equiv-tr B' (H _)) (inv (H' a'))
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (s : X → A) (s' : {x : X} → X' x → A' (s x))
+  where
+
+  right-whisk-htpy-over : htpy-over B' (H ·r s) (f' ∘ s') (g' ∘ s')
+  right-whisk-htpy-over a' = H' (s' a')
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  {s : B → X} (s' : {b : B} → B' b → X' (s b))
+  where
+
+  LWMOTIF : {a : A} (a' : A' a) (g : A → B) (H : f ~ g) → UU (l5 ⊔ l6)
+  LWMOTIF {a} a' g H =
+    {g'a' : B' (g a)} →
+    (H' : tr B' (H a) (f' a') ＝ g'a') →
+    tr X' (ap s (H a)) (s' (f' a')) ＝ s' (g'a')
+
+  left-whisk-htpy-over : htpy-over X' (s ·l H) (s' ∘ f') (s' ∘ g')
+  left-whisk-htpy-over {a} a' =
+    ind-htpy f
+      ( LWMOTIF a')
+      ( ap s')
+      ( H)
+      ( H' a')
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f : A → B}
+  {f' g' : {a : A} → A' a → B' (f a)}
+  (H' : {a : A} → f' {a} ~ g')
+  {s : B → X} (s' : {b : B} → B' b → X' (s b))
+  where
+
+  compute-left-whisk-htpy-over :
+    {a : A} (a' : A' a) →
+    left-whisk-htpy-over {B' = B'} {X' = X'} {f = f} refl-htpy H' s' a' ＝ ap s' (H' a')
+  compute-left-whisk-htpy-over a' =
+    htpy-eq
+      ( htpy-eq-implicit
+        ( compute-ind-htpy f
+          ( LWMOTIF {B' = B'} {X' = X'} refl-htpy H' s' a')
+          ( ap s'))
+        ( g' a'))
+      ( H' a')
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  {f g h : A → B}
+  (H : f ~ g) (K : g ~ h)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  {h' : {a : A} → A' a → B' (h a)}
+  (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' h')
+  where
+
+  concat-htpy-over : htpy-over B' (H ∙h K) f' h'
+  concat-htpy-over {a} a' =
+    concat-dependent-identification B' (H a) (K a) (H' a') (K' a')
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  (f : A → B)
+  (f' : {a : A} → A' a → B' (f a))
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  where
+
+  section-map-over : UU (l1 ⊔ l4)
+  section-map-over = (a : A) → f' (sA a) ＝ sB (f a)
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {C' : C → UU l6}
+  (g : B → C) (f : A → B)
+  (g' : {b : B} → B' b → C' (g b))
+  (f' : {a : A} → A' a → B' (f a))
+  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sC : (c : C) → C' c)
+  where
+
+  comp-section-map-over :
+    section-map-over g g' sB sC → section-map-over f f' sA sB →
+    section-map-over (g ∘ f) (g' ∘ f') sA sC
+  comp-section-map-over G F =
+    g' ·l F ∙h G ·r f
+
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  where
+
+  section-htpy-over : UU (l1 ⊔ l4)
+  section-htpy-over =
+    (a : A) →
+    H' (sA a) ∙ G a ＝
+    ap (tr B' (H a)) (F a) ∙ apd sB (H a)
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  where
+
+  inv-section-htpy-over :
+    section-htpy-over H H' sA sB F G →
+    section-htpy-over
+      ( inv-htpy H)
+      ( inv-htpy-over B' H f' g' H')
+      ( sA)
+      ( sB)
+      ( G)
+      ( F)
+  inv-section-htpy-over α =
+    ind-htpy f
+      ( λ g H →
+        {g' : {a : A} → A' a → B' (g a)} →
+        (H' : htpy-over B' H f' g') →
+        (G : section-map-over g g' sA sB) →
+        section-htpy-over H H' sA sB F G →
+        section-htpy-over
+          ( inv-htpy H)
+          ( inv-htpy-over B' H f' g' H')
+          sA sB G F)
+      ( λ H' G α a →
+        ind-htpy f'
+          ( λ g'a H'a →
+            (Ga : g'a (sA a) ＝ sB (f a)) →
+            (αa : H'a (sA a) ∙ Ga ＝ ap (tr B' refl) (F a) ∙ apd sB refl) →
+            map-eq-transpose-equiv-inv (equiv-tr B' refl) (inv (H'a (sA a))) ∙ F a ＝
+            ap (tr B' refl) Ga ∙ apd sB refl)
+          ( λ Ga αa →
+            ap (_∙ F a) (compute-refl-eq-transpose-equiv-inv (equiv-tr B' refl)) ∙
+            inv (right-unit ∙ ap-id _ ∙ (αa ∙ right-unit ∙ ap-id _)))
+          ( H')
+          ( G a)
+          ( α a))
+      ( H)
+      ( H')
+      ( G)
+      ( α)
+
+module _
+  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+  {A' : A → UU l5} {B' : B → UU l6} {C' : C → UU l7} {D' : D → UU l8}
+  {f : A → B} {g : B → C} {h : C → D}
+  (f' : {a : A} → A' a → B' (f a))
+  (g' : {b : B} → B' b → C' (g b))
+  (h' : {c : C} → C' c → D' (h c))
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (sC : (c : C) → C' c)
+  (sD : (d : D) → D' d)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sB sC)
+  (H : section-map-over h h' sC sD)
+  where
+
+  assoc-comp-section-map-over :
+    section-htpy-over
+      ( refl-htpy {f = h ∘ g ∘ f})
+      ( refl-htpy {f = h' ∘ g' ∘ f'})
+      sA sD
+      ( comp-section-map-over (h ∘ g) f (h' ∘ g') f' sA sB sD
+        ( comp-section-map-over h g h' g' sB sC sD H G)
+        ( F))
+      ( comp-section-map-over h (g ∘ f) h' (g' ∘ f') sA sC sD H
+        ( comp-section-map-over g f g' f' sA sB sC G F))
+  assoc-comp-section-map-over =
+    inv-htpy
+      ( right-unit-htpy ∙h
+        left-unit-law-left-whisker-comp _ ∙h
+        inv-htpy-assoc-htpy ((h' ∘ g') ·l F) (h' ·l G ·r f) (H ·r (g ∘ f)) ∙h
+        right-whisker-concat-htpy
+          ( ( right-whisker-concat-htpy
+              ( inv-preserves-comp-left-whisker-comp h' g' F)
+              ( h' ·l G ·r f)) ∙h
+            ( inv-htpy
+              ( distributive-left-whisker-comp-concat h'
+                ( g' ·l F)
+                ( G ·r f))))
+          ( H ·r g ·r f))
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  (α : section-htpy-over H H' sA sB F G)
+  (s : X → A)
+  (s' : {x : X} → X' x → A' (s x))
+  (sX : (x : X) → X' x)
+  (S : section-map-over s s' sX sA)
+  where
+
+  right-whisk-section-htpy-over :
+    section-htpy-over (H ·r s)
+      ( right-whisk-htpy-over H H' s s')
+      sX sB
+      ( comp-section-map-over f s f' s' sX sA sB F S)
+      ( comp-section-map-over g s g' s' sX sA sB G S)
+  right-whisk-section-htpy-over =
+    ind-htpy f
+      ( λ g H →
+          {g' : {a : A} → A' a → B' (g a)}
+          (H' : htpy-over B' H f' g')
+          (G : section-map-over g g' sA sB)
+          (α : section-htpy-over H H' sA sB F G) →
+          section-htpy-over (H ·r s)
+            ( right-whisk-htpy-over H H' s s')
+            sX sB
+            ( comp-section-map-over f s f' s' sX sA sB F S)
+            ( comp-section-map-over g s g' s' sX sA sB G S))
+      ( λ H' G α x →
+        ind-htpy (f' {s x})
+          ( λ g'sx H'sx →
+            (Gsx : g'sx (sA (s x)) ＝ sB (f (s x)))
+            (αsx : H'sx (sA (s x)) ∙ Gsx ＝ ap (tr B' refl) (F (s x)) ∙ apd sB refl) →
+            H'sx (s' (sX x)) ∙ ((ap g'sx (S x)) ∙ Gsx) ＝
+            ap (tr B' refl) (ap f' (S x) ∙ (F (s x))) ∙ apd sB refl)
+          ( λ Gsx αsx → inv (right-unit ∙ (ap-id _ ∙ ap (ap f' (S x) ∙_) (inv (αsx ∙ (right-unit ∙ ap-id _))))))
+          ( H')
+          ( G (s x))
+          ( α (s x)))
+      ( H)
+      ( H')
+      ( G)
+      ( α)
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  {f g : A → B}
+  (H : f ~ g)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  (H' : htpy-over B' H f' g')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  (α : section-htpy-over H H' sA sB F G)
+  (s : B → X)
+  (s' : {b : B} → B' b → X' (s b))
+  (sX : (x : X) → X' x)
+  (S : section-map-over s s' sB sX)
+  where
+
+  left-whisk-section-htpy-over :
+    section-htpy-over (s ·l H)
+      ( left-whisk-htpy-over H H' s')
+      sA sX
+      ( comp-section-map-over s f s' f' sA sB sX S F)
+      ( comp-section-map-over s g s' g' sA sB sX S G)
+  left-whisk-section-htpy-over =
+    ind-htpy f
+      ( λ g H →
+        {g' : {a : A} → A' a → B' (g a)} →
+        (H' : htpy-over B' H f' g')
+        (G : section-map-over g g' sA sB)
+        (α : section-htpy-over H H' sA sB F G) →
+        section-htpy-over (s ·l H)
+          ( left-whisk-htpy-over H H' s')
+          sA sX
+          ( comp-section-map-over s f s' f' sA sB sX S F)
+          ( comp-section-map-over s g s' g' sA sB sX S G))
+      ( λ H' G α a →
+        ap (_∙ (ap s' (G a) ∙ S (f a)))
+          ( compute-left-whisk-htpy-over H' s' (sA a)) ∙
+        ind-htpy f'
+          ( λ g'a H'a →
+            (Ga : g'a (sA a) ＝ sB (f a)) →
+            (αa : H'a (sA a) ∙ Ga ＝ ap (tr B' refl) (F a) ∙ apd sB refl) →
+            ap s' (H'a (sA a)) ∙ (ap s' Ga ∙ S (f a)) ＝ ap (tr X' refl) (ap s' (F a) ∙ S (f a)) ∙ apd sX refl)
+          ( λ Ga αa → inv (right-unit ∙ (ap-id _ ∙ ap (_∙ S (f a)) (inv (ap (ap s') (αa ∙ (right-unit ∙ ap-id _)))))))
+          ( H')
+          ( G a)
+          ( α a))
+      ( H)
+      ( H')
+      ( G)
+      ( α)
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
+  {f g i : A → B}
+  (H : f ~ g) (K : g ~ i)
+  {f' : {a : A} → A' a → B' (f a)}
+  {g' : {a : A} → A' a → B' (g a)}
+  {i' : {a : A} → A' a → B' (i a)}
+  (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' i')
+  (sA : (a : A) → A' a)
+  (sB : (b : B) → B' b)
+  (F : section-map-over f f' sA sB)
+  (G : section-map-over g g' sA sB)
+  (I : section-map-over i i' sA sB)
+  (α : section-htpy-over H H' sA sB F G)
+  (β : section-htpy-over K K' sA sB G I)
+  where
+
+  concat-section-htpy-over :
+    section-htpy-over
+      ( H ∙h K)
+      ( concat-htpy-over H K H' K')
+      ( sA)
+      ( sB)
+      ( F)
+      ( I)
+  concat-section-htpy-over =
+    ind-htpy f
+      ( λ g H →
+        {i : A → B} (K : g ~ i)
+        {g' : {a : A} → A' a → B' (g a)}
+        {i' : {a : A} → A' a → B' (i a)}
+        (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' i')
+        (G : section-map-over g g' sA sB)
+        (I : section-map-over i i' sA sB)
+        (α : section-htpy-over H H' sA sB F G)
+        (β : section-htpy-over K K' sA sB G I) →
+        section-htpy-over
+          ( H ∙h K)
+          ( concat-htpy-over H K H' K')
+          sA sB F I)
+      ( λ K H' K' G I α β a →
+        ind-htpy (f' {a})
+          ( λ g'a H' →
+            {ia : B} (K : f a ＝ ia)
+            {i'a : A' a → B' ia}
+            (K' : (a' : A' a) → dependent-identification B' K (g'a a') (i'a a'))
+            (G : g'a (sA a) ＝ sB (f a))
+            (I : i'a (sA a) ＝ sB ia)
+            (α : H' (sA a) ∙ G ＝ ap id (F a) ∙ refl)
+            (β : K' (sA a) ∙ I ＝ ap (tr B' K) G ∙ apd sB K) →
+              concat-dependent-identification B' refl K (H' (sA a)) (K' (sA a)) ∙ I ＝
+              ap (tr B' K) (F a) ∙ apd sB K)
+          ( λ K K' G I α β → β ∙ ap (λ p → ap (tr B' K) p ∙ apd sB K) (α ∙ (right-unit ∙ ap-id (F a))))
+          ( H' {a})
+          ( K a)
+          ( K' {a})
+          ( G a)
+          ( I a)
+          ( α a)
+          ( β a))
+      ( H)
+      ( K)
+      ( H')
+      ( K')
+      ( G)
+      ( I)
+      ( α)
+      ( β)
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
+  (f : A → B) (g : A → X) (m : B → X)
+  (f' : {a : A} → A' a → B' (f a))
+  (g' : {a : A} → A' a → X' (g a))
+  (m' : {b : B} → B' b → X' (m b))
+  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sX : (x : X) → X' x)
+  (F : (a : A) → f' (sA a) ＝ sB (f a))
+  (G : (a : A) → g' (sA a) ＝ sX (g a))
+  (M : (b : B) → m' (sB b) ＝ sX (m b))
+  where
+
+  section-triangle-over :
+    (H : coherence-triangle-maps g m f) →
+    (H' : htpy-over X' H g' (m' ∘ f')) →
+    UU (l1 ⊔ l6)
+  section-triangle-over H H' =
+    (a : A) →
+    H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
+    ap (tr X' (H a)) (G a) ∙ apd sX (H a)
+
+  unget-section-triangle-over :
+    (H : coherence-triangle-maps g m f) →
+    (H' : htpy-over X' H g' (m' ∘ f')) →
+    section-triangle-over H H' →
+    section-htpy-over H H' sA sX G
+      ( comp-section-map-over m f m' f' sA sB sX M F)
+  unget-section-triangle-over H H' α =
+    inv-htpy-assoc-htpy (H' ·r sA) (m' ·l F) (M ·r f) ∙h α
+
+  section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    UU (l1 ⊔ l6)
+  section-triangle-over' H H' =
+    (a : A) →
+    H' (sA a) ∙ G a ＝
+    ap (tr X' (H a) ∘ m') (F a) ∙ ap (tr X' (H a)) (M (f a)) ∙ apd sX (H a)
+
+
+  equiv-get-section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    section-triangle-over' H H' ≃
+    section-htpy-over H H' sA sX
+      ( comp-section-map-over m f m' f' sA sB sX M F)
+      ( G)
+  equiv-get-section-triangle-over' H H' =
+    equiv-Π-equiv-family
+      ( λ a →
+        equiv-concat'
+          ( H' (sA a) ∙ G a)
+          ( ap
+            ( _∙ apd sX (H a))
+            ( ( ap
+                ( _∙ ap (tr X' (H a)) (M (f a)))
+                ( ap-comp (tr X' (H a)) m' (F a))) ∙
+              ( inv (ap-concat (tr X' (H a)) (ap m' (F a)) (M (f a)))))))
+
+  unget-section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    section-triangle-over' H H' →
+    section-htpy-over H H' sA sX
+      ( comp-section-map-over m f m' f' sA sB sX M F)
+      ( G)
+  unget-section-triangle-over' H H' =
+    map-equiv (equiv-get-section-triangle-over' H H')
+
+  get-section-triangle-over' :
+    (H : coherence-triangle-maps' g m f) →
+    (H' : htpy-over X' H (m' ∘ f') g') →
+    section-htpy-over H H' sA sX
+      ( comp-section-map-over m f m' f' sA sB sX M F)
+      ( G) →
+    section-triangle-over' H H'
+  get-section-triangle-over' H H' =
+    map-inv-equiv (equiv-get-section-triangle-over' H H')
+
+  -- actually ≐ section-triangle-over 🤔
+  -- section-triangle-over-inv :
+  --   (H : coherence-triangle-maps g m f) →
+  --   (H' : {a : A} (a' : A' a) → dependent-identification X' (H a) (g' a') (m' (f' a'))) →
+  --   UU (l1 ⊔ l6)
+  -- section-triangle-over-inv H H' =
+  --   (a : A) →
+  --   H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
+  --   ap (tr X' (H a)) (G a) ∙ apd sX (H a)
+
+module _
+  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+  {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
+  {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
+  (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
+  (g1' : {p : P1} → Q1 p → Q3 (g1 p))
+  (f1' : {p : P1} → Q1 p → Q2 (f1 p))
+  (f2' : {p : P3} → Q3 p → Q4 (f2 p))
+  (g2' : {p : P2} → Q2 p → Q4 (g2 p))
+  where
+
+  square-over : coherence-square-maps g1 f1 f2 g2 → UU (l1 ⊔ l5 ⊔ l8)
+  square-over H = htpy-over Q4 H (g2' ∘ f1') (f2' ∘ g1')
+
+  module _
+    (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p) (s3 : (p : P3) → Q3 p)
+    (s4 : (p : P4) → Q4 p)
+    (G1 : (p : P1) → g1' (s1 p) ＝ s3 (g1 p))
+    (F1 : (p : P1) → f1' (s1 p) ＝ s2 (f1 p))
+    (F2 : (p : P3) → f2' (s3 p) ＝ s4 (f2 p))
+    (G2 : (p : P2) → g2' (s2 p) ＝ s4 (g2 p))
+    (H : coherence-square-maps g1 f1 f2 g2)
+    (H' : square-over H)
+    where
+
+    section-square-over : UU (l1 ⊔ l8)
+    section-square-over =
+      (p : P1) →
+      H' (s1 p) ∙ ap f2' (G1 p) ∙ (F2 (g1 p)) ＝
+      ( ap (tr Q4 (H p) ∘ g2') (F1 p) ∙
+        ap (tr Q4 (H p)) (G2 (f1 p)) ∙
+        apd s4 (H p))
+
+    get-section-square-over :
+      section-htpy-over H H' s1 s4
+        ( comp-section-map-over g2 f1 g2' f1' s1 s2 s4 G2 F1)
+        ( comp-section-map-over f2 g1 f2' g1' s1 s3 s4 F2 G1) →
+      section-square-over
+    get-section-square-over α =
+      assoc-htpy (H' ·r s1) (f2' ·l G1) (F2 ·r g1) ∙h
+      α ∙h
+      ( λ p →
+        ap
+          ( _∙ apd s4 (H p))
+          ( ap-concat (tr Q4 (H p)) (ap g2' (F1 p)) (G2 (f1 p)) ∙
+            ap (_∙ _) (inv (ap-comp _ g2' (F1 p)))))
+
+  module _
+    (m : P2 → P3)
+    (m' : {p : P2} → Q2 p → Q3 (m p))
+    (B1 : coherence-triangle-maps' g1 m f1)
+    (B2 : coherence-triangle-maps g2 f2 m)
+    (T1 : htpy-over Q3 B1 (m' ∘ f1') g1')
+    (T2 : htpy-over Q4 B2 g2' (f2' ∘ m'))
+    where
+
+    pasting-triangles-over :
+      htpy-over Q4
+        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
+        ( g2' ∘ f1')
+        ( f2' ∘ g1')
+    pasting-triangles-over =
+      concat-htpy-over
+        ( B2 ·r f1)
+        ( f2 ·l B1)
+        ( right-whisk-htpy-over B2 T2 f1 f1')
+        ( left-whisk-htpy-over B1 T1 f2')
+
+  module _
+    (m : P2 → P3)
+    (m' : {p : P2} → Q2 p → Q3 (m p))
+    (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p) (s3 : (p : P3) → Q3 p)
+    (s4 : (p : P4) → Q4 p)
+    (G1 : (p : P1) → g1' (s1 p) ＝ s3 (g1 p))
+    (F1 : (p : P1) → f1' (s1 p) ＝ s2 (f1 p))
+    (F2 : (p : P3) → f2' (s3 p) ＝ s4 (f2 p))
+    (G2 : (p : P2) → g2' (s2 p) ＝ s4 (g2 p))
+    (M : (p : P2) → m' (s2 p) ＝ s3 (m p))
+    (B1 : coherence-triangle-maps' g1 m f1)
+    (B2 : coherence-triangle-maps g2 f2 m)
+    (T1 : htpy-over Q3 B1 (m' ∘ f1') g1')
+    (T2 : htpy-over Q4 B2 g2' (f2' ∘ m'))
+    where
+
+    pasting-sections-triangles-over :
+      section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 →
+      section-triangle-over m g2 f2 m' g2' f2' s2 s3 s4 M G2 F2 B2 T2 →
+      section-square-over s1 s2 s3 s4 G1 F1 F2 G2
+        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
+        ( pasting-triangles-over m m' B1 B2 T1 T2)
+    pasting-sections-triangles-over S1 S2 =
+      get-section-square-over s1 s2 s3 s4 G1 F1 F2 G2
+        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
+        ( pasting-triangles-over m m' B1 B2 T1 T2)
+        ( concat-section-htpy-over (B2 ·r f1) (f2 ·l B1)
+           ( right-whisk-htpy-over B2 T2 f1 f1')
+           ( left-whisk-htpy-over B1 T1 f2')
+           s1 s4
+           ( comp-section-map-over g2 f1 g2' f1' s1 s2 s4 G2 F1)
+           ( comp-section-map-over (f2 ∘ m) f1 (f2' ∘ m') f1' s1 s2 s4
+             ( comp-section-map-over f2 m f2' m' s2 s3 s4 F2 M)
+             ( F1))
+           ( comp-section-map-over f2 g1 f2' g1' s1 s3 s4 F2 G1)
+           ( [ii])
+           ( concat-section-htpy-over refl-htpy (f2 ·l B1) refl-htpy
+             ( left-whisk-htpy-over B1 T1 f2')
+             s1 s4 _ _ _
+             ( assoc-comp-section-map-over f1' m' f2' s1 s2 s3 s4 F1 M F2)
+             ( [iv])))
+      where
+        [i] = unget-section-triangle-over m g2 f2 m' g2' f2' s2 s3 s4 M G2 F2 B2 T2 S2
+        [ii] = right-whisk-section-htpy-over B2 T2 s2 s4 _ _ [i] f1 f1' s1 F1
+        [iii] = unget-section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 S1
+        [iv] = left-whisk-section-htpy-over B1 T1 s1 s3 _ _ [iii] f2 f2' s4 F2
+```
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index daa3941fdb..4f53e6bfd7 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -51,6 +51,8 @@ open import synthetic-homotopy-theory.shifts-sequential-diagrams
 open import synthetic-homotopy-theory.sections-descent-data-pushouts
 open import synthetic-homotopy-theory.universal-property-pushouts
 open import synthetic-homotopy-theory.zigzags-sequential-diagrams
+
+open import synthetic-homotopy-theory.stuff-over
 ```
 
 </details>
@@ -63,641 +65,6 @@ colimits of pushouts.
 ## Definitions
 
 ```agda
-open import foundation.commuting-triangles-of-maps
-open import foundation.whiskering-homotopies-concatenation
-open import foundation.homotopy-induction
-open import foundation.dependent-homotopies
-
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2}
-  {A' : A → UU l3} (B' : B → UU l4)
-  {f g : A → B}
-  (H : f ~ g)
-  (f' : {a : A} → A' a → B' (f a))
-  (g' : {a : A} → A' a → B' (g a))
-  where
-
-  htpy-over : UU (l1 ⊔ l3 ⊔ l4)
-  htpy-over = {a : A} (a' : A' a) → dependent-identification B' (H a) (f' a') (g' a')
-
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2}
-  {A' : A → UU l3} (B' : B → UU l4)
-  {f g : A → B}
-  (H : f ~ g)
-  (f' : {a : A} → A' a → B' (f a))
-  (g' : {a : A} → A' a → B' (g a))
-  where
-
-  inv-htpy-over : htpy-over B' H f' g' → htpy-over B' (inv-htpy H) g' f'
-  inv-htpy-over H' a' =
-    map-eq-transpose-equiv-inv (equiv-tr B' (H _)) (inv (H' a'))
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
-  {f g : A → B}
-  (H : f ~ g)
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {a : A} → A' a → B' (g a)}
-  (H' : htpy-over B' H f' g')
-  {s : X → A} (s' : {x : X} → X' x → A' (s x))
-  where
-
-  right-whisk-htpy-over : htpy-over B' (H ·r s) (f' ∘ s') (g' ∘ s')
-  right-whisk-htpy-over a' = H' (s' a')
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
-  {f g : A → B}
-  (H : f ~ g)
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {a : A} → A' a → B' (g a)}
-  (H' : htpy-over B' H f' g')
-  {s : B → X} (s' : {b : B} → B' b → X' (s b))
-  where
-
-  LWMOTIF : {a : A} (a' : A' a) (g : A → B) (H : f ~ g) → UU (l5 ⊔ l6)
-  LWMOTIF {a} a' g H =
-    {g'a' : B' (g a)} →
-    (H' : tr B' (H a) (f' a') ＝ g'a') →
-    tr X' (ap s (H a)) (s' (f' a')) ＝ s' (g'a')
-
-  left-whisk-htpy-over : htpy-over X' (s ·l H) (s' ∘ f') (s' ∘ g')
-  left-whisk-htpy-over {a} a' =
-    ind-htpy f
-      ( LWMOTIF a')
-      ( ap s')
-      ( H)
-      ( H' a')
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
-  {f : A → B}
-  {f' g' : {a : A} → A' a → B' (f a)}
-  (H' : {a : A} → f' {a} ~ g')
-  {s : B → X} (s' : {b : B} → B' b → X' (s b))
-  where
-
-  open import foundation.function-extensionality
-
-  compute-left-whisk-htpy-over :
-    {a : A} (a' : A' a) →
-    left-whisk-htpy-over {B' = B'} {X' = X'} {f = f} refl-htpy H' s' a' ＝ ap s' (H' a')
-  compute-left-whisk-htpy-over a' =
-    htpy-eq
-      ( htpy-eq-implicit
-        ( compute-ind-htpy f
-          ( LWMOTIF {B' = B'} {X' = X'} refl-htpy H' s' a')
-          ( ap s'))
-        ( g' a'))
-      ( H' a')
-
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
-  {f g h : A → B}
-  (H : f ~ g) (K : g ~ h)
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {a : A} → A' a → B' (g a)}
-  {h' : {a : A} → A' a → B' (h a)}
-  (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' h')
-  where
-
-  concat-htpy-over : htpy-over B' (H ∙h K) f' h'
-  concat-htpy-over {a} a' =
-    concat-dependent-identification B' (H a) (K a) (H' a') (K' a')
-
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
-  (f : A → B)
-  (f' : {a : A} → A' a → B' (f a))
-  (sA : (a : A) → A' a)
-  (sB : (b : B) → B' b)
-  where
-
-  section-map-over : UU (l1 ⊔ l4)
-  section-map-over = (a : A) → f' (sA a) ＝ sB (f a)
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {C' : C → UU l6}
-  (g : B → C) (f : A → B)
-  (g' : {b : B} → B' b → C' (g b))
-  (f' : {a : A} → A' a → B' (f a))
-  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sC : (c : C) → C' c)
-  where
-
-  comp-section-map-over :
-    section-map-over g g' sB sC → section-map-over f f' sA sB →
-    section-map-over (g ∘ f) (g' ∘ f') sA sC
-  comp-section-map-over G F =
-    g' ·l F ∙h G ·r f
-
-
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
-  {f g : A → B}
-  (H : f ~ g)
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {a : A} → A' a → B' (g a)}
-  (H' : htpy-over B' H f' g')
-  (sA : (a : A) → A' a)
-  (sB : (b : B) → B' b)
-  (F : section-map-over f f' sA sB)
-  (G : section-map-over g g' sA sB)
-  where
-
-  section-htpy-over : UU (l1 ⊔ l4)
-  section-htpy-over =
-    (a : A) →
-    H' (sA a) ∙ G a ＝
-    ap (tr B' (H a)) (F a) ∙ apd sB (H a)
-
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
-  {f g : A → B}
-  (H : f ~ g)
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {a : A} → A' a → B' (g a)}
-  (H' : htpy-over B' H f' g')
-  (sA : (a : A) → A' a)
-  (sB : (b : B) → B' b)
-  (F : section-map-over f f' sA sB)
-  (G : section-map-over g g' sA sB)
-  where
-
-  inv-section-htpy-over :
-    section-htpy-over H H' sA sB F G →
-    section-htpy-over
-      ( inv-htpy H)
-      ( inv-htpy-over B' H f' g' H')
-      ( sA)
-      ( sB)
-      ( G)
-      ( F)
-  inv-section-htpy-over α =
-    ind-htpy f
-      ( λ g H →
-        {g' : {a : A} → A' a → B' (g a)} →
-        (H' : htpy-over B' H f' g') →
-        (G : section-map-over g g' sA sB) →
-        section-htpy-over H H' sA sB F G →
-        section-htpy-over
-          ( inv-htpy H)
-          ( inv-htpy-over B' H f' g' H')
-          sA sB G F)
-      ( λ H' G α a →
-        ind-htpy f'
-          ( λ g'a H'a →
-            (Ga : g'a (sA a) ＝ sB (f a)) →
-            (αa : H'a (sA a) ∙ Ga ＝ ap (tr B' refl) (F a) ∙ apd sB refl) →
-            map-eq-transpose-equiv-inv (equiv-tr B' refl) (inv (H'a (sA a))) ∙ F a ＝
-            ap (tr B' refl) Ga ∙ apd sB refl)
-          ( λ Ga αa →
-            ap (_∙ F a) (compute-refl-eq-transpose-equiv-inv (equiv-tr B' refl)) ∙
-            inv (right-unit ∙ ap-id _ ∙ (αa ∙ right-unit ∙ ap-id _)))
-          ( H')
-          ( G a)
-          ( α a))
-      ( H)
-      ( H')
-      ( G)
-      ( α)
-
-module _
-  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
-  {A' : A → UU l5} {B' : B → UU l6} {C' : C → UU l7} {D' : D → UU l8}
-  {f : A → B} {g : B → C} {h : C → D}
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {b : B} → B' b → C' (g b)}
-  {h' : {c : C} → C' c → D' (h c)}
-  (sA : (a : A) → A' a)
-  (sB : (b : B) → B' b)
-  (sC : (c : C) → C' c)
-  (sD : (d : D) → D' d)
-  (F : section-map-over f f' sA sB)
-  (G : section-map-over g g' sB sC)
-  (H : section-map-over h h' sC sD)
-  where
-
-  assoc-comp-section-map-over :
-    section-htpy-over
-      ( refl-htpy {f = h ∘ g ∘ f})
-      ( refl-htpy {f = h' ∘ g' ∘ f'})
-      sA sD
-      ( comp-section-map-over (h ∘ g) f (h' ∘ g') f' sA sB sD
-        ( comp-section-map-over h g h' g' sB sC sD H G)
-        ( F))
-      ( comp-section-map-over h (g ∘ f) h' (g' ∘ f') sA sC sD H
-        ( comp-section-map-over g f g' f' sA sB sC G F))
-  assoc-comp-section-map-over =
-    inv-htpy
-      ( right-unit-htpy ∙h
-        left-unit-law-left-whisker-comp _ ∙h
-        inv-htpy-assoc-htpy _ _ _ ∙h
-        right-whisker-concat-htpy
-          ( ( right-whisker-concat-htpy
-              ( inv-preserves-comp-left-whisker-comp h' g' F)
-              ( h' ·l G ·r f)) ∙h
-            ( inv-htpy
-              ( distributive-left-whisker-comp-concat h'
-                ( g' ·l F)
-                ( G ·r f))))
-          ( H ·r g ·r f))
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
-  {f g : A → B}
-  (H : f ~ g)
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {a : A} → A' a → B' (g a)}
-  (H' : htpy-over B' H f' g')
-  (sA : (a : A) → A' a)
-  (sB : (b : B) → B' b)
-  (F : section-map-over f f' sA sB)
-  (G : section-map-over g g' sA sB)
-  (α : section-htpy-over H H' sA sB F G)
-  (s : X → A)
-  (s' : {x : X} → X' x → A' (s x))
-  (sX : (x : X) → X' x)
-  (S : section-map-over s s' sX sA)
-  where
-
-  right-whisk-section-htpy-over :
-    section-htpy-over (H ·r s)
-      ( right-whisk-htpy-over H H' s')
-      sX sB
-      ( comp-section-map-over f s f' s' sX sA sB F S)
-      ( comp-section-map-over g s g' s' sX sA sB G S)
-  right-whisk-section-htpy-over =
-    ind-htpy f
-      ( λ g H →
-          {g' : {a : A} → A' a → B' (g a)}
-          (H' : htpy-over B' H f' g')
-          (G : section-map-over g g' sA sB)
-          (α : section-htpy-over H H' sA sB F G) →
-          section-htpy-over (H ·r s)
-            ( right-whisk-htpy-over H H' s')
-            sX sB
-            ( comp-section-map-over f s f' s' sX sA sB F S)
-            ( comp-section-map-over g s g' s' sX sA sB G S))
-      ( λ H' G α x →
-        ind-htpy (f' {s x})
-          ( λ g'sx H'sx →
-            (Gsx : g'sx (sA (s x)) ＝ sB (f (s x)))
-            (αsx : H'sx (sA (s x)) ∙ Gsx ＝ ap (tr B' refl) (F (s x)) ∙ apd sB refl) →
-            H'sx (s' (sX x)) ∙ ((ap g'sx (S x)) ∙ Gsx) ＝
-            ap (tr B' refl) (ap f' (S x) ∙ (F (s x))) ∙ apd sB refl)
-          ( λ Gsx αsx → inv (right-unit ∙ (ap-id _ ∙ ap (ap f' (S x) ∙_) (inv (αsx ∙ (right-unit ∙ ap-id _))))))
-          ( H')
-          ( G (s x))
-          ( α (s x)))
-      ( H)
-      ( H')
-      ( G)
-      ( α)
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
-  {f g : A → B}
-  (H : f ~ g)
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {a : A} → A' a → B' (g a)}
-  (H' : htpy-over B' H f' g')
-  (sA : (a : A) → A' a)
-  (sB : (b : B) → B' b)
-  (F : section-map-over f f' sA sB)
-  (G : section-map-over g g' sA sB)
-  (α : section-htpy-over H H' sA sB F G)
-  (s : B → X)
-  (s' : {b : B} → B' b → X' (s b))
-  (sX : (x : X) → X' x)
-  (S : section-map-over s s' sB sX)
-  where
-
-  open import foundation.function-extensionality
-
-  left-whisk-section-htpy-over :
-    section-htpy-over (s ·l H)
-      ( left-whisk-htpy-over H H' s')
-      sA sX
-      ( comp-section-map-over s f s' f' sA sB sX S F)
-      ( comp-section-map-over s g s' g' sA sB sX S G)
-  left-whisk-section-htpy-over =
-    ind-htpy f
-      ( λ g H →
-        {g' : {a : A} → A' a → B' (g a)} →
-        (H' : htpy-over B' H f' g')
-        (G : section-map-over g g' sA sB)
-        (α : section-htpy-over H H' sA sB F G) →
-        section-htpy-over (s ·l H)
-          ( left-whisk-htpy-over H H' s')
-          sA sX
-          ( comp-section-map-over s f s' f' sA sB sX S F)
-          ( comp-section-map-over s g s' g' sA sB sX S G))
-      ( λ H' G α a →
-        ap (_∙ (ap s' (G a) ∙ S (f a)))
-          ( compute-left-whisk-htpy-over H' s' (sA a)) ∙
-        ind-htpy f'
-          ( λ g'a H'a →
-            (Ga : g'a (sA a) ＝ sB (f a)) →
-            (αa : H'a (sA a) ∙ Ga ＝ ap (tr B' refl) (F a) ∙ apd sB refl) →
-            ap s' (H'a (sA a)) ∙ (ap s' Ga ∙ S (f a)) ＝ ap (tr X' refl) (ap s' (F a) ∙ S (f a)) ∙ apd sX refl)
-          ( λ Ga αa → inv (right-unit ∙ (ap-id _ ∙ ap (_∙ S (f a)) (inv (ap (ap s') (αa ∙ (right-unit ∙ ap-id _)))))))
-          ( H')
-          ( G a)
-          ( α a))
-      ( H)
-      ( H')
-      ( G)
-      ( α)
-
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
-  {f g i : A → B}
-  (H : f ~ g) (K : g ~ i)
-  {f' : {a : A} → A' a → B' (f a)}
-  {g' : {a : A} → A' a → B' (g a)}
-  {i' : {a : A} → A' a → B' (i a)}
-  (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' i')
-  (sA : (a : A) → A' a)
-  (sB : (b : B) → B' b)
-  (F : section-map-over f f' sA sB)
-  (G : section-map-over g g' sA sB)
-  (I : section-map-over i i' sA sB)
-  (α : section-htpy-over H H' sA sB F G)
-  (β : section-htpy-over K K' sA sB G I)
-  where
-
-  concat-section-htpy-over :
-    section-htpy-over
-      ( H ∙h K)
-      ( concat-htpy-over H K H' K')
-      ( sA)
-      ( sB)
-      ( F)
-      ( I)
-  concat-section-htpy-over =
-    ind-htpy f
-      ( λ g H →
-        {i : A → B} (K : g ~ i)
-        {g' : {a : A} → A' a → B' (g a)}
-        {i' : {a : A} → A' a → B' (i a)}
-        (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' i')
-        (G : section-map-over g g' sA sB)
-        (I : section-map-over i i' sA sB)
-        (α : section-htpy-over H H' sA sB F G)
-        (β : section-htpy-over K K' sA sB G I) →
-        section-htpy-over
-          ( H ∙h K)
-          ( concat-htpy-over H K H' K')
-          sA sB F I)
-      ( λ K H' K' G I α β a →
-        ind-htpy (f' {a})
-          ( λ g'a H' →
-            {ia : B} (K : f a ＝ ia)
-            {i'a : A' a → B' ia}
-            (K' : (a' : A' a) → dependent-identification B' K (g'a a') (i'a a'))
-            (G : g'a (sA a) ＝ sB (f a))
-            (I : i'a (sA a) ＝ sB ia)
-            (α : H' (sA a) ∙ G ＝ ap id (F a) ∙ refl)
-            (β : K' (sA a) ∙ I ＝ ap (tr B' K) G ∙ apd sB K) →
-              concat-dependent-identification B' refl K (H' (sA a)) (K' (sA a)) ∙ I ＝
-              ap (tr B' K) (F a) ∙ apd sB K)
-          ( λ K K' G I α β → β ∙ ap (λ p → ap (tr B' K) p ∙ apd sB K) (α ∙ (right-unit ∙ ap-id (F a))))
-          ( H' {a})
-          ( K a)
-          ( K' {a})
-          ( G a)
-          ( I a)
-          ( α a)
-          ( β a))
-      ( H)
-      ( K)
-      ( H')
-      ( K')
-      ( G)
-      ( I)
-      ( α)
-      ( β)
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
-  (f : A → B) (g : A → X) (m : B → X)
-  (f' : {a : A} → A' a → B' (f a))
-  (g' : {a : A} → A' a → X' (g a))
-  (m' : {b : B} → B' b → X' (m b))
-  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sX : (x : X) → X' x)
-  (F : (a : A) → f' (sA a) ＝ sB (f a))
-  (G : (a : A) → g' (sA a) ＝ sX (g a))
-  (M : (b : B) → m' (sB b) ＝ sX (m b))
-  where
-
-  section-triangle-over :
-    (H : coherence-triangle-maps g m f) →
-    (H' : htpy-over X' H g' (m' ∘ f')) →
-    UU (l1 ⊔ l6)
-  section-triangle-over H H' =
-    (a : A) →
-    H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
-    ap (tr X' (H a)) (G a) ∙ apd sX (H a)
-
-  unget-section-triangle-over :
-    (H : coherence-triangle-maps g m f) →
-    (H' : htpy-over X' H g' (m' ∘ f')) →
-    section-triangle-over H H' →
-    section-htpy-over H H' sA sX G
-      ( comp-section-map-over m f m' f' sA sB sX M F)
-  unget-section-triangle-over H H' α = inv-htpy-assoc-htpy _ _ _ ∙h α
-
-  section-triangle-over' :
-    (H : coherence-triangle-maps' g m f) →
-    (H' : htpy-over X' H (m' ∘ f') g') →
-    UU (l1 ⊔ l6)
-  section-triangle-over' H H' =
-    (a : A) →
-    H' (sA a) ∙ G a ＝
-    ap (tr X' (H a) ∘ m') (F a) ∙ ap (tr X' (H a)) (M (f a)) ∙ apd sX (H a)
-
-
-  open import foundation.functoriality-dependent-function-types
-  equiv-get-section-triangle-over' :
-    (H : coherence-triangle-maps' g m f) →
-    (H' : htpy-over X' H (m' ∘ f') g') →
-    section-triangle-over' H H' ≃
-    section-htpy-over H H' sA sX
-      ( comp-section-map-over m f m' f' sA sB sX M F)
-      ( G)
-  equiv-get-section-triangle-over' H H' =
-    equiv-Π-equiv-family
-      ( λ a →
-        equiv-concat'
-          ( H' (sA a) ∙ G a)
-          ( ap
-            ( _∙ apd sX (H a))
-            ( ( ap
-                ( _∙ ap (tr X' (H a)) (M (f a)))
-                ( ap-comp (tr X' (H a)) m' (F a))) ∙
-              ( inv (ap-concat (tr X' (H a)) (ap m' (F a)) (M (f a)))))))
-
-  unget-section-triangle-over' :
-    (H : coherence-triangle-maps' g m f) →
-    (H' : htpy-over X' H (m' ∘ f') g') →
-    section-triangle-over' H H' →
-    section-htpy-over H H' sA sX
-      ( comp-section-map-over m f m' f' sA sB sX M F)
-      ( G)
-  unget-section-triangle-over' H H' =
-    map-equiv (equiv-get-section-triangle-over' H H')
-
-  get-section-triangle-over' :
-    (H : coherence-triangle-maps' g m f) →
-    (H' : htpy-over X' H (m' ∘ f') g') →
-    section-htpy-over H H' sA sX
-      ( comp-section-map-over m f m' f' sA sB sX M F)
-      ( G) →
-    section-triangle-over' H H'
-  get-section-triangle-over' H H' =
-    map-inv-equiv (equiv-get-section-triangle-over' H H')
-
-  -- actually ≐ section-triangle-over 🤔
-  -- section-triangle-over-inv :
-  --   (H : coherence-triangle-maps g m f) →
-  --   (H' : {a : A} (a' : A' a) → dependent-identification X' (H a) (g' a') (m' (f' a'))) →
-  --   UU (l1 ⊔ l6)
-  -- section-triangle-over-inv H H' =
-  --   (a : A) →
-  --   H' (sA a) ∙ ap m' (F a) ∙ (M (f a)) ＝
-  --   ap (tr X' (H a)) (G a) ∙ apd sX (H a)
-
-module _
-  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
-  {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
-  {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
-  (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
-  (g1' : {p : P1} → Q1 p → Q3 (g1 p))
-  (f1' : {p : P1} → Q1 p → Q2 (f1 p))
-  (f2' : {p : P3} → Q3 p → Q4 (f2 p))
-  (g2' : {p : P2} → Q2 p → Q4 (g2 p))
-  where
-
-  module _
-    (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p) (s3 : (p : P3) → Q3 p)
-    (s4 : (p : P4) → Q4 p)
-    (G1 : (p : P1) → g1' (s1 p) ＝ s3 (g1 p))
-    (F1 : (p : P1) → f1' (s1 p) ＝ s2 (f1 p))
-    (F2 : (p : P3) → f2' (s3 p) ＝ s4 (f2 p))
-    (G2 : (p : P2) → g2' (s2 p) ＝ s4 (g2 p))
-    (H : coherence-square-maps g1 f1 f2 g2)
-    (H' : htpy-over Q4 H (g2' ∘ f1') (f2' ∘ g1'))
-    where
-
-    section-square-over : UU (l1 ⊔ l8)
-    section-square-over =
-      (p : P1) →
-      H' (s1 p) ∙ ap f2' (G1 p) ∙ (F2 (g1 p)) ＝
-      ( ap (tr Q4 (H p) ∘ g2') (F1 p) ∙
-        ap (tr Q4 (H p)) (G2 (f1 p)) ∙
-        apd s4 (H p))
-
-    get-section-square-over :
-      section-htpy-over H H' s1 s4
-        ( comp-section-map-over g2 f1 g2' f1' s1 s2 s4 G2 F1)
-        ( comp-section-map-over f2 g1 f2' g1' s1 s3 s4 F2 G1) →
-      section-square-over
-    get-section-square-over α p =
-      assoc _ _ _ ∙
-      α p ∙
-      ap (_∙ apd s4 (H p))
-        (ap-concat (tr Q4 (H p)) _ _ ∙ ap (_∙ _) (inv (ap-comp _ g2' (F1 p))))
-
-  module _
-    (m : P2 → P3)
-    (m' : {p : P2} → Q2 p → Q3 (m p))
-    (B1 : coherence-triangle-maps' g1 m f1)
-    (B2 : coherence-triangle-maps g2 f2 m)
-    (T1 : htpy-over Q3 B1 (m' ∘ f1') g1')
-    (T2 : htpy-over Q4 B2 g2' (f2' ∘ m'))
-    where
-
-    pasting-triangles-over :
-      htpy-over Q4
-        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
-        ( g2' ∘ f1')
-        ( f2' ∘ g1')
-    pasting-triangles-over =
-      concat-htpy-over
-        ( B2 ·r f1)
-        ( f2 ·l B1)
-        ( right-whisk-htpy-over B2 T2 f1')
-        ( left-whisk-htpy-over B1 T1 f2')
-
-  module _
-    (m : P2 → P3)
-    (m' : {p : P2} → Q2 p → Q3 (m p))
-    (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p) (s3 : (p : P3) → Q3 p)
-    (s4 : (p : P4) → Q4 p)
-    (G1 : (p : P1) → g1' (s1 p) ＝ s3 (g1 p))
-    (F1 : (p : P1) → f1' (s1 p) ＝ s2 (f1 p))
-    (F2 : (p : P3) → f2' (s3 p) ＝ s4 (f2 p))
-    (G2 : (p : P2) → g2' (s2 p) ＝ s4 (g2 p))
-    (M : (p : P2) → m' (s2 p) ＝ s3 (m p))
-    (B1 : coherence-triangle-maps' g1 m f1)
-    (B2 : coherence-triangle-maps g2 f2 m)
-    (T1 : htpy-over Q3 B1 (m' ∘ f1') g1')
-    (T2 : htpy-over Q4 B2 g2' (f2' ∘ m'))
-    where
-
-    pasting-sections-triangles-over :
-      section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 →
-      section-triangle-over m g2 f2 m' g2' f2' s2 s3 s4 M G2 F2 B2 T2 →
-      section-square-over s1 s2 s3 s4 G1 F1 F2 G2
-        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
-        ( pasting-triangles-over m m' B1 B2 T1 T2)
-    pasting-sections-triangles-over S1 S2 =
-      get-section-square-over s1 s2 s3 s4 G1 F1 F2 G2
-        ( horizontal-pasting-up-diagonal-coherence-triangle-maps g1 f1 f2 g2 B1 B2)
-        ( pasting-triangles-over m m' B1 B2 T1 T2)
-        ( concat-section-htpy-over (B2 ·r f1) (f2 ·l B1)
-           ( right-whisk-htpy-over B2 T2 f1')
-           ( left-whisk-htpy-over B1 T1 f2')
-           s1 s4
-           ( comp-section-map-over g2 f1 g2' f1' s1 s2 s4 G2 F1)
-           ( comp-section-map-over (f2 ∘ m) f1 (f2' ∘ m') f1' s1 s2 s4
-             ( comp-section-map-over f2 m f2' m' s2 s3 s4 F2 M)
-             ( F1))
-           ( comp-section-map-over f2 g1 f2' g1' s1 s3 s4 F2 G1)
-           ( [ii])
-           ( concat-section-htpy-over refl-htpy (f2 ·l B1) refl-htpy
-             ( left-whisk-htpy-over B1 T1 f2')
-             s1 s4 _ _ _
-             ( assoc-comp-section-map-over _ _ _ _ F1 M F2)
-             ( [iv])))
-      where
-        [i] = unget-section-triangle-over m g2 f2 m' g2' f2' s2 s3 s4 M G2 F2 B2 T2 S2
-        [ii] = right-whisk-section-htpy-over B2 T2 s2 s4 _ _ [i] f1 f1' s1 F1
-        [iii] = unget-section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 S1
-        [iv] = left-whisk-section-htpy-over B1 T1 s1 s3 _ _ [iii] f2 f2' s4 F2
 
 module _
   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)

From 78685af2e1e9f36bb12e2b4668727971f85acb0e Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Fri, 17 Jan 2025 18:36:13 +0100
Subject: [PATCH 16/33] Attempt to factorize out the functoriality lemma

---
 .../functoriality-stuff.lagda.md              | 204 ++++++++++++++++++
 ...nstruction-identity-type-pushouts.lagda.md |  28 ++-
 2 files changed, 231 insertions(+), 1 deletion(-)
 create mode 100644 src/synthetic-homotopy-theory/functoriality-stuff.lagda.md

diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
new file mode 100644
index 0000000000..f3bb11a0e5
--- /dev/null
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -0,0 +1,204 @@
+# Functoriality stuff
+
+```agda
+{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
+
+module synthetic-homotopy-theory.functoriality-stuff where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.action-on-identifications-dependent-functions
+open import foundation.action-on-identifications-functions
+-- open import foundation.commuting-squares-of-maps
+-- open import foundation.commuting-triangles-of-maps
+-- open import foundation.dependent-identifications
+open import foundation.dependent-pair-types
+open import foundation.embeddings
+open import foundation.equivalences
+-- open import foundation.function-extensionality
+open import foundation.function-types
+-- open import foundation.functoriality-dependent-function-types
+open import foundation.homotopies
+-- open import foundation.homotopy-induction
+open import foundation.identity-types
+open import foundation.transport-along-identifications
+-- open import foundation.transposition-identifications-along-equivalences
+open import foundation.universe-levels
+-- open import foundation.whiskering-homotopies-composition
+-- open import foundation.whiskering-homotopies-concatenation
+
+open import synthetic-homotopy-theory.cocones-under-sequential-diagrams
+open import synthetic-homotopy-theory.dependent-sequential-diagrams
+open import synthetic-homotopy-theory.dependent-universal-property-sequential-colimits
+open import synthetic-homotopy-theory.descent-data-sequential-colimits
+open import synthetic-homotopy-theory.functoriality-sequential-colimits
+open import synthetic-homotopy-theory.morphisms-sequential-diagrams
+open import synthetic-homotopy-theory.sequential-diagrams
+open import synthetic-homotopy-theory.stuff-over
+open import synthetic-homotopy-theory.universal-property-sequential-colimits
+```
+
+## Theorem
+
+```agda
+module _
+  {l1 l2 : Level}
+  {A : sequential-diagram l1}
+  (P : descent-data-sequential-colimit A l2)
+  where
+
+  section-descent-data-sequential-colimit : UU (l1 ⊔ l2)
+  section-descent-data-sequential-colimit =
+    Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
+        family-descent-data-sequential-colimit P n a)
+      ( λ s →
+        (n : ℕ) (a : family-sequential-diagram A n) →
+        map-family-descent-data-sequential-colimit P n a (s n a) ＝
+        s (succ-ℕ n) (map-sequential-diagram A n a))
+
+module _
+  {l1 l2 l3 : Level}
+  {A : sequential-diagram l1}
+  {X : UU l2} {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  (P : X → UU l3)
+  where
+
+  sect-family-sect-dd-sequential-colimit :
+    section-descent-data-sequential-colimit
+      ( descent-data-family-cocone-sequential-diagram c P) →
+    ((x : X) → P x)
+  sect-family-sect-dd-sequential-colimit s =
+    map-dependent-universal-property-sequential-colimit
+      ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+      ( s)
+```
+
+```agda
+module big-thm
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : sequential-diagram l1}
+  {B : sequential-diagram l2}
+  {X : UU l3} {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {Y : UU l4} {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (H : hom-sequential-diagram A B)
+  where
+
+  -- the squares induce a map
+
+  f∞ : X → Y
+  f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' H
+
+  Cn : (n : ℕ) →
+    f∞ ∘ map-cocone-sequential-diagram c n ~
+    map-cocone-sequential-diagram c' n ∘ map-hom-sequential-diagram B H n
+  Cn =
+    htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H
+
+  module _
+    (P : X → UU l5) (Q : Y → UU l6)
+    (f'∞ : {x : X} → P x → Q (f∞ x))
+    where
+
+    An : ℕ → UU l1
+    An = family-sequential-diagram A
+    Bn : ℕ → UU l2
+    Bn = family-sequential-diagram B
+    an : {n : ℕ} → An n → An (succ-ℕ n)
+    an = map-sequential-diagram A _
+    bn : {n : ℕ} → Bn n → Bn (succ-ℕ n)
+    bn = map-sequential-diagram B _
+    fn : {n : ℕ} → An n → Bn n
+    fn = map-hom-sequential-diagram B H _
+    Hn : {n : ℕ} → bn {n} ∘ fn ~ fn ∘ an
+    Hn = naturality-map-hom-sequential-diagram B H _
+
+    -- a map-over induces squares-over
+
+    -- first, the sequences-over:
+    𝒟P : descent-data-sequential-colimit A l5
+    𝒟P = descent-data-family-cocone-sequential-diagram c P
+    𝒫 = dependent-sequential-diagram-descent-data 𝒟P
+    𝒟Q : descent-data-sequential-colimit B l6
+    𝒟Q = descent-data-family-cocone-sequential-diagram c' Q
+    𝒬 = dependent-sequential-diagram-descent-data 𝒟Q
+
+    Pn : {n : ℕ} → An n → UU l5
+    Pn = family-descent-data-sequential-colimit 𝒟P _
+    Qn : {n : ℕ} → Bn n → UU l6
+    Qn = family-descent-data-sequential-colimit 𝒟Q _
+
+    pn : {n : ℕ} (a : An n) → Pn a → Pn (an a)
+    pn = map-family-descent-data-sequential-colimit 𝒟P _
+    qn : {n : ℕ} (b : Bn n) → Qn b → Qn (bn b)
+    qn = map-family-descent-data-sequential-colimit 𝒟Q _
+
+    -- then, the maps over homs
+    f'∞n : {n : ℕ} (a : An n) → Pn a → Qn (fn a)
+    f'∞n a =
+      ( tr Q
+        ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
+          ( H)
+          ( _)
+          ( a))) ∘
+      ( f'∞)
+
+    -- then, the squares-over
+    f'∞n-square-over :
+      {n : ℕ} →
+      square-over {Q4 = Qn} (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _) Hn
+    f'∞n-square-over p = {!qn!}
+
+    thm :
+      (sA : section-dependent-sequential-diagram A 𝒫) →
+      (sB : section-dependent-sequential-diagram B 𝒬) →
+      (S : (n : ℕ) →
+        section-map-over (fn {n}) (f'∞n _)
+          ( map-section-dependent-sequential-diagram A 𝒫 sA n)
+          ( map-section-dependent-sequential-diagram B 𝒬 sB n)) →
+      ((n : ℕ) →
+        section-square-over (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _)
+          ( map-section-dependent-sequential-diagram A 𝒫 sA n)
+          ( map-section-dependent-sequential-diagram B 𝒬 sB n)
+          ( map-section-dependent-sequential-diagram A 𝒫 sA (succ-ℕ n))
+          ( map-section-dependent-sequential-diagram B 𝒬 sB (succ-ℕ n))
+          ( naturality-map-section-dependent-sequential-diagram A 𝒫 sA n)
+          ( S n)
+          ( S (succ-ℕ n))
+          ( naturality-map-section-dependent-sequential-diagram B 𝒬 sB n)
+          ( Hn)
+          ( f'∞n-square-over)) →
+      section-map-over f∞ f'∞
+        ( sect-family-sect-dd-sequential-colimit up-c P sA)
+        ( sect-family-sect-dd-sequential-colimit up-c' Q sB)
+    thm sA sB S α =
+      map-dependent-universal-property-sequential-colimit
+        ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+        ( ( λ n a →
+            ap f'∞
+              ( pr1
+                ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+                  ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+                  ( sA)) n a) ∙
+            map-equiv
+              ( inv-equiv-ap-emb (emb-equiv (equiv-tr Q (Cn n a))))
+              ( S n a ∙
+                inv
+                  ( apd sB∞ (Cn n a) ∙
+                    pr1
+                      ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+                        ( dependent-universal-property-universal-property-sequential-colimit _ up-c')
+                        ( sB)) n (fn a)))) ,
+          {!!})
+      where
+        sA∞ : (x : X) → P x
+        sA∞ = sect-family-sect-dd-sequential-colimit up-c P sA
+        sB∞ : (y : Y) → Q y
+        sB∞ = sect-family-sect-dd-sequential-colimit up-c' Q sB
+```
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index 4f53e6bfd7..cbcdc8980b 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -1,7 +1,7 @@
 # The zigzag construction of identity types of pushouts
 
 ```agda
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
 
 module synthetic-homotopy-theory.zigzag-construction-identity-type-pushouts where
 ```
@@ -52,6 +52,7 @@ open import synthetic-homotopy-theory.sections-descent-data-pushouts
 open import synthetic-homotopy-theory.universal-property-pushouts
 open import synthetic-homotopy-theory.zigzags-sequential-diagrams
 
+open import synthetic-homotopy-theory.functoriality-stuff
 open import synthetic-homotopy-theory.stuff-over
 ```
 
@@ -1114,6 +1115,31 @@ module _
        ∙ apd (vertices.sBn s) (sides.bottom s n)
     KS-in-diagram = cube.cube
 
+    alt-ind-coherence :
+      (s : spanning-type-span-diagram 𝒮)
+      (p : left-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s)) →
+      {!!}
+      -- map-family-descent-data-pushout R _ (pr1 ind-singleton-zigzag-id-pushout' (left-map-span-diagram 𝒮 s , p)) ＝
+      -- pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p)
+    alt-ind-coherence s p =
+      big-thm.thm
+        ( up-standard-sequential-colimit)
+        ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+        ( hom-diagram-zigzag-sequential-diagram
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+        ( ev-pair
+          ( left-family-descent-data-pushout R)
+          ( left-map-span-diagram 𝒮 s))
+        ( ev-pair
+          ( right-family-descent-data-pushout R)
+          ( right-map-span-diagram 𝒮 s))
+        ( λ {p} → map-family-descent-data-pushout R (s , p))
+        ( {!!})
+        ( {!!})
+        ( {!!})
+        ( {!!})
+        ( p)
+
   is-identity-system-zigzag-id-pushout :
     is-identity-system-descent-data-pushout
       ( descent-data-zigzag-id-pushout 𝒮 a₀)

From f50bfb6d9cc65ed67972853a285dcdcf2a47c16b Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Mon, 27 Jan 2025 17:57:51 +0100
Subject: [PATCH 17/33] Very minute progress

---
 src/synthetic-homotopy-theory.lagda.md        |   4 +
 ...cocones-under-sequential-diagrams.lagda.md |  89 +++
 ...rsal-property-sequential-colimits.lagda.md |  59 +-
 ...cent-property-sequential-colimits.lagda.md |   3 +-
 ...ttening-lemma-sequential-colimits.lagda.md |   1 -
 ...functoriality-sequential-colimits.lagda.md |   2 +-
 .../functoriality-stuff.lagda.md              | 562 +++++++++++++++++-
 .../stuff-over.lagda.md                       |  11 +-
 ...nstruction-identity-type-pushouts.lagda.md | 125 ++--
 9 files changed, 738 insertions(+), 118 deletions(-)

diff --git a/src/synthetic-homotopy-theory.lagda.md b/src/synthetic-homotopy-theory.lagda.md
index f05ba2976d..52b42811e2 100644
--- a/src/synthetic-homotopy-theory.lagda.md
+++ b/src/synthetic-homotopy-theory.lagda.md
@@ -51,6 +51,7 @@ open import synthetic-homotopy-theory.descent-circle-function-types public
 open import synthetic-homotopy-theory.descent-circle-subtypes public
 open import synthetic-homotopy-theory.descent-data-equivalence-types-over-pushouts public
 open import synthetic-homotopy-theory.descent-data-function-types-over-pushouts public
+open import synthetic-homotopy-theory.descent-data-function-types-over-sequential-colimits public
 open import synthetic-homotopy-theory.descent-data-identity-types-over-pushouts public
 open import synthetic-homotopy-theory.descent-data-pushouts public
 open import synthetic-homotopy-theory.descent-data-sequential-colimits public
@@ -72,6 +73,7 @@ open import synthetic-homotopy-theory.flattening-lemma-sequential-colimits publi
 open import synthetic-homotopy-theory.free-loops public
 open import synthetic-homotopy-theory.functoriality-loop-spaces public
 open import synthetic-homotopy-theory.functoriality-sequential-colimits public
+open import synthetic-homotopy-theory.functoriality-stuff public
 open import synthetic-homotopy-theory.functoriality-suspensions public
 open import synthetic-homotopy-theory.groups-of-loops-in-1-types public
 open import synthetic-homotopy-theory.hatchers-acyclic-type public
@@ -120,6 +122,7 @@ open import synthetic-homotopy-theory.smash-products-of-pointed-types public
 open import synthetic-homotopy-theory.spectra public
 open import synthetic-homotopy-theory.sphere-prespectrum public
 open import synthetic-homotopy-theory.spheres public
+open import synthetic-homotopy-theory.stuff-over public
 open import synthetic-homotopy-theory.suspension-prespectra public
 open import synthetic-homotopy-theory.suspension-structures public
 open import synthetic-homotopy-theory.suspensions-of-pointed-types public
@@ -139,5 +142,6 @@ open import synthetic-homotopy-theory.universal-property-sequential-colimits pub
 open import synthetic-homotopy-theory.universal-property-suspensions public
 open import synthetic-homotopy-theory.universal-property-suspensions-of-pointed-types public
 open import synthetic-homotopy-theory.wedges-of-pointed-types public
+open import synthetic-homotopy-theory.zigzag-construction-identity-type-pushouts public
 open import synthetic-homotopy-theory.zigzags-sequential-diagrams public
 ```
diff --git a/src/synthetic-homotopy-theory/cocones-under-sequential-diagrams.lagda.md b/src/synthetic-homotopy-theory/cocones-under-sequential-diagrams.lagda.md
index ca4adb47b0..c9bcd3532d 100644
--- a/src/synthetic-homotopy-theory/cocones-under-sequential-diagrams.lagda.md
+++ b/src/synthetic-homotopy-theory/cocones-under-sequential-diagrams.lagda.md
@@ -24,6 +24,7 @@ open import foundation.torsorial-type-families
 open import foundation.transport-along-identifications
 open import foundation.universe-levels
 open import foundation.whiskering-homotopies-composition
+open import foundation.whiskering-homotopies-concatenation
 
 open import synthetic-homotopy-theory.dependent-sequential-diagrams
 open import synthetic-homotopy-theory.equifibered-sequential-diagrams
@@ -208,6 +209,40 @@ module _
       ( coherence-htpy-htpy-cocone-sequential-diagram K n)
 ```
 
+### Homotopies of homotopies of cocones under a sequential diagram
+
+```agda
+module _
+  {l1 l2 : Level} {A : sequential-diagram l1} {X : UU l2}
+  {c c' : cocone-sequential-diagram A X}
+  (H H' : htpy-cocone-sequential-diagram c c')
+  where
+
+  coherence-htpy²-cocone-sequential-diagram :
+    ((n : ℕ) →
+      htpy-htpy-cocone-sequential-diagram H n ~
+      htpy-htpy-cocone-sequential-diagram H' n) →
+    UU (l1 ⊔ l2)
+  coherence-htpy²-cocone-sequential-diagram α =
+    (n : ℕ) →
+      coherence-square-homotopies
+        ( left-whisker-concat-htpy
+          ( coherence-cocone-sequential-diagram c n)
+          ( α (succ-ℕ n) ·r map-sequential-diagram A n))
+        ( coherence-htpy-htpy-cocone-sequential-diagram H n)
+        ( coherence-htpy-htpy-cocone-sequential-diagram H' n)
+        ( right-whisker-concat-htpy
+          ( α n)
+          ( coherence-cocone-sequential-diagram c' n))
+
+  htpy²-cocone-sequential-diagram : UU (l1 ⊔ l2)
+  htpy²-cocone-sequential-diagram =
+    Σ ( (n : ℕ) →
+        htpy-htpy-cocone-sequential-diagram H n ~
+        htpy-htpy-cocone-sequential-diagram H' n)
+      ( coherence-htpy²-cocone-sequential-diagram)
+```
+
 ### Postcomposing cocones under a sequential diagram with a map
 
 Given a cocone `c` with vertex `X` under `(A, a)` and a map `f : X → Y`, we may
@@ -355,6 +390,60 @@ module _
     map-inv-equiv (extensionality-cocone-sequential-diagram c')
 ```
 
+### Characterization of identity types of homotopies of cocones under sequential diagrams
+
+```agda
+module _
+  {l1 l2 : Level} {A : sequential-diagram l1} {X : UU l2}
+  {c c' : cocone-sequential-diagram A X}
+  (H : htpy-cocone-sequential-diagram c c')
+  where
+
+  refl-htpy²-cocone-sequential-diagram :
+    htpy²-cocone-sequential-diagram H H
+  pr1 refl-htpy²-cocone-sequential-diagram n = refl-htpy
+  pr2 refl-htpy²-cocone-sequential-diagram n = right-unit-htpy
+
+  htpy²-eq-cocone-sequential-diagram :
+    (H' : htpy-cocone-sequential-diagram c c') →
+    (H ＝ H') → htpy²-cocone-sequential-diagram H H'
+  htpy²-eq-cocone-sequential-diagram .H refl =
+    refl-htpy²-cocone-sequential-diagram
+
+  abstract
+    is-torsorial-htpy²-cocone-sequential-diagram :
+      is-torsorial (htpy²-cocone-sequential-diagram H)
+    is-torsorial-htpy²-cocone-sequential-diagram =
+      is-torsorial-Eq-structure
+        ( is-torsorial-binary-htpy (htpy-htpy-cocone-sequential-diagram H))
+        ( htpy-htpy-cocone-sequential-diagram H , refl-binary-htpy _)
+        ( is-torsorial-binary-htpy
+          ( λ n →
+            coherence-htpy-htpy-cocone-sequential-diagram H n ∙h refl-htpy))
+
+    is-equiv-htpy²-eq-cocone-sequential-diagram :
+      (H' : htpy-cocone-sequential-diagram c c') →
+      is-equiv (htpy²-eq-cocone-sequential-diagram H')
+    is-equiv-htpy²-eq-cocone-sequential-diagram =
+      fundamental-theorem-id
+        ( is-torsorial-htpy²-cocone-sequential-diagram)
+        ( htpy²-eq-cocone-sequential-diagram)
+
+  extensionality-htpy-eq-cocone-sequential-diagram :
+    (H' : htpy-cocone-sequential-diagram c c') →
+    (H ＝ H') ≃ htpy²-cocone-sequential-diagram H H'
+  pr1 (extensionality-htpy-eq-cocone-sequential-diagram H') =
+    htpy²-eq-cocone-sequential-diagram H'
+  pr2 (extensionality-htpy-eq-cocone-sequential-diagram H') =
+    is-equiv-htpy²-eq-cocone-sequential-diagram H'
+
+  eq-htpy²-cocone-sequential-diagram :
+    (H' : htpy-cocone-sequential-diagram c c') →
+    htpy²-cocone-sequential-diagram H H' → H ＝ H'
+  eq-htpy²-cocone-sequential-diagram H' =
+    map-inv-equiv (extensionality-htpy-eq-cocone-sequential-diagram H')
+```
+
 ### Postcomposing a cocone under a sequential diagram by identity is the identity
 
 ```agda
diff --git a/src/synthetic-homotopy-theory/dependent-universal-property-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/dependent-universal-property-sequential-colimits.lagda.md
index 449c744b8e..e2607d3474 100644
--- a/src/synthetic-homotopy-theory/dependent-universal-property-sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/dependent-universal-property-sequential-colimits.lagda.md
@@ -196,35 +196,36 @@ module _
   ( c : cocone-sequential-diagram A X)
   where
 
-  universal-property-dependent-universal-property-sequential-colimit :
-    dependent-universal-property-sequential-colimit c →
-    universal-property-sequential-colimit c
-  universal-property-dependent-universal-property-sequential-colimit
-    ( dup-c)
-    ( Y) =
-    is-equiv-left-map-triangle
-      ( cocone-map-sequential-diagram c)
-      ( map-compute-dependent-cocone-sequential-diagram-constant-family Y)
-      ( dependent-cocone-map-sequential-diagram c (λ _ → Y))
-      ( triangle-compute-dependent-cocone-sequential-diagram-constant-family
-        ( Y))
-      ( dup-c (λ _ → Y))
-      ( is-equiv-map-equiv
-        ( compute-dependent-cocone-sequential-diagram-constant-family Y))
-
-  dependent-universal-property-universal-property-sequential-colimit :
-    universal-property-sequential-colimit c →
-    dependent-universal-property-sequential-colimit c
-  dependent-universal-property-universal-property-sequential-colimit
-    ( up-sequential-diagram) =
-    dependent-universal-property-sequential-colimit-dependent-universal-property-coequalizer
-      ( c)
-      ( dependent-universal-property-universal-property-coequalizer
-        ( double-arrow-sequential-diagram A)
-        ( cofork-cocone-sequential-diagram c)
-        ( universal-property-coequalizer-universal-property-sequential-colimit
-          ( c)
-          ( up-sequential-diagram)))
+  abstract
+    universal-property-dependent-universal-property-sequential-colimit :
+      dependent-universal-property-sequential-colimit c →
+      universal-property-sequential-colimit c
+    universal-property-dependent-universal-property-sequential-colimit
+      ( dup-c)
+      ( Y) =
+      is-equiv-left-map-triangle
+        ( cocone-map-sequential-diagram c)
+        ( map-compute-dependent-cocone-sequential-diagram-constant-family Y)
+        ( dependent-cocone-map-sequential-diagram c (λ _ → Y))
+        ( triangle-compute-dependent-cocone-sequential-diagram-constant-family
+          ( Y))
+        ( dup-c (λ _ → Y))
+        ( is-equiv-map-equiv
+          ( compute-dependent-cocone-sequential-diagram-constant-family Y))
+
+    dependent-universal-property-universal-property-sequential-colimit :
+      universal-property-sequential-colimit c →
+      dependent-universal-property-sequential-colimit c
+    dependent-universal-property-universal-property-sequential-colimit
+      ( up-sequential-diagram) =
+      dependent-universal-property-sequential-colimit-dependent-universal-property-coequalizer
+        ( c)
+        ( dependent-universal-property-universal-property-coequalizer
+          ( double-arrow-sequential-diagram A)
+          ( cofork-cocone-sequential-diagram c)
+          ( universal-property-coequalizer-universal-property-sequential-colimit
+            ( c)
+            ( up-sequential-diagram)))
 ```
 
 ### The 3-for-2 property of the dependent universal property of sequential colimits
diff --git a/src/synthetic-homotopy-theory/descent-property-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/descent-property-sequential-colimits.lagda.md
index e41aa18fa6..c36ea4cad1 100644
--- a/src/synthetic-homotopy-theory/descent-property-sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/descent-property-sequential-colimits.lagda.md
@@ -158,7 +158,8 @@ module _
     {x y : A} (p : x ＝ y) (q : f x ＝ f y) (α : ap f p ＝ q) →
     (z : P x) →
     tr Q q (h x z) ＝ h y (tr P p z)
-  other-nat-lemma p q α z = inv (preserves-tr h p z ∙ (inv (substitution-law-tr Q f p) ∙ tr² Q α _))
+  other-nat-lemma p q α z =
+    inv (preserves-tr h p z ∙ (inv (substitution-law-tr Q f p) ∙ tr² Q α _))
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
   {A : sequential-diagram l1} {B : sequential-diagram l2}
diff --git a/src/synthetic-homotopy-theory/flattening-lemma-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/flattening-lemma-sequential-colimits.lagda.md
index 1e014f974d..316040ccfa 100644
--- a/src/synthetic-homotopy-theory/flattening-lemma-sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/flattening-lemma-sequential-colimits.lagda.md
@@ -21,7 +21,6 @@ open import foundation.whiskering-homotopies-composition
 open import synthetic-homotopy-theory.cocones-under-sequential-diagrams
 open import synthetic-homotopy-theory.coforks
 open import synthetic-homotopy-theory.coforks-cocones-under-sequential-diagrams
-open import synthetic-homotopy-theory.dependent-universal-property-sequential-colimits
 open import synthetic-homotopy-theory.equivalences-coforks-under-equivalences-double-arrows
 open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
 open import synthetic-homotopy-theory.flattening-lemma-coequalizers
diff --git a/src/synthetic-homotopy-theory/functoriality-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/functoriality-sequential-colimits.lagda.md
index e978bc0554..1279c6f21d 100644
--- a/src/synthetic-homotopy-theory/functoriality-sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-sequential-colimits.lagda.md
@@ -125,7 +125,7 @@ This homotopy of cocones provides
     Aₙ ---------> X
     |      |      |
     |      ∨      |
- fₙ |     Bₙ₊₁    | g
+ fₙ |     Bₙ₊₁    | f∞
     |    ∧   \    |
     |  /       \  |
     ∨/           ∨∨
diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index f3bb11a0e5..37d0bbeb1a 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -13,22 +13,29 @@ open import elementary-number-theory.natural-numbers
 
 open import foundation.action-on-identifications-dependent-functions
 open import foundation.action-on-identifications-functions
--- open import foundation.commuting-squares-of-maps
--- open import foundation.commuting-triangles-of-maps
+-- open import foundation.binary-homotopies
+open import foundation.commuting-squares-of-maps
+open import foundation.commuting-triangles-of-maps
 -- open import foundation.dependent-identifications
 open import foundation.dependent-pair-types
 open import foundation.embeddings
+open import foundation.equality-dependent-pair-types
 open import foundation.equivalences
--- open import foundation.function-extensionality
+open import foundation.function-extensionality
 open import foundation.function-types
--- open import foundation.functoriality-dependent-function-types
+open import foundation.functoriality-dependent-function-types
+open import foundation.functoriality-dependent-pair-types
 open import foundation.homotopies
 -- open import foundation.homotopy-induction
 open import foundation.identity-types
+open import foundation.implicit-function-types
+open import foundation.postcomposition-functions
+open import foundation.precomposition-dependent-functions
 open import foundation.transport-along-identifications
 -- open import foundation.transposition-identifications-along-equivalences
+open import foundation.universal-property-equivalences
 open import foundation.universe-levels
--- open import foundation.whiskering-homotopies-composition
+open import foundation.whiskering-homotopies-composition
 -- open import foundation.whiskering-homotopies-concatenation
 
 open import synthetic-homotopy-theory.cocones-under-sequential-diagrams
@@ -42,8 +49,255 @@ open import synthetic-homotopy-theory.stuff-over
 open import synthetic-homotopy-theory.universal-property-sequential-colimits
 ```
 
+</details>
+
 ## Theorem
 
+New idea: instead of bruteforcing this direction, show that a square induces
+coherent cubes, and show that it's an equivalence because it fits in a diagram.
+
+```agda
+nat-lemma :
+  {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
+  {P : A → UU l3} {Q : B → UU l4}
+  (f : A → B) (h : (a : A) → P a → Q (f a))
+  {x y : A} {p : x ＝ y}
+  {q : f x ＝ f y} (α : ap f p ＝ q) →
+  coherence-square-maps
+    ( tr P p)
+    ( h x)
+    ( h y)
+    ( tr Q q)
+nat-lemma f h {p = p} refl x =
+  substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
+```
+
+```agda
+open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
+open import synthetic-homotopy-theory.total-cocones-families-sequential-diagrams
+open import synthetic-homotopy-theory.total-sequential-diagrams
+
+open import foundation.action-on-identifications-functions
+open import foundation.commuting-squares-of-identifications
+open import foundation.functoriality-dependent-pair-types
+open import foundation.equality-dependent-pair-types
+open import foundation.identity-types
+open import synthetic-homotopy-theory.sequential-colimits
+open import synthetic-homotopy-theory.functoriality-sequential-colimits
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : sequential-diagram l1}
+  {X : UU l2} {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  (P : family-with-descent-data-sequential-colimit c l3)
+  {Y : UU l4}
+  {c' :
+    cocone-sequential-diagram
+      ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
+      ( Y)}
+  (up-c' : universal-property-sequential-colimit c')
+  where
+
+  mediating-cocone :
+    cocone-sequential-diagram
+      ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
+      ( Σ X (family-cocone-family-with-descent-data-sequential-colimit P))
+  pr1 mediating-cocone n =
+    map-Σ
+      ( family-cocone-family-with-descent-data-sequential-colimit P)
+      ( map-cocone-sequential-diagram c n)
+      ( λ a → map-equiv-descent-data-family-with-descent-data-sequential-colimit P n a)
+  pr2 mediating-cocone n (a , p) =
+    eq-pair-Σ
+      ( coherence-cocone-sequential-diagram c n a)
+      ( inv
+        ( coherence-square-equiv-descent-data-family-with-descent-data-sequential-colimit P n a p))
+
+  totι' : Y → Σ X (family-cocone-family-with-descent-data-sequential-colimit P)
+  totι' =
+    map-universal-property-sequential-colimit up-c' mediating-cocone
+  triangle-pr1∞-pr1 :
+    pr1-sequential-colimit-total-sequential-diagram
+      ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)
+      ( up-c')
+      ( c) ~
+    pr1 ∘ totι'
+  triangle-pr1∞-pr1 =
+    htpy-htpy-out-of-sequential-colimit up-c'
+      ( concat-htpy-cocone-sequential-diagram
+        ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c' c
+          ( pr1-total-sequential-diagram
+            ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)))
+        ( ( λ n →
+            inv-htpy (pr1 ·l (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n))) ,
+          ( λ n x →
+            ap (_∙ inv (ap pr1 (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))) right-unit ∙
+            horizontal-inv-coherence-square-identifications _
+              ( ap (pr1 ∘ totι') (coherence-cocone-sequential-diagram c' n x))
+              ( coherence-cocone-sequential-diagram c n (pr1 x))
+              _
+              ( ( ap
+                  ( _∙ ap pr1
+                    ( pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))
+                  ( ap-comp pr1
+                    ( totι')
+                    ( coherence-cocone-sequential-diagram c' n x))) ∙
+                ( inv
+                  ( ap-concat pr1
+                    ( ap
+                      ( totι')
+                      ( coherence-cocone-sequential-diagram c' n x)) _)) ∙
+                ( ap (ap pr1) (pr2 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n x)) ∙
+                ( ap-concat pr1
+                  ( pr1
+                    ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
+                    n x)
+                  ( coherence-cocone-sequential-diagram mediating-cocone n x)) ∙
+                ( ap
+                  ( ap pr1
+                    ( pr1
+                      ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
+                      n x) ∙_)
+                  ( ap-pr1-eq-pair-Σ
+                    ( coherence-cocone-sequential-diagram c n (pr1 x))
+                    ( _)))))))
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (P : X → UU l5) (Q : Y → UU l6)
+  (f : hom-sequential-diagram A B)
+  (f' :
+    (x : X) → P x →
+    Q (map-sequential-colimit-hom-sequential-diagram up-c c' f x))
+  where
+
+  open import synthetic-homotopy-theory.flattening-lemma-sequential-colimits
+
+  ΣAP : sequential-diagram (l1 ⊔ l5)
+  ΣAP =
+    total-sequential-diagram (dependent-sequential-diagram-family-cocone c P)
+
+  ΣBQ : sequential-diagram (l3 ⊔ l6)
+  ΣBQ =
+    total-sequential-diagram (dependent-sequential-diagram-family-cocone c' Q)
+
+  totff' : hom-sequential-diagram ΣAP ΣBQ
+  pr1 totff' n =
+    map-Σ _
+      ( map-hom-sequential-diagram B f n)
+      ( λ a →
+        tr Q
+          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+            up-c c' f n a) ∘
+        f' (map-cocone-sequential-diagram c n a))
+  pr2 totff' = {!!}
+
+  totff'∞ : Σ X P → Σ Y Q
+  totff'∞ =
+    map-sequential-colimit-hom-sequential-diagram
+      ( flattening-lemma-sequential-colimit _ P up-c)
+      ( total-cocone-family-cocone-sequential-diagram c' Q)
+      ( totff')
+
+  _ :
+    totι' up-c
+      ( family-with-descent-data-family-cocone-sequential-diagram c P)
+      ( flattening-lemma-sequential-colimit c P up-c) ~
+    id
+  _ =
+    compute-map-universal-property-sequential-colimit-id
+      ( flattening-lemma-sequential-colimit _ P up-c)
+
+  _ :
+    coherence-square-maps
+      ( totι' up-c
+        ( family-with-descent-data-family-cocone-sequential-diagram c P)
+        ( flattening-lemma-sequential-colimit c P up-c))
+      ( totff'∞)
+      ( map-Σ Q
+        ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+        f')
+      ( totι' up-c'
+        ( family-with-descent-data-family-cocone-sequential-diagram c' Q)
+        ( flattening-lemma-sequential-colimit c' Q up-c'))
+  _ =
+    ( compute-map-universal-property-sequential-colimit-id
+      ( flattening-lemma-sequential-colimit c' Q up-c') ·r _) ∙h
+    ( htpy-htpy-out-of-sequential-colimit
+      ( flattening-lemma-sequential-colimit c P up-c)
+      ( concat-htpy-cocone-sequential-diagram
+        ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+          ( flattening-lemma-sequential-colimit c P up-c)
+          ( total-cocone-family-cocone-sequential-diagram c' Q)
+          ( totff'))
+        ( ( λ n (a , p) →
+            inv
+              ( eq-pair-Σ
+                ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
+                  ( f)
+                  ( n)
+                  ( a))
+                refl)) ,
+          {!!}))) ∙h
+    ( _ ·l
+      ( inv-htpy
+        (compute-map-universal-property-sequential-colimit-id
+          ( flattening-lemma-sequential-colimit c P up-c))))
+
+    -- htpy-htpy-out-of-sequential-colimit
+    --   ( flattening-lemma-sequential-colimit c P up-c)
+    --   ( {!!})
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (f : hom-sequential-diagram A B)
+  where
+  open import foundation.homotopies-morphisms-arrows
+
+  interm :
+    coherence-square-maps
+      ( id)
+      ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+      ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+      ( id)
+  interm =
+    htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-c c'
+      ( refl-htpy-hom-sequential-diagram A B f)
+
+  preserves-refl-htpy-sequential-colimit :
+    htpy-hom-arrow
+      ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+      ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+      ( id , id , interm)
+      ( id , id , refl-htpy)
+  pr1 preserves-refl-htpy-sequential-colimit = refl-htpy
+  pr1 (pr2 preserves-refl-htpy-sequential-colimit) = refl-htpy
+  pr2 (pr2 preserves-refl-htpy-sequential-colimit) =
+    right-unit-htpy ∙h
+    htpy-eq
+      ( ap
+        ( htpy-eq ∘ ap (map-sequential-colimit-hom-sequential-diagram up-c c'))
+        ( is-retraction-map-inv-equiv
+          ( extensionality-hom-sequential-diagram A B f f)
+          ( refl)))
+```
+
 ```agda
 module _
   {l1 l2 : Level}
@@ -78,6 +332,218 @@ module _
       ( s)
 ```
 
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : sequential-diagram l1}
+  (B : sequential-diagram l2)
+  (f : hom-sequential-diagram A B)
+  (P : descent-data-sequential-colimit A l3)
+  (Q : descent-data-sequential-colimit B l4)
+  where
+
+  hom-over-hom : UU (l1 ⊔ l3 ⊔ l4)
+  hom-over-hom =
+    Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
+        family-descent-data-sequential-colimit P n a →
+        family-descent-data-sequential-colimit Q n
+          ( map-hom-sequential-diagram B f n a))
+      ( λ f'n →
+        (n : ℕ) →
+        square-over
+          { Q4 = family-descent-data-sequential-colimit Q (succ-ℕ n)}
+          ( map-sequential-diagram A n)
+          ( map-hom-sequential-diagram B f n)
+          ( map-hom-sequential-diagram B f (succ-ℕ n))
+          ( map-sequential-diagram B n)
+          ( λ {a} → map-family-descent-data-sequential-colimit P n a)
+          ( λ {a} → f'n n a)
+          ( λ {a} → f'n (succ-ℕ n) a)
+          ( λ {a} → map-family-descent-data-sequential-colimit Q n a)
+          ( naturality-map-hom-sequential-diagram B f n))
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (f : hom-sequential-diagram A B)
+  (P : X → UU l5) (Q : Y → UU l6)
+  where
+
+  private
+    f∞ : X → Y
+    f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f
+    DDMO : descent-data-sequential-colimit A (l5 ⊔ l6)
+    pr1 DDMO n a =
+      P (map-cocone-sequential-diagram c n a) →
+      Q (map-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+    pr2 DDMO n a =
+      ( equiv-postcomp _
+        ( ( equiv-tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘e
+          ( equiv-tr Q (coherence-cocone-sequential-diagram c' n _)))) ∘e
+      ( equiv-precomp
+        ( inv-equiv (equiv-tr P (coherence-cocone-sequential-diagram c n a)))
+        ( _))
+
+  sect-over-DDMO-map-over :
+    ((a : X) → P a → Q (f∞ a)) →
+    section-descent-data-sequential-colimit DDMO
+  pr1 (sect-over-DDMO-map-over f∞') n a =
+    ( tr Q
+      ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
+    ( f∞' (map-cocone-sequential-diagram c n a))
+  pr2 (sect-over-DDMO-map-over f∞') n a =
+    eq-htpy
+      ( λ p →
+        {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a!})
+
+  sect-over-DDMO-map-over' :
+    ((a : X) → P a → Q (f∞ a)) →
+    section-descent-data-sequential-colimit DDMO
+  sect-over-DDMO-map-over' =
+    {!sect-family-sect-dd-sequential-colimit!}
+
+  map-over-sect-DDMO :
+    section-descent-data-sequential-colimit DDMO →
+    hom-over-hom B f
+      ( descent-data-family-cocone-sequential-diagram c P)
+      ( descent-data-family-cocone-sequential-diagram c' Q)
+  map-over-sect-DDMO =
+    tot
+      ( λ s →
+        map-Π
+          ( λ n →
+            ( map-implicit-Π
+              ( λ a →
+                ( concat-htpy
+                  ( inv-htpy
+                    ( ( ( tr
+                          ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+                          ( naturality-map-hom-sequential-diagram B f n a)) ∘
+                        ( tr Q
+                          ( coherence-cocone-sequential-diagram c' n
+                            (map-hom-sequential-diagram B f n a))) ∘
+                        ( s n a)) ·l
+                      ( is-retraction-inv-tr P
+                        ( coherence-cocone-sequential-diagram c n a))))
+                  ( _)) ∘
+                ( map-equiv
+                  ( equiv-htpy-precomp-htpy-Π _ _
+                    ( equiv-tr P
+                      ( coherence-cocone-sequential-diagram c n a)))) ∘
+                ( htpy-eq
+                  {f =
+                    ( tr
+                      ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+                      ( naturality-map-hom-sequential-diagram B f n a)) ∘
+                    ( tr Q
+                      ( coherence-cocone-sequential-diagram c' n
+                        ( map-hom-sequential-diagram B f n a))) ∘
+                    ( s n a) ∘
+                    ( tr P (inv (coherence-cocone-sequential-diagram c n a)))}
+                  { s (succ-ℕ n) (map-sequential-diagram A n a)}))) ∘
+            ( implicit-explicit-Π)))
+
+  map-over-diagram-map-over-colimit :
+    ((a : X) → P a → Q (f∞ a)) →
+    hom-over-hom B f
+      ( descent-data-family-cocone-sequential-diagram c P)
+      ( descent-data-family-cocone-sequential-diagram c' Q)
+  pr1 (map-over-diagram-map-over-colimit f∞') n a =
+    ( tr Q
+      ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
+    ( f∞' (map-cocone-sequential-diagram c n a))
+  pr2 (map-over-diagram-map-over-colimit f∞') n {a} =
+    pasting-vertical-coherence-square-maps
+      ( tr P (coherence-cocone-sequential-diagram c n a))
+      ( f∞' _)
+      ( f∞' _)
+      ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
+      ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
+      ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
+      ( ( tr
+          ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B f n a)) ∘
+        ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
+      ( λ q →
+        substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
+        inv (preserves-tr f∞' (coherence-cocone-sequential-diagram c n a) q))
+      ( ( inv-htpy
+          ( λ q →
+            ( tr-concat
+              ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+                up-c c' f n a)
+              ( _)
+              ( q)) ∙
+            ( tr-concat
+              ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+              ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
+              ( tr Q
+                ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+                  up-c c' f n a)
+                ( q))) ∙
+            ( substitution-law-tr Q
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
+        ( λ q →
+          ap
+            ( λ p → tr Q p q)
+            ( inv
+              ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
+        ( tr-concat
+          ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+            up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))
+
+  abstract
+    triangle-map-over-sect-DDMO :
+      coherence-triangle-maps
+        ( map-over-diagram-map-over-colimit)
+        ( map-over-sect-DDMO)
+        ( sect-over-DDMO-map-over)
+    triangle-map-over-sect-DDMO f∞' =
+      eq-pair-eq-fiber
+        ( eq-htpy
+          ( λ n →
+            eq-htpy-implicit
+              ( λ a →
+                eq-htpy
+                  ( λ p →
+                    {!!}))))
+
+    is-equiv-map-over-sect-DDMO :
+      is-equiv map-over-sect-DDMO
+    is-equiv-map-over-sect-DDMO =
+      is-equiv-tot-is-fiberwise-equiv
+        ( λ s →
+          is-equiv-map-Π-is-fiberwise-equiv
+            ( λ n →
+              is-equiv-comp _ _
+                ( is-equiv-implicit-explicit-Π)
+                ( is-equiv-map-implicit-Π-is-fiberwise-equiv
+                  ( λ a →
+                    is-equiv-comp _ _
+                      ( funext _ _)
+                      ( is-equiv-comp _ _
+                        ( is-equiv-map-equiv (equiv-htpy-precomp-htpy-Π _ _ _))
+                        ( is-equiv-concat-htpy _ _))))))
+
+    is-equiv-map-over-diagram-map-over-colimit :
+      is-equiv map-over-diagram-map-over-colimit
+    is-equiv-map-over-diagram-map-over-colimit =
+      {!is-equiv-left-map-triangle
+        ( map-over-diagram-map-over-colimit)
+        ( map-over-sect-DDMO)
+        ( sect-over-DDMO-map-over)
+        ( triangle-map-over-sect-DDMO)
+        ( is-equiv) !}
+```
+
 ```agda
 module big-thm
   {l1 l2 l3 l4 l5 l6 : Level}
@@ -153,7 +619,47 @@ module big-thm
     f'∞n-square-over :
       {n : ℕ} →
       square-over {Q4 = Qn} (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _) Hn
-    f'∞n-square-over p = {!qn!}
+    f'∞n-square-over {n} {a} =
+      pasting-vertical-coherence-square-maps
+        ( tr P (coherence-cocone-sequential-diagram c n a))
+        ( f'∞)
+        ( f'∞)
+        ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
+        ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H _ a))
+        ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H _ (an a)))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( Hn a)) ∘
+          ( tr Q (coherence-cocone-sequential-diagram c' n (fn a))))
+        ( λ q →
+          substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
+          inv (preserves-tr (λ p → f'∞ {p}) (coherence-cocone-sequential-diagram c n a) q))
+        ( ( inv-htpy
+            ( λ q →
+              ( tr-concat
+                ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+                  up-c c' H n a)
+                ( _)
+                ( q)) ∙
+              ( tr-concat
+                ( coherence-cocone-sequential-diagram c' n (fn a))
+                ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (Hn a))
+                ( tr Q
+                  ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+                    up-c c' H n a)
+                  ( q))) ∙
+              ( substitution-law-tr Q
+                ( map-cocone-sequential-diagram c' (succ-ℕ n))
+                ( Hn a)))) ∙h
+          ( λ q →
+            ap
+              ( λ p → tr Q p q)
+              ( inv
+                ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H n a))) ∙h
+          ( tr-concat
+            ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+            ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+              up-c c' H (succ-ℕ n) (an a))))
 
     thm :
       (sA : section-dependent-sequential-diagram A 𝒫) →
@@ -180,25 +686,37 @@ module big-thm
     thm sA sB S α =
       map-dependent-universal-property-sequential-colimit
         ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
-        ( ( λ n a →
-            ap f'∞
-              ( pr1
-                ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
-                  ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
-                  ( sA)) n a) ∙
-            map-equiv
-              ( inv-equiv-ap-emb (emb-equiv (equiv-tr Q (Cn n a))))
-              ( S n a ∙
-                inv
-                  ( apd sB∞ (Cn n a) ∙
-                    pr1
-                      ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
-                        ( dependent-universal-property-universal-property-sequential-colimit _ up-c')
-                        ( sB)) n (fn a)))) ,
-          {!!})
+        ( tS ,
+          ( λ n a →
+            map-compute-dependent-identification-eq-value
+              ( f'∞ ∘ sA∞)
+              ( sB∞ ∘ f∞)
+              ( coherence-cocone-sequential-diagram c n a)
+              ( tS n a)
+              ( tS (succ-ℕ n) (an a))
+              ( {!f'∞n-square-over!})))
       where
         sA∞ : (x : X) → P x
         sA∞ = sect-family-sect-dd-sequential-colimit up-c P sA
         sB∞ : (y : Y) → Q y
         sB∞ = sect-family-sect-dd-sequential-colimit up-c' Q sB
+        tS :
+          (n : ℕ) →
+          (f'∞ ∘ sA∞ ∘ (map-cocone-sequential-diagram c n)) ~
+          (sB∞ ∘ f∞ ∘ map-cocone-sequential-diagram c n)
+        tS n a =
+          ap f'∞
+            ( pr1
+              ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+                ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+                ( sA)) n a) ∙
+          map-equiv
+            ( inv-equiv-ap-emb (emb-equiv (equiv-tr Q (Cn n a))))
+            ( S n a ∙
+              inv
+                ( apd sB∞ (Cn n a) ∙
+                  pr1
+                    ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+                      ( dependent-universal-property-universal-property-sequential-colimit _ up-c')
+                      ( sB)) n (fn a)))
 ```
diff --git a/src/synthetic-homotopy-theory/stuff-over.lagda.md b/src/synthetic-homotopy-theory/stuff-over.lagda.md
index 3e74048c0c..d8ea225f0e 100644
--- a/src/synthetic-homotopy-theory/stuff-over.lagda.md
+++ b/src/synthetic-homotopy-theory/stuff-over.lagda.md
@@ -40,7 +40,8 @@ module _
   where
 
   htpy-over : UU (l1 ⊔ l3 ⊔ l4)
-  htpy-over = {a : A} (a' : A' a) → dependent-identification B' (H a) (f' a') (g' a')
+  htpy-over =
+    {a : A} (a' : A' a) → dependent-identification B' (H a) (f' a') (g' a')
 
 module _
   {l1 l2 l3 l4 : Level}
@@ -162,7 +163,6 @@ module _
   comp-section-map-over G F =
     g' ·l F ∙h G ·r f
 
-
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
@@ -497,7 +497,6 @@ module _
     H' (sA a) ∙ G a ＝
     ap (tr X' (H a) ∘ m') (F a) ∙ ap (tr X' (H a)) (M (f a)) ∙ apd sX (H a)
 
-
   equiv-get-section-triangle-over' :
     (H : coherence-triangle-maps' g m f) →
     (H' : htpy-over X' H (m' ∘ f') g') →
@@ -657,8 +656,10 @@ module _
              ( assoc-comp-section-map-over f1' m' f2' s1 s2 s3 s4 F1 M F2)
              ( [iv])))
       where
-        [i] = unget-section-triangle-over m g2 f2 m' g2' f2' s2 s3 s4 M G2 F2 B2 T2 S2
+        [i] =
+          unget-section-triangle-over m g2 f2 m' g2' f2' s2 s3 s4 M G2 F2 B2 T2 S2
         [ii] = right-whisk-section-htpy-over B2 T2 s2 s4 _ _ [i] f1 f1' s1 F1
-        [iii] = unget-section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 S1
+        [iii] =
+          unget-section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 S1
         [iv] = left-whisk-section-htpy-over B1 T1 s1 s3 _ _ [iii] f2 f2' s4 F2
 ```
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index cbcdc8980b..9e95f96ff4 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -40,20 +40,19 @@ open import synthetic-homotopy-theory.dependent-cocones-under-sequential-diagram
 open import synthetic-homotopy-theory.dependent-cocones-under-spans
 open import synthetic-homotopy-theory.dependent-universal-property-sequential-colimits
 open import synthetic-homotopy-theory.descent-data-pushouts
-open import synthetic-homotopy-theory.functoriality-sequential-colimits
-open import synthetic-homotopy-theory.identity-systems-descent-data-pushouts
 open import synthetic-homotopy-theory.families-descent-data-pushouts
 open import synthetic-homotopy-theory.flattening-lemma-pushouts
+open import synthetic-homotopy-theory.functoriality-sequential-colimits
+open import synthetic-homotopy-theory.functoriality-stuff
+open import synthetic-homotopy-theory.identity-systems-descent-data-pushouts
 open import synthetic-homotopy-theory.pushouts
+open import synthetic-homotopy-theory.sections-descent-data-pushouts
 open import synthetic-homotopy-theory.sequential-colimits
 open import synthetic-homotopy-theory.sequential-diagrams
 open import synthetic-homotopy-theory.shifts-sequential-diagrams
-open import synthetic-homotopy-theory.sections-descent-data-pushouts
+open import synthetic-homotopy-theory.stuff-over
 open import synthetic-homotopy-theory.universal-property-pushouts
 open import synthetic-homotopy-theory.zigzags-sequential-diagrams
-
-open import synthetic-homotopy-theory.functoriality-stuff
-open import synthetic-homotopy-theory.stuff-over
 ```
 
 </details>
@@ -66,7 +65,6 @@ colimits of pushouts.
 ## Definitions
 
 ```agda
-
 module _
   {l1 l2 l3 : Level} (𝒮 : span-diagram l1 l2 l3)
   where
@@ -290,19 +288,6 @@ module _
 ### TODO
 
 ```agda
-nat-lemma :
-  {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
-  {P : A → UU l3} {Q : B → UU l4}
-  (f : A → B) (h : (a : A) → P a → Q (f a))
-  {x y : A} {p : x ＝ y}
-  {q : f x ＝ f y} (α : ap f p ＝ q) →
-  coherence-square-maps
-    ( tr P p)
-    ( h x)
-    ( h y)
-    ( tr Q q)
-nat-lemma f h {p = p} refl x = substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
-
 apd-lemma :
   {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
   (f : (a : A) → B a) (g : (a : A) → B a → C a) {x y : A} (p : x ＝ y) →
@@ -716,7 +701,6 @@ module _
               ( dep-cocone-b (right-map-span-diagram 𝒮 s))
               ( s , refl , p))))
 
-
     tB :
       (b : codomain-span-diagram 𝒮) (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
       right-family-descent-data-pushout R
@@ -724,6 +708,20 @@ module _
     tB b zero-ℕ (map-raise ())
     tB b (succ-ℕ n) = dependent-cogap _ _ (pr1 (stages-cocones' n) b)
 
+    KB :
+      (b : codomain-span-diagram 𝒮) (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
+      dependent-identification
+        ( ev-pair (right-family-descent-data-pushout R) b)
+        ( coherence-cocone-standard-sequential-colimit n p)
+        ( tB b n p)
+        ( tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
+    KB b zero-ℕ (map-raise ())
+    KB b (succ-ℕ n) p =
+      inv
+        ( compute-inl-dependent-cogap _ _
+          ( pr1 (stages-cocones' (succ-ℕ n)) b)
+          ( p))
+
     tA :
       (a : domain-span-diagram 𝒮) (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
       left-family-descent-data-pushout R
@@ -731,47 +729,34 @@ module _
     tA .a₀ zero-ℕ (map-raise refl) = r₀
     tA a (succ-ℕ n) = dependent-cogap _ _ (pr1 (pr2 (stages-cocones' n)) a)
 
-    ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
-    pr1 ind-singleton-zigzag-id-pushout' (a , p) =
-      dependent-cogap-standard-sequential-colimit
-        ( tA a , KA)
-        ( p)
-      where
-      KA :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
+    KA :
+      (a : domain-span-diagram 𝒮) (n : ℕ) (p : Path-to-a 𝒮 a₀ a n) →
         dependent-identification
           ( ev-pair (left-family-descent-data-pushout R) a)
           ( coherence-cocone-standard-sequential-colimit n p)
           ( tA a n p)
           ( tA a (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ a n p))
-      KA zero-ℕ (map-raise refl) =
-        inv
-          ( compute-inl-dependent-cogap _ _
-            ( pr1 (pr2 (stages-cocones' 0)) a)
-            ( map-raise refl))
-      KA (succ-ℕ n) p =
-        inv
-          ( compute-inl-dependent-cogap _ _
-            ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) a)
-            ( p))
+    KA a zero-ℕ (map-raise refl) =
+      inv
+        ( compute-inl-dependent-cogap _ _
+          ( pr1 (pr2 (stages-cocones' 0)) a)
+          ( map-raise refl))
+    KA a (succ-ℕ n) p =
+      inv
+        ( compute-inl-dependent-cogap _ _
+          ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) a)
+          ( p))
+
+    ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
+    pr1 ind-singleton-zigzag-id-pushout' (a , p) =
+      dependent-cogap-standard-sequential-colimit
+        ( tA a , KA a)
+        ( p)
     pr1 (pr2 ind-singleton-zigzag-id-pushout') (b , p) =
       dependent-cogap-standard-sequential-colimit
-        ( tB b , KB)
+        ( tB b , KB b)
         ( p)
       where
-      KB :
-        (n : ℕ) (p : Path-to-b 𝒮 a₀ b n) →
-        dependent-identification
-          ( ev-pair (right-family-descent-data-pushout R) b)
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tB b n p)
-          ( tB b (succ-ℕ n) (inl-Path-to-b 𝒮 a₀ b n p))
-      KB zero-ℕ (map-raise ())
-      KB (succ-ℕ n) p =
-        inv
-          ( compute-inl-dependent-cogap _ _
-            ( pr1 (stages-cocones' (succ-ℕ n)) b)
-            ( p))
     pr2 (pr2 ind-singleton-zigzag-id-pushout') (s , p) =
       dependent-cogap-standard-sequential-colimit
         ( tS , KS)
@@ -848,7 +833,8 @@ module _
         ( CB s n p)
         ( map-family-descent-data-pushout R _ (tA (left-map-span-diagram 𝒮 s) n p))) ＝
       ( tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
-    tS-in-diagram s zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
+    tS-in-diagram s zero-ℕ (map-raise refl) =
+      inv (compute-inr-dependent-cogap _ _ _ _)
     tS-in-diagram s (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
 
     module vertices
@@ -857,11 +843,13 @@ module _
       PAn : (n : ℕ) → UU (l1 ⊔ l2 ⊔ l3)
       PAn = Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s)
       QAn : {n : ℕ} → PAn n → UU l5
-      QAn {n} p = left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p)
+      QAn {n} p =
+        left-family-descent-data-pushout R (left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p)
       PBn : (n : ℕ) → UU (l1 ⊔ l2 ⊔ l3)
       PBn = Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) ∘ succ-ℕ
       QBn : {n : ℕ} → PBn n → UU l5
-      QBn {n} p = right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
+      QBn {n} p =
+        right-family-descent-data-pushout R (right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p)
       fn : {n : ℕ} → PAn n → PBn n
       fn = concat-s 𝒮 a₀ s _
       gn : {n : ℕ} → PAn n → PAn (succ-ℕ n)
@@ -1119,6 +1107,24 @@ module _
       (s : spanning-type-span-diagram 𝒮)
       (p : left-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s)) →
       {!!}
+       -- (pr1 (pr2 (pr2 R) (s , p))
+       --  (sect-family-sect-dd-sequential-colimit
+       --   up-standard-sequential-colimit
+       --   (λ y → pr1 R (pr1 (pr2 (pr2 (pr2 𝒮))) s , y))
+       --   (tA (pr1 (pr2 (pr2 (pr2 𝒮))) s) , KA (pr1 (pr2 (pr2 (pr2 𝒮))) s))
+       --   p)) ＝
+       -- (sect-family-sect-dd-sequential-colimit
+       --  (up-shift-cocone-sequential-diagram 1
+       --   up-standard-sequential-colimit)
+       --  (λ y → pr1 (pr2 R) (pr2 (pr2 (pr2 (pr2 𝒮))) s , y))
+       --  (tB (pr2 (pr2 (pr2 (pr2 𝒮))) s) ∘ succ-ℕ ,
+       --   KB (pr2 (pr2 (pr2 (pr2 𝒮))) s) ∘ succ-ℕ)
+       --  (big-thm.f∞ up-standard-sequential-colimit
+       --   (up-shift-cocone-sequential-diagram 1
+       --    up-standard-sequential-colimit)
+       --   (hom-diagram-zigzag-sequential-diagram
+       --    (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+       --   p))
       -- map-family-descent-data-pushout R _ (pr1 ind-singleton-zigzag-id-pushout' (left-map-span-diagram 𝒮 s , p)) ＝
       -- pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p)
     alt-ind-coherence s p =
@@ -1134,9 +1140,10 @@ module _
           ( right-family-descent-data-pushout R)
           ( right-map-span-diagram 𝒮 s))
         ( λ {p} → map-family-descent-data-pushout R (s , p))
-        ( {!!})
-        ( {!!})
-        ( {!!})
+        ( tA (left-map-span-diagram 𝒮 s) , KA (left-map-span-diagram 𝒮 s))
+        ( tB (right-map-span-diagram 𝒮 s) ∘ succ-ℕ ,
+          KB (right-map-span-diagram 𝒮 s) ∘ succ-ℕ)
+        ( tS-in-diagram s)
         ( {!!})
         ( p)
 

From e3bd101577b826371ea8a3ed694ac057268bd057 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Tue, 28 Jan 2025 18:21:30 +0100
Subject: [PATCH 18/33] Unstraightening diagrams

---
 .../stuff-over.lagda.md                       | 258 ++++++++++++++++++
 1 file changed, 258 insertions(+)

diff --git a/src/synthetic-homotopy-theory/stuff-over.lagda.md b/src/synthetic-homotopy-theory/stuff-over.lagda.md
index d8ea225f0e..45c1d9db66 100644
--- a/src/synthetic-homotopy-theory/stuff-over.lagda.md
+++ b/src/synthetic-homotopy-theory/stuff-over.lagda.md
@@ -29,6 +29,23 @@ open import foundation.whiskering-homotopies-concatenation
 </details>
 
 ```agda
+open import foundation.dependent-pair-types
+open import foundation.equality-dependent-pair-types
+open import foundation.functoriality-dependent-pair-types
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2}
+  {A' : A → UU l3} {B' : B → UU l4}
+  (f : A → B)
+  (f' : (a : A) → A' a → B' (f a))
+  where
+
+  tot-map-over : Σ A A' → Σ B B'
+  tot-map-over = map-Σ B' f f'
+
+  coh-tot-map-over : coherence-square-maps tot-map-over pr1 pr1 f
+  coh-tot-map-over = refl-htpy
+
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2}
@@ -663,3 +680,244 @@ module _
           unget-section-triangle-over' f1 g1 m f1' g1' m' s1 s2 s3 F1 G1 M B1 T1 S1
         [iv] = left-whisk-section-htpy-over B1 T1 s1 s3 _ _ [iii] f2 f2' s4 F2
 ```
+
+```agda
+open import foundation.sections
+open import foundation.transport-along-homotopies
+module _
+  {l1 l2 : Level}
+  {A : UU l1} (B : A → UU l2)
+  where
+
+  sect-section :
+    section (pr1 {B = B}) →
+    ((a : A) → B a)
+  sect-section (s , H) a = tr B (H a) (pr2 (s a))
+
+  section-sect :
+    ((a : A) → B a) →
+    section (pr1 {B = B})
+  section-sect = section-dependent-function
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {P : A → UU l2}
+  {B : UU l3} {Q : B → UU l4}
+  (f : A → B)
+  (f' : {a : A} → P a → Q (f a))
+  where
+
+  section-displayed-map-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4)
+  section-displayed-map-over =
+    Σ ( section (pr1 {B = P}))
+      ( λ sA →
+        Σ ( section (pr1 {B = Q}))
+          ( λ sB →
+            Σ ( coherence-square-maps f
+                ( map-section pr1 sA)
+                ( map-section pr1 sB)
+                ( tot-map-over f (λ a → f' {a})))
+              ( λ H →
+                ( ( pasting-vertical-coherence-square-maps
+                    ( f)
+                    ( map-section pr1 sA)
+                    ( map-section pr1 sB)
+                    ( tot-map-over f (λ a → f' {a}))
+                    ( pr1)
+                    ( pr1)
+                    ( f)
+                    ( H)
+                    ( refl-htpy))) ∙h
+                  ( is-section-map-section pr1 sB ·r f) ~
+                ( f ·l is-section-map-section pr1 sA) ∙h refl-htpy)))
+
+  sect-map-over-section-map-over :
+    (s : section-displayed-map-over) →
+    section-map-over f
+      ( f')
+      ( sect-section P (pr1 s))
+      ( sect-section Q (pr1 (pr2 s)))
+  sect-map-over-section-map-over (sA , sB , H , α) a =
+    preserves-tr (λ a → f' {a}) (σA a) (sA2 a) ∙
+    inv (substitution-law-tr Q f (σA a)) ∙
+    [i] ∙
+    tr-concat (H1 a) (σB (f a)) (f' (sA2 a)) ∙
+    ap
+      ( tr Q (σB (f a)))
+      ( substitution-law-tr Q pr1 (H a) ∙
+        apd pr2 (H a))
+    where
+      sA1 : A → A
+      sA1 = pr1 ∘ map-section pr1 sA
+      σA : sA1 ~ id
+      σA = is-section-map-section pr1 sA
+      sA2 : (a : A) → P (sA1 a)
+      sA2 = pr2 ∘ map-section pr1 sA
+      sB1 : B → B
+      sB1 = pr1 ∘ map-section pr1 sB
+      σB : sB1 ~ id
+      σB = is-section-map-section pr1 sB
+      H1 : f ∘ sA1 ~ sB1 ∘ f
+      H1 = pr1 ·l H
+      [i] :
+        tr Q (ap f (σA a)) (f' (sA2 a)) ＝
+        tr Q (H1 a ∙ σB (f a)) (f' (sA2 a))
+      [i] =
+        ap
+          ( λ p → tr Q p (f' (sA2 a)))
+          ( inv (α a ∙ right-unit))
+```
+
+```agda
+open import foundation.commuting-cubes-of-maps
+module _
+  {l1 l2 l3 l4 l1' l2' l3' l4' l1'' l2'' l3'' l4'' : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+  (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+  {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
+  (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
+  {A'' : UU l1''} {B'' : UU l2''} {C'' : UU l3''} {D'' : UU l4''}
+  (f'' : A'' → B'') (g'' : A'' → C'') (h'' : B'' → D'') (k'' : C'' → D'')
+  (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
+  (hA' : A'' → A') (hB' : B'' → B') (hC' : C'' → C') (hD' : D'' → D')
+  (mid : (h' ∘ f') ~ (k' ∘ g'))
+  (bottom-back-left : (f ∘ hA) ~ (hB ∘ f'))
+  (bottom-back-right : (g ∘ hA) ~ (hC ∘ g'))
+  (bottom-front-left : (h ∘ hB) ~ (hD ∘ h'))
+  (bottom-front-right : (k ∘ hC) ~ (hD ∘ k'))
+  (bottom : (h ∘ f) ~ (k ∘ g))
+  (top : (h'' ∘ f'') ~ (k'' ∘ g''))
+  (top-back-left : (f' ∘ hA') ~ (hB' ∘ f''))
+  (top-back-right : (g' ∘ hA') ~ (hC' ∘ g''))
+  (top-front-left : (h' ∘ hB') ~ (hD' ∘ h''))
+  (top-front-right : (k' ∘ hC') ~ (hD' ∘ k''))
+  where
+
+  pasting-vertical-coherence-cube-maps :
+    coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
+      ( mid)
+      ( bottom-back-left)
+      ( bottom-back-right)
+      ( bottom-front-left)
+      ( bottom-front-right)
+      ( bottom) →
+    coherence-cube-maps f' g' h' k' f'' g'' h'' k'' hA' hB' hC' hD'
+      ( top)
+      ( top-back-left)
+      ( top-back-right)
+      ( top-front-left)
+      ( top-front-right)
+      ( mid) →
+    coherence-cube-maps f g h k f'' g'' h'' k''
+      ( hA ∘ hA') (hB ∘ hB') (hC ∘ hC') (hD ∘ hD')
+      ( top)
+      ( pasting-vertical-coherence-square-maps f'' hA' hB' f' hA hB f
+        ( top-back-left) (bottom-back-left))
+      ( pasting-vertical-coherence-square-maps g'' hA' hC' g' hA hC g
+        ( top-back-right) (bottom-back-right))
+      ( pasting-vertical-coherence-square-maps h'' hB' hD' h' hB hD h
+        ( top-front-left) (bottom-front-left))
+      ( pasting-vertical-coherence-square-maps k'' hC' hD' k' hC hD k
+        ( top-front-right) (bottom-front-right))
+      ( bottom)
+  pasting-vertical-coherence-cube-maps α β = {!!}
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+  {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
+  {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
+  (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
+  (g1' : (p : P1) → Q1 p → Q3 (g1 p))
+  (f1' : (p : P1) → Q1 p → Q2 (f1 p))
+  (f2' : (p : P3) → Q3 p → Q4 (f2 p))
+  (g2' : (p : P2) → Q2 p → Q4 (g2 p))
+  (bottom : g2 ∘ f1 ~ f2 ∘ g1)
+  (top : square-over g1 f1 f2 g2 (g1' _) (f1' _) (f2' _) (g2' _) bottom)
+  where
+
+  tot-square-over :
+    coherence-square-maps
+      ( tot-map-over g1 g1')
+      ( tot-map-over f1 f1')
+      ( tot-map-over {B' = Q4} f2 f2')
+      ( tot-map-over g2 g2')
+  tot-square-over =
+    coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})
+
+  coh-tot-square-over :
+    coherence-cube-maps f1 g1 g2 f2
+      ( map-Σ Q2 f1 f1')
+      ( map-Σ Q3 g1 g1')
+      ( map-Σ Q4 g2 g2')
+      ( map-Σ Q4 f2 f2')
+      ( pr1)
+      ( pr1)
+      ( pr1)
+      ( pr1)
+      ( tot-square-over)
+      ( refl-htpy)
+      ( refl-htpy)
+      ( refl-htpy)
+      ( refl-htpy)
+      ( bottom)
+  coh-tot-square-over (p , q) =
+    ap-pr1-eq-pair-Σ (bottom p) (top q) ∙ inv right-unit
+
+  section-displayed-cube-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4 ⊔ l5 ⊔ l6 ⊔ l7 ⊔ l8)
+  section-displayed-cube-over =
+    Σ ( section-displayed-map-over {Q = Q2} f1 (f1' _))
+      ( λ sF1 →
+        Σ ( section-displayed-map-over {Q = Q4} f2 (f2' _))
+          ( λ sF2 →
+            Σ ( coherence-square-maps g1
+                ( map-section pr1 (pr1 sF1))
+                ( map-section pr1 (pr1 sF2))
+                ( tot-map-over g1 g1'))
+              ( λ G1 →
+                Σ ( coherence-square-maps g2
+                    ( map-section pr1 (pr1 (pr2 sF1)))
+                    ( map-section pr1 (pr1 (pr2 sF2)))
+                    ( tot-map-over g2 g2'))
+                  ( λ G2 →
+                    Σ ( coherence-cube-maps
+                        ( tot-map-over f1 f1')
+                        ( tot-map-over g1 g1')
+                        ( tot-map-over g2 g2')
+                        ( tot-map-over f2 f2')
+                        f1 g1 g2 f2
+                        ( map-section pr1 (pr1 sF1))
+                        ( map-section pr1 (pr1 (pr2 sF1)))
+                        ( map-section pr1 (pr1 sF2))
+                        ( map-section pr1 (pr1 (pr2 sF2)))
+                        ( bottom)
+                        ( pr1 (pr2 (pr2 sF1)))
+                        ( G1)
+                        ( G2)
+                        ( pr1 (pr2 (pr2 sF2)))
+                        ( tot-square-over))
+                      ( λ α →
+                        pasting-vertical-coherence-cube-maps f1 g1 g2 f2
+                          ( tot-map-over f1 f1')
+                          ( tot-map-over g1 g1')
+                          ( tot-map-over g2 g2')
+                          ( tot-map-over f2 f2')
+                          f1 g1 g2 f2
+                          pr1 pr1 pr1 pr1
+                          ( map-section pr1 (pr1 sF1))
+                          ( map-section pr1 (pr1 (pr2 sF1)))
+                          ( map-section pr1 (pr1 sF2))
+                          ( map-section pr1 (pr1 (pr2 sF2)))
+                          ( tot-square-over)
+                          refl-htpy refl-htpy refl-htpy refl-htpy
+                          ( bottom)
+                          ( bottom)
+                          ( pr1 (pr2 (pr2 sF1)))
+                          ( G1)
+                          ( G2)
+                          ( pr1 (pr2 (pr2 sF2)))
+                          ( coh-tot-square-over)
+                          ( α) ~ {!!}
+                          )))))
+```

From 04cc699d96a8069b7ec6d1f633e1f51f6a1b4854 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Thu, 30 Jan 2025 19:02:23 +0100
Subject: [PATCH 19/33] Work on cubes from displayed squares

---
 .../stuff-over.lagda.md                       | 204 +++++++++++-------
 1 file changed, 129 insertions(+), 75 deletions(-)

diff --git a/src/synthetic-homotopy-theory/stuff-over.lagda.md b/src/synthetic-homotopy-theory/stuff-over.lagda.md
index 45c1d9db66..7ca3abb082 100644
--- a/src/synthetic-homotopy-theory/stuff-over.lagda.md
+++ b/src/synthetic-homotopy-theory/stuff-over.lagda.md
@@ -9,6 +9,7 @@ module synthetic-homotopy-theory.stuff-over where
 ```agda
 open import foundation.action-on-identifications-dependent-functions
 open import foundation.action-on-identifications-functions
+open import foundation.commuting-cubes-of-maps
 open import foundation.commuting-squares-of-maps
 open import foundation.commuting-triangles-of-maps
 open import foundation.dependent-identifications
@@ -22,6 +23,7 @@ open import foundation.identity-types
 open import foundation.transport-along-identifications
 open import foundation.transposition-identifications-along-equivalences
 open import foundation.universe-levels
+open import foundation.whiskering-higher-homotopies-composition
 open import foundation.whiskering-homotopies-composition
 open import foundation.whiskering-homotopies-concatenation
 ```
@@ -738,14 +740,13 @@ module _
       ( sect-section P (pr1 s))
       ( sect-section Q (pr1 (pr2 s)))
   sect-map-over-section-map-over (sA , sB , H , α) a =
-    preserves-tr (λ a → f' {a}) (σA a) (sA2 a) ∙
-    inv (substitution-law-tr Q f (σA a)) ∙
-    [i] ∙
-    tr-concat (H1 a) (σB (f a)) (f' (sA2 a)) ∙
-    ap
+    ( preserves-tr (λ a → f' {a}) (σA a) (sA2 a)) ∙
+    ( inv (substitution-law-tr Q f (σA a))) ∙
+    ( ap (λ p → tr Q p (f' (sA2 a))) (inv (α a ∙ right-unit))) ∙
+    ( tr-concat (H1 a) (σB (f a)) (f' (sA2 a))) ∙
+    ( ap
       ( tr Q (σB (f a)))
-      ( substitution-law-tr Q pr1 (H a) ∙
-        apd pr2 (H a))
+      ( substitution-law-tr Q pr1 (H a) ∙ apd pr2 (H a)))
     where
       sA1 : A → A
       sA1 = pr1 ∘ map-section pr1 sA
@@ -759,71 +760,73 @@ module _
       σB = is-section-map-section pr1 sB
       H1 : f ∘ sA1 ~ sB1 ∘ f
       H1 = pr1 ·l H
-      [i] :
-        tr Q (ap f (σA a)) (f' (sA2 a)) ＝
-        tr Q (H1 a ∙ σB (f a)) (f' (sA2 a))
-      [i] =
-        ap
-          ( λ p → tr Q p (f' (sA2 a)))
-          ( inv (α a ∙ right-unit))
 ```
 
 ```agda
-open import foundation.commuting-cubes-of-maps
 module _
-  {l1 l2 l3 l4 l1' l2' l3' l4' l1'' l2'' l3'' l4'' : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
-  (f : A → B) (g : A → C) (h : B → D) (k : C → D)
-  {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
-  (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
-  {A'' : UU l1''} {B'' : UU l2''} {C'' : UU l3''} {D'' : UU l4''}
-  (f'' : A'' → B'') (g'' : A'' → C'') (h'' : B'' → D'') (k'' : C'' → D'')
-  (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
-  (hA' : A'' → A') (hB' : B'' → B') (hC' : C'' → C') (hD' : D'' → D')
-  (mid : (h' ∘ f') ~ (k' ∘ g'))
-  (bottom-back-left : (f ∘ hA) ~ (hB ∘ f'))
-  (bottom-back-right : (g ∘ hA) ~ (hC ∘ g'))
-  (bottom-front-left : (h ∘ hB) ~ (hD ∘ h'))
-  (bottom-front-right : (k ∘ hC) ~ (hD ∘ k'))
-  (bottom : (h ∘ f) ~ (k ∘ g))
-  (top : (h'' ∘ f'') ~ (k'' ∘ g''))
-  (top-back-left : (f' ∘ hA') ~ (hB' ∘ f''))
-  (top-back-right : (g' ∘ hA') ~ (hC' ∘ g''))
-  (top-front-left : (h' ∘ hB') ~ (hD' ∘ h''))
-  (top-front-right : (k' ∘ hC') ~ (hD' ∘ k''))
+  {l1 l2 : Level}
+  {A : UU l1} {B : A → UU l2}
+  (s : (a : A) → B a)
   where
 
-  pasting-vertical-coherence-cube-maps :
-    coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
-      ( mid)
-      ( bottom-back-left)
-      ( bottom-back-right)
-      ( bottom-front-left)
-      ( bottom-front-right)
-      ( bottom) →
-    coherence-cube-maps f' g' h' k' f'' g'' h'' k'' hA' hB' hC' hD'
-      ( top)
-      ( top-back-left)
-      ( top-back-right)
-      ( top-front-left)
-      ( top-front-right)
-      ( mid) →
-    coherence-cube-maps f g h k f'' g'' h'' k''
-      ( hA ∘ hA') (hB ∘ hB') (hC ∘ hC') (hD ∘ hD')
-      ( top)
-      ( pasting-vertical-coherence-square-maps f'' hA' hB' f' hA hB f
-        ( top-back-left) (bottom-back-left))
-      ( pasting-vertical-coherence-square-maps g'' hA' hC' g' hA hC g
-        ( top-back-right) (bottom-back-right))
-      ( pasting-vertical-coherence-square-maps h'' hB' hD' h' hB hD h
-        ( top-front-left) (bottom-front-left))
-      ( pasting-vertical-coherence-square-maps k'' hC' hD' k' hC hD k
-        ( top-front-right) (bottom-front-right))
-      ( bottom)
-  pasting-vertical-coherence-cube-maps α β = {!!}
-```
+  ap-map-section-family-lemma :
+    {a a' : A} (p : a ＝ a') →
+    ap (map-section-family s) p ＝ eq-pair-Σ p (apd s p)
+  ap-map-section-family-lemma refl = refl
+module _
+  {l1 l2 l3 : Level}
+  {A : UU l1} {B : UU l2} {Q : B → UU l3}
+  (s : (b : B) → Q b)
+  {f g : A → B} (H : f ~ g)
+  where
 
-```agda
+  left-whisker-dependent-function-lemma :
+    (a : A) →
+    (map-section-family s ·l H) a ＝ eq-pair-Σ (H a) (apd s (H a))
+  left-whisker-dependent-function-lemma a = ap-map-section-family-lemma s (H a)
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2}
+  {A' : A → UU l3} {B' : B → UU l4}
+  {f : A → B} (f' : (a : A) → A' a → B' (f a))
+  where
+
+  ap-map-Σ-eq-fiber :
+    {a : A} (x y : A' a) (p : x ＝ y) →
+    ap (map-Σ B' f f') (eq-pair-eq-fiber p) ＝ eq-pair-eq-fiber (ap (f' a) p)
+  ap-map-Σ-eq-fiber x .x refl = refl
+
+  -- ap-map-Σ-eq-fiber' :
+  --   {a : A} (x y : A' a) (p : x ＝ y) →
+  --   ap (map-Σ B' f f') (eq-pair-eq-fiber p) ＝ eq-pair-eq-fiber (ap (f' a) p)
+  -- ap-map-Σ-eq-fiber' {a} x y p =
+  --   compute-ap-eq-pair-Σ (map-Σ B' f f') refl p ∙
+  --   ap-comp (pair (f a)) (f' a) p
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3}
+  {A' : A → UU l4} {B' : B → UU l5} {C' : C → UU l6}
+  {f : A → B} {g : B → C}
+  (f' : (a : A) → A' a → B' (f a))
+  (g' : (b : B) → B' b → C' (g b))
+  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sC : (c : C) → C' c)
+  (F : (a : A) → f' a (sA a) ＝ sB (f a)) (G : (b : B) → g' b (sB b) ＝ sC (g b))
+  where
+
+  pasting-horizontal-comp :
+    pasting-horizontal-coherence-square-maps f g
+      ( map-section-family sA) (map-section-family sB) (map-section-family sC)
+      ( tot-map-over f f') (tot-map-over g g')
+      ( eq-pair-eq-fiber ∘ F)
+      ( eq-pair-eq-fiber ∘ G) ~
+    eq-pair-eq-fiber ∘
+      ((g' _) ·l F ∙h G ·r f)
+  pasting-horizontal-comp a =
+    ap
+      ( _∙ eq-pair-eq-fiber (G (f a)))
+      ( inv (ap-comp (tot-map-over g g') (pair (f a)) (F a)) ∙
+        ap-comp (pair (g (f a))) (g' (f a)) (F a)) ∙
+    inv (ap-concat (pair (g (f a))) (ap (g' (f a)) (F a)) (G (f a)))
 module _
   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
   {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
@@ -852,15 +855,9 @@ module _
       ( map-Σ Q3 g1 g1')
       ( map-Σ Q4 g2 g2')
       ( map-Σ Q4 f2 f2')
-      ( pr1)
-      ( pr1)
-      ( pr1)
-      ( pr1)
+      pr1 pr1 pr1 pr1
       ( tot-square-over)
-      ( refl-htpy)
-      ( refl-htpy)
-      ( refl-htpy)
-      ( refl-htpy)
+      refl-htpy refl-htpy refl-htpy refl-htpy
       ( bottom)
   coh-tot-square-over (p , q) =
     ap-pr1-eq-pair-Σ (bottom p) (top q) ∙ inv right-unit
@@ -911,8 +908,7 @@ module _
                           ( map-section pr1 (pr1 (pr2 sF2)))
                           ( tot-square-over)
                           refl-htpy refl-htpy refl-htpy refl-htpy
-                          ( bottom)
-                          ( bottom)
+                          bottom bottom
                           ( pr1 (pr2 (pr2 sF1)))
                           ( G1)
                           ( G2)
@@ -920,4 +916,62 @@ module _
                           ( coh-tot-square-over)
                           ( α) ~ {!!}
                           )))))
+
+  module _
+    (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p)
+    (s3 : (p : P3) → Q3 p) (s4 : (p : P4) → Q4 p)
+    (G1 : (p : P1) → g1' p (s1 p) ＝ s3 (g1 p))
+    (F1 : (p : P1) → f1' p (s1 p) ＝ s2 (f1 p))
+    (F2 : (p : P3) → f2' p (s3 p) ＝ s4 (f2 p))
+    (G2 : (p : P2) → g2' p (s2 p) ＝ s4 (g2 p))
+    where
+    open import foundation.action-on-identifications-binary-functions
+
+    _ :
+      pasting-vertical-coherence-square-maps g1
+        ( map-section-family s1) (map-section-family s3)
+        ( tot-map-over g1 g1') (tot-map-over f1 f1')
+        ( tot-map-over {B' = Q4} f2 f2') (tot-map-over g2 g2')
+        ( eq-pair-eq-fiber ∘ G1)
+        ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})) ~
+      ( λ p → eq-pair-Σ (bottom p) (top (s1 p) ∙ ap (f2' (g1 p)) (G1 p)))
+    _ = λ p → ap (eq-pair-Σ (bottom p) (top (s1 p)) ∙_) ([i] p) ∙
+              {!!}
+        where
+        [i] =
+          λ (p : P1) →
+          inv (ap-comp (map-Σ Q4 f2 f2') (pair (g1 p)) (G1 p)) ∙
+          ap-comp (pair (f2 (g1 p))) (f2' (g1 p)) (G1 p)
+
+    section-cube-over-sect-square-over :
+      section-square-over g1 f1 f2 g2
+        ( g1' _) (f1' _) (f2' _) (g2' _)
+        s1 s2 s3 s4
+        G1 F1 F2 G2
+        bottom top →
+      section-displayed-cube-over
+    pr1 (section-cube-over-sect-square-over α) =
+      ( section-dependent-function s1) ,
+      ( section-dependent-function s2) ,
+      ( λ p → eq-pair-eq-fiber (F1 p)) ,
+      ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F1 p))
+    pr1 (pr2 (section-cube-over-sect-square-over α)) =
+      ( section-dependent-function s3) ,
+      ( section-dependent-function s4) ,
+      ( λ p → eq-pair-eq-fiber (F2 p)) ,
+      ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F2 p))
+    pr2 (pr2 (section-cube-over-sect-square-over α)) =
+      ( λ p → eq-pair-eq-fiber (G1 p)) ,
+      ( λ p → eq-pair-eq-fiber (G2 p)) ,
+      ( λ p →
+        ap-binary
+          ( _∙_)
+          ( pasting-horizontal-comp f1' g2' s1 s2 s4 F1 G2 p)
+          ( ap-map-section-family-lemma s4 (bottom p)) ∙
+        {!!} ∙
+        ap-binary
+          ( _∙_)
+          ( refl {x = eq-pair-Σ (bottom p) (top (s1 p))})
+          ( inv (pasting-horizontal-comp g1' f2' s1 s3 s4 G1 F2 p))) ,
+      ( {!!})
 ```

From 037a2324ac860c10a19d74a37e3738b32b05d90e Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Sat, 1 Feb 2025 00:29:35 +0100
Subject: [PATCH 20/33] Simplifications

---
 .../stuff-over.lagda.md                       | 731 ++++++++++++------
 1 file changed, 484 insertions(+), 247 deletions(-)

diff --git a/src/synthetic-homotopy-theory/stuff-over.lagda.md b/src/synthetic-homotopy-theory/stuff-over.lagda.md
index 7ca3abb082..709671029f 100644
--- a/src/synthetic-homotopy-theory/stuff-over.lagda.md
+++ b/src/synthetic-homotopy-theory/stuff-over.lagda.md
@@ -18,7 +18,6 @@ open import foundation.function-extensionality
 open import foundation.function-types
 open import foundation.functoriality-dependent-function-types
 open import foundation.homotopies
-open import foundation.homotopy-induction
 open import foundation.identity-types
 open import foundation.transport-along-identifications
 open import foundation.transposition-identifications-along-equivalences
@@ -73,8 +72,7 @@ module _
   where
 
   inv-htpy-over : htpy-over B' H f' g' → htpy-over B' (inv-htpy H) g' f'
-  inv-htpy-over H' a' =
-    map-eq-transpose-equiv-inv (equiv-tr B' (H _)) (inv (H' a'))
+  inv-htpy-over H' {a} a' = inv-dependent-identification B' (H a) (H' a')
 
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
@@ -91,6 +89,20 @@ module _
   right-whisk-htpy-over : htpy-over B' (H ·r s) (f' ∘ s') (g' ∘ s')
   right-whisk-htpy-over a' = H' (s' a')
 
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2}
+  {A' : A → UU l3} {B' : B → UU l4}
+  where
+
+  left-whisk-dependent-identification :
+    {s : A → B} (s' : {a : A} → A' a → B' (s a))
+    {x y : A} (p : x ＝ y)
+    {x' : A' x} {y' : A' y} (q : dependent-identification A' p x' y') →
+    dependent-identification B' (ap s p) (s' x') (s' y')
+  left-whisk-dependent-identification s' refl q = ap s' q
+
+
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
   {A : UU l1} {B : UU l2} {X : UU l3}
@@ -110,34 +122,7 @@ module _
     tr X' (ap s (H a)) (s' (f' a')) ＝ s' (g'a')
 
   left-whisk-htpy-over : htpy-over X' (s ·l H) (s' ∘ f') (s' ∘ g')
-  left-whisk-htpy-over {a} a' =
-    ind-htpy f
-      ( LWMOTIF a')
-      ( ap s')
-      ( H)
-      ( H' a')
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {X' : X → UU l6}
-  {f : A → B}
-  {f' g' : {a : A} → A' a → B' (f a)}
-  (H' : {a : A} → f' {a} ~ g')
-  {s : B → X} (s' : {b : B} → B' b → X' (s b))
-  where
-
-  compute-left-whisk-htpy-over :
-    {a : A} (a' : A' a) →
-    left-whisk-htpy-over {B' = B'} {X' = X'} {f = f} refl-htpy H' s' a' ＝ ap s' (H' a')
-  compute-left-whisk-htpy-over a' =
-    htpy-eq
-      ( htpy-eq-implicit
-        ( compute-ind-htpy f
-          ( LWMOTIF {B' = B'} {X' = X'} refl-htpy H' s' a')
-          ( ap s'))
-        ( g' a'))
-      ( H' a')
+  left-whisk-htpy-over {a} a' = left-whisk-dependent-identification s' (H a) (H' a')
 
 module _
   {l1 l2 l3 l4 : Level}
@@ -182,6 +167,19 @@ module _
   comp-section-map-over G F =
     g' ·l F ∙h G ·r f
 
+module _
+  {l1 l2 : Level}
+  {A : UU l1} {B : A → UU l2}
+  {x y : A} (p : x ＝ y)
+  {x' : B x} {y' : B y} (q : dependent-identification B p x' y')
+  (s : (a : A) → B a)
+  (F : x' ＝ s x) (G : y' ＝ s y)
+  where
+
+  section-dependent-identification : UU l2
+  section-dependent-identification =
+    q ∙ G ＝ ap (tr B p) F ∙ apd s p
+
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2} {A' : A → UU l3} {B' : B → UU l4}
@@ -198,9 +196,26 @@ module _
 
   section-htpy-over : UU (l1 ⊔ l4)
   section-htpy-over =
-    (a : A) →
-    H' (sA a) ∙ G a ＝
-    ap (tr B' (H a)) (F a) ∙ apd sB (H a)
+    (a : A) → section-dependent-identification (H a) (H' (sA a)) sB (F a) (G a)
+
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+
+  inv-section-identification-over :
+    {x y : A} (p : x ＝ y) →
+    {x' : B x} {y' : B y} (q : dependent-identification B p x' y') →
+    (s : (a : A) → B a) →
+    (F : x' ＝ s x) (G : y' ＝ s y) →
+    section-dependent-identification p q s F G →
+    section-dependent-identification
+      ( inv p)
+      ( inv-dependent-identification B p q)
+      ( s)
+      ( G)
+      ( F)
+  inv-section-identification-over refl refl s F G α =
+    inv (right-unit ∙ ap-id G ∙ α ∙ right-unit ∙ ap-id F)
 
 module _
   {l1 l2 l3 l4 : Level}
@@ -225,34 +240,8 @@ module _
       ( sB)
       ( G)
       ( F)
-  inv-section-htpy-over α =
-    ind-htpy f
-      ( λ g H →
-        {g' : {a : A} → A' a → B' (g a)} →
-        (H' : htpy-over B' H f' g') →
-        (G : section-map-over g g' sA sB) →
-        section-htpy-over H H' sA sB F G →
-        section-htpy-over
-          ( inv-htpy H)
-          ( inv-htpy-over B' H f' g' H')
-          sA sB G F)
-      ( λ H' G α a →
-        ind-htpy f'
-          ( λ g'a H'a →
-            (Ga : g'a (sA a) ＝ sB (f a)) →
-            (αa : H'a (sA a) ∙ Ga ＝ ap (tr B' refl) (F a) ∙ apd sB refl) →
-            map-eq-transpose-equiv-inv (equiv-tr B' refl) (inv (H'a (sA a))) ∙ F a ＝
-            ap (tr B' refl) Ga ∙ apd sB refl)
-          ( λ Ga αa →
-            ap (_∙ F a) (compute-refl-eq-transpose-equiv-inv (equiv-tr B' refl)) ∙
-            inv (right-unit ∙ ap-id _ ∙ (αa ∙ right-unit ∙ ap-id _)))
-          ( H')
-          ( G a)
-          ( α a))
-      ( H)
-      ( H')
-      ( G)
-      ( α)
+  inv-section-htpy-over α a =
+    inv-section-identification-over (H a) (H' (sA a)) sB (F a) (G a) (α a)
 
 module _
   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
@@ -315,6 +304,8 @@ module _
   (sX : (x : X) → X' x)
   (S : section-map-over s s' sX sA)
   where
+  open import foundation.commuting-squares-of-identifications
+  open import foundation.commuting-triangles-of-identifications
 
   right-whisk-section-htpy-over :
     section-htpy-over (H ·r s)
@@ -322,33 +313,45 @@ module _
       sX sB
       ( comp-section-map-over f s f' s' sX sA sB F S)
       ( comp-section-map-over g s g' s' sX sA sB G S)
-  right-whisk-section-htpy-over =
-    ind-htpy f
-      ( λ g H →
-          {g' : {a : A} → A' a → B' (g a)}
-          (H' : htpy-over B' H f' g')
-          (G : section-map-over g g' sA sB)
-          (α : section-htpy-over H H' sA sB F G) →
-          section-htpy-over (H ·r s)
-            ( right-whisk-htpy-over H H' s s')
-            sX sB
-            ( comp-section-map-over f s f' s' sX sA sB F S)
-            ( comp-section-map-over g s g' s' sX sA sB G S))
-      ( λ H' G α x →
-        ind-htpy (f' {s x})
-          ( λ g'sx H'sx →
-            (Gsx : g'sx (sA (s x)) ＝ sB (f (s x)))
-            (αsx : H'sx (sA (s x)) ∙ Gsx ＝ ap (tr B' refl) (F (s x)) ∙ apd sB refl) →
-            H'sx (s' (sX x)) ∙ ((ap g'sx (S x)) ∙ Gsx) ＝
-            ap (tr B' refl) (ap f' (S x) ∙ (F (s x))) ∙ apd sB refl)
-          ( λ Gsx αsx → inv (right-unit ∙ (ap-id _ ∙ ap (ap f' (S x) ∙_) (inv (αsx ∙ (right-unit ∙ ap-id _))))))
-          ( H')
-          ( G (s x))
-          ( α (s x)))
-      ( H)
-      ( H')
-      ( G)
-      ( α)
+  right-whisk-section-htpy-over x =
+    right-whisker-concat-coherence-square-identifications
+      ( ap (tr B' (H (s x)) ∘ f') (S x))
+      ( H' (s' (sX x)))
+      ( H' (sA (s x)))
+      ( ap g' (S x))
+      ( nat-htpy (H' {s x}) (S x))
+      ( G (s x)) ∙
+    ap (_∙ (H' (sA (s x)) ∙ G (s x))) (ap-comp (tr B' (H (s x))) f' (S x)) ∙
+    ap (ap (tr B' (H (s x))) (ap f' (S x)) ∙_) (α (s x)) ∙
+    right-whisker-concat-coherence-triangle-identifications'
+      ( ap (tr B' (H (s x))) (ap f' (S x) ∙ F (s x)))
+      ( ap (tr B' (H (s x))) (F (s x)))
+      ( ap (tr B' (H (s x))) (ap f' (S x)))
+      ( apd sB (H (s x)))
+      ( inv (ap-concat (tr B' (H (s x))) (ap f' (S x)) (F (s x))))
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {X : UU l2}
+  {A' : A → UU l3} {X' : X → UU l4}
+  where
+
+  left-whisk-section-dependent-identification :
+    {x y : A} (p : x ＝ y)
+    {x' : A' x} {y' : A' y} (q : dependent-identification A' p x' y')
+    (sA : (a : A) → A' a)
+    (F : x' ＝ sA x) (G : y' ＝ sA y)
+    (α : section-dependent-identification p q sA F G)
+    {s : A → X} (s' : {a : A} → A' a → X' (s a))
+    (sX : (x : X) → X' x)
+    (S : section-map-over s s' sA sX) →
+    section-dependent-identification
+      ( ap s p)
+      ( left-whisk-dependent-identification s' p q)
+      sX (ap s' F ∙ S x) (ap s' G ∙ S y)
+  left-whisk-section-dependent-identification {x} refl refl sA F G α s' sX S =
+    ap (λ p → ap s' p ∙ S x) (α ∙ right-unit ∙ ap-id F) ∙
+    inv (right-unit ∙ ap-id (ap s' F ∙ S x))
 
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
@@ -376,34 +379,30 @@ module _
       sA sX
       ( comp-section-map-over s f s' f' sA sB sX S F)
       ( comp-section-map-over s g s' g' sA sB sX S G)
-  left-whisk-section-htpy-over =
-    ind-htpy f
-      ( λ g H →
-        {g' : {a : A} → A' a → B' (g a)} →
-        (H' : htpy-over B' H f' g')
-        (G : section-map-over g g' sA sB)
-        (α : section-htpy-over H H' sA sB F G) →
-        section-htpy-over (s ·l H)
-          ( left-whisk-htpy-over H H' s')
-          sA sX
-          ( comp-section-map-over s f s' f' sA sB sX S F)
-          ( comp-section-map-over s g s' g' sA sB sX S G))
-      ( λ H' G α a →
-        ap (_∙ (ap s' (G a) ∙ S (f a)))
-          ( compute-left-whisk-htpy-over H' s' (sA a)) ∙
-        ind-htpy f'
-          ( λ g'a H'a →
-            (Ga : g'a (sA a) ＝ sB (f a)) →
-            (αa : H'a (sA a) ∙ Ga ＝ ap (tr B' refl) (F a) ∙ apd sB refl) →
-            ap s' (H'a (sA a)) ∙ (ap s' Ga ∙ S (f a)) ＝ ap (tr X' refl) (ap s' (F a) ∙ S (f a)) ∙ apd sX refl)
-          ( λ Ga αa → inv (right-unit ∙ (ap-id _ ∙ ap (_∙ S (f a)) (inv (ap (ap s') (αa ∙ (right-unit ∙ ap-id _)))))))
-          ( H')
-          ( G a)
-          ( α a))
+  left-whisk-section-htpy-over a =
+    left-whisk-section-dependent-identification (H a) (H' (sA a)) sB (F a) (G a) (α a) s' sX S
+
+module _
+  {l1 l2 : Level}
+  {A : UU l1} {B : A → UU l2}
+  where
+
+  concat-section-dependent-identification :
+    {x y z : A} (p : x ＝ y) (q : y ＝ z)
+    {x' : B x} {y' : B y} {z' : B z}
+    (p' : dependent-identification B p x' y')
+    (q' : dependent-identification B q y' z')
+    (s : (a : A) → B a)
+    (F : x' ＝ s x) (G : y' ＝ s y) (H : z' ＝ s z)
+    (α : section-dependent-identification p p' s F G)
+    (β : section-dependent-identification q q' s G H) →
+    section-dependent-identification (p ∙ q)
+      ( concat-dependent-identification B p q p' q')
+      ( s)
+      ( F)
       ( H)
-      ( H')
-      ( G)
-      ( α)
+  concat-section-dependent-identification refl q refl q' s F G H α β =
+    β ∙ ap (λ p → ap (tr B q) p ∙ apd s q) (α ∙ right-unit ∙ ap-id F)
 
 module _
   {l1 l2 l3 l4 : Level}
@@ -431,49 +430,9 @@ module _
       ( sB)
       ( F)
       ( I)
-  concat-section-htpy-over =
-    ind-htpy f
-      ( λ g H →
-        {i : A → B} (K : g ~ i)
-        {g' : {a : A} → A' a → B' (g a)}
-        {i' : {a : A} → A' a → B' (i a)}
-        (H' : htpy-over B' H f' g') (K' : htpy-over B' K g' i')
-        (G : section-map-over g g' sA sB)
-        (I : section-map-over i i' sA sB)
-        (α : section-htpy-over H H' sA sB F G)
-        (β : section-htpy-over K K' sA sB G I) →
-        section-htpy-over
-          ( H ∙h K)
-          ( concat-htpy-over H K H' K')
-          sA sB F I)
-      ( λ K H' K' G I α β a →
-        ind-htpy (f' {a})
-          ( λ g'a H' →
-            {ia : B} (K : f a ＝ ia)
-            {i'a : A' a → B' ia}
-            (K' : (a' : A' a) → dependent-identification B' K (g'a a') (i'a a'))
-            (G : g'a (sA a) ＝ sB (f a))
-            (I : i'a (sA a) ＝ sB ia)
-            (α : H' (sA a) ∙ G ＝ ap id (F a) ∙ refl)
-            (β : K' (sA a) ∙ I ＝ ap (tr B' K) G ∙ apd sB K) →
-              concat-dependent-identification B' refl K (H' (sA a)) (K' (sA a)) ∙ I ＝
-              ap (tr B' K) (F a) ∙ apd sB K)
-          ( λ K K' G I α β → β ∙ ap (λ p → ap (tr B' K) p ∙ apd sB K) (α ∙ (right-unit ∙ ap-id (F a))))
-          ( H' {a})
-          ( K a)
-          ( K' {a})
-          ( G a)
-          ( I a)
-          ( α a)
-          ( β a))
-      ( H)
-      ( K)
-      ( H')
-      ( K')
-      ( G)
-      ( I)
-      ( α)
-      ( β)
+  concat-section-htpy-over a =
+    concat-section-dependent-identification
+      ( H a) (K a) (H' (sA a)) (K' (sA a)) sB (F a) (G a) (I a) (α a) (β a)
 
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
@@ -703,38 +662,97 @@ module _
 
 module _
   {l1 l2 l3 l4 : Level}
-  {A : UU l1} {P : A → UU l2}
-  {B : UU l3} {Q : B → UU l4}
-  (f : A → B)
-  (f' : {a : A} → P a → Q (f a))
+  {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
+  (f : A → B) (f' : A' → B')
+  where
+
+  htpy-hom-map :
+    (hA : A' → A) (hB : B' → B) →
+    coherence-square-maps f' hA hB f →
+    (hA' : A' → A) (hB' : B' → B) →
+    coherence-square-maps f' hA' hB' f →
+    hA ~ hA' → hB ~ hB' →
+    UU (l2 ⊔ l3)
+  htpy-hom-map hA hB H hA' hB' H' σA σB = H ∙h (σB ·r f') ~ (f ·l σA) ∙h H'
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3}
+  {X : UU l4} {Y : UU l5} {Z : UU l6}
+  (f : A → B) (g : B → C)
+  (f' : X → Y) (g' : Y → Z)
+  (hA hA' : X → A) (hB hB' : Y → B) (hC hC' : Z → C)
+  (σA : hA ~ hA') (σB : hB ~ hB') (σC : hC ~ hC')
+  (NL : coherence-square-maps f' hA hB f)
+  (FL : coherence-square-maps f' hA' hB' f)
+  (α : htpy-hom-map f f' hA hB NL hA' hB' FL σA σB)
+  (NR : coherence-square-maps g' hB hC g)
+  (FR : coherence-square-maps g' hB' hC' g)
+  (β : htpy-hom-map g g' hB hC NR hB' hC' FR σB σC)
+  where
+  open import foundation.commuting-squares-of-homotopies
+
+  comp-htpy-hom-map :
+    htpy-hom-map (g ∘ f) (g' ∘ f')
+      hA hC
+      ( pasting-horizontal-coherence-square-maps f' g' hA hB hC f g NL NR)
+      hA' hC'
+      ( pasting-horizontal-coherence-square-maps f' g' hA' hB' hC' f g FL FR)
+      σA σC
+  comp-htpy-hom-map =
+    left-whisker-concat-coherence-square-homotopies (g ·l NL)
+      ( g ·l σB ·r f') (NR ·r f') (FR ·r f') (σC ·r (g' ∘ f'))
+      ( β ·r f') ∙h
+    right-whisker-concat-htpy
+      ( inv-htpy
+          ( distributive-left-whisker-comp-concat g NL (σB ·r f')) ∙h
+        left-whisker-comp² g α ∙h
+        distributive-left-whisker-comp-concat g (f ·l σA) FL ∙h
+        right-whisker-concat-htpy
+          ( preserves-comp-left-whisker-comp g f σA)
+          ( g ·l FL))
+      ( FR ·r f') ∙h
+    assoc-htpy ((g ∘ f) ·l σA) (g ·l FL) (FR ·r f')
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
+  (f : A → B) (f' : A' → B')
+  (hA : A' → A) (hB : B' → B)
+  (H : coherence-square-maps f' hA hB f)
   where
 
   section-displayed-map-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4)
   section-displayed-map-over =
-    Σ ( section (pr1 {B = P}))
+    Σ ( section hA)
       ( λ sA →
-        Σ ( section (pr1 {B = Q}))
+        Σ ( section hB)
           ( λ sB →
-            Σ ( coherence-square-maps f
-                ( map-section pr1 sA)
-                ( map-section pr1 sB)
-                ( tot-map-over f (λ a → f' {a})))
-              ( λ H →
-                ( ( pasting-vertical-coherence-square-maps
-                    ( f)
-                    ( map-section pr1 sA)
-                    ( map-section pr1 sB)
-                    ( tot-map-over f (λ a → f' {a}))
-                    ( pr1)
-                    ( pr1)
-                    ( f)
-                    ( H)
-                    ( refl-htpy))) ∙h
-                  ( is-section-map-section pr1 sB ·r f) ~
-                ( f ·l is-section-map-section pr1 sA) ∙h refl-htpy)))
+            Σ ( coherence-square-maps
+                f (map-section hA sA) (map-section hB sB) f')
+              ( λ K →
+                htpy-hom-map f f
+                  ( hA ∘ map-section hA sA)
+                  ( hB ∘ map-section hB sB)
+                  ( pasting-vertical-coherence-square-maps f
+                    ( map-section hA sA) (map-section hB sB) f' hA hB f K H)
+                  id id refl-htpy
+                  ( is-section-map-section hA sA)
+                  ( is-section-map-section hB sB))))
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {P : A → UU l2}
+  {B : UU l3} {Q : B → UU l4}
+  (f : A → B)
+  (f' : {a : A} → P a → Q (f a))
+  where
 
   sect-map-over-section-map-over :
-    (s : section-displayed-map-over) →
+    (s :
+      section-displayed-map-over f
+        (tot-map-over f (λ a → f' {a}))
+        pr1 pr1 refl-htpy) →
     section-map-over f
       ( f')
       ( sect-section P (pr1 s))
@@ -784,6 +802,14 @@ module _
     (a : A) →
     (map-section-family s ·l H) a ＝ eq-pair-Σ (H a) (apd s (H a))
   left-whisker-dependent-function-lemma a = ap-map-section-family-lemma s (H a)
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+  concat-vertical-eq-pair :
+    {x y : A} (p : x ＝ y) {x' : B x} {y' z' : B y} →
+    (q : dependent-identification B p x' y') → (r : y' ＝ z') →
+    eq-pair-Σ p (q ∙ r) ＝ eq-pair-Σ p q ∙ eq-pair-eq-fiber r
+  concat-vertical-eq-pair {x} refl q r = ap-concat (pair x) q r
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2}
@@ -827,6 +853,254 @@ module _
       ( inv (ap-comp (tot-map-over g g') (pair (f a)) (F a)) ∙
         ap-comp (pair (g (f a))) (g' (f a)) (F a)) ∙
     inv (ap-concat (pair (g (f a))) (ap (g' (f a)) (F a)) (G (f a)))
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4}
+  {f g : A → B} {f' g' : X → Y}
+  (top : f' ~ g') (bottom : f ~ g)
+  {hA : X → A} {hB : Y → B}
+  (N : f ∘ hA ~ hB ∘ f') (F : g ∘ hA ~ hB ∘ g')
+  where
+
+  hom-htpy : UU (l2 ⊔ l3)
+  hom-htpy = N ∙h (hB ·l top) ~ (bottom ·r hA) ∙h F
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4}
+  (f g : A → B) (f' g' : X → Y)
+  (bottom : f ~ g) (top : f' ~ g')
+  (hA : X → A) (hB : Y → B)
+  (N : f ∘ hA ~ hB ∘ f') (F : g ∘ hA ~ hB ∘ g')
+  (α : hom-htpy top bottom N F)
+  (hA' : X → A) (hB' : Y → B)
+  (N' : f ∘ hA' ~ hB' ∘ f') (F' : g ∘ hA' ~ hB' ∘ g')
+  (β : hom-htpy top bottom N' F')
+  (σA : hA ~ hA') (σB : hB ~ hB')
+  (γN : htpy-hom-map f f' hA hB N hA' hB' N' σA σB)
+  (γF : htpy-hom-map g g' hA hB F hA' hB' F' σA σB)
+  where
+  open import foundation.commuting-squares-of-homotopies
+
+  nudged-α nudged-β :
+    (N ∙h (hB ·l top)) ∙h (σB ·r g') ~
+    (f ·l σA) ∙h ((bottom ·r hA') ∙h F')
+  nudged-α =
+    right-whisker-concat-htpy α (σB ·r g') ∙h
+    assoc-htpy (bottom ·r hA) F (σB ·r g') ∙h
+    left-whisker-concat-htpy (bottom ·r hA) γF ∙h
+    right-whisker-concat-coherence-square-homotopies
+      ( f ·l σA)
+      ( bottom ·r hA)
+      ( bottom ·r hA')
+      ( g ·l σA)
+      ( λ x → nat-htpy bottom (σA x))
+      ( F')
+  nudged-β =
+    left-whisker-concat-coherence-square-homotopies N
+      ( σB ·r f')
+      ( hB ·l top)
+      ( hB' ·l top)
+      ( σB ·r g')
+      ( λ x → inv (nat-htpy σB (top x))) ∙h
+    right-whisker-concat-htpy γN (hB' ·l top) ∙h
+    assoc-htpy (f ·l σA) N' (hB' ·l top) ∙h
+    left-whisker-concat-htpy (f ·l σA) β
+
+  htpy-hom-htpy : UU (l2 ⊔ l3)
+  htpy-hom-htpy = nudged-α ~ nudged-β
+
+module _
+  {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+  (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+  {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
+  (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
+  (top : h' ∘ f' ~ k' ∘ g')
+  (bottom : h ∘ f ~ k ∘ g)
+  (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
+  (back-left : (f ∘ hA) ~ (hB ∘ f'))
+  (back-right : (g ∘ hA) ~ (hC ∘ g'))
+  (front-left : (h ∘ hB) ~ (hD ∘ h'))
+  (front-right : (k ∘ hC) ~ (hD ∘ k'))
+  (α :
+    coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
+      top back-left back-right front-left front-right bottom)
+  (hA' : A' → A) (hB' : B' → B) (hC' : C' → C) (hD' : D' → D)
+  (back-left' : (f ∘ hA') ~ (hB' ∘ f'))
+  (back-right' : (g ∘ hA') ~ (hC' ∘ g'))
+  (front-left' : (h ∘ hB') ~ (hD' ∘ h'))
+  (front-right' : (k ∘ hC') ~ (hD' ∘ k'))
+  (β :
+    coherence-cube-maps f g h k f' g' h' k' hA' hB' hC' hD'
+      top back-left' back-right' front-left' front-right' bottom)
+  (σA : hA ~ hA') (σB : hB ~ hB') (σC : hC ~ hC') (σD : hD ~ hD')
+  (back-left-H : htpy-hom-map f f' hA hB back-left hA' hB' back-left' σA σB)
+  (back-right-H : htpy-hom-map g g' hA hC back-right hA' hC' back-right' σA σC)
+  (front-left-H : htpy-hom-map h h' hB hD front-left hB' hD' front-left' σB σD)
+  (front-right-H : htpy-hom-map k k' hC hD front-right hC' hD' front-right' σC σD)
+  where
+  open import foundation.commuting-squares-of-homotopies
+
+  htpy-hom-square :
+    UU (l4 ⊔ l1')
+  htpy-hom-square =
+    htpy-hom-htpy (h ∘ f) (k ∘ g) (h' ∘ f') (k' ∘ g') bottom top hA hD
+      ( pasting-horizontal-coherence-square-maps f' h' hA hB hD f h back-left front-left)
+      ( pasting-horizontal-coherence-square-maps g' k' hA hC hD g k back-right front-right)
+      ( α)
+      hA' hD'
+      ( pasting-horizontal-coherence-square-maps f' h' hA' hB' hD' f h back-left' front-left')
+      ( pasting-horizontal-coherence-square-maps g' k' hA' hC' hD' g k back-right' front-right')
+      ( β)
+      σA σD
+      ( comp-htpy-hom-map f h f' h' hA hA' hB hB' hD hD' σA σB σD
+        back-left back-left' back-left-H
+        front-left front-left' front-left-H)
+      ( comp-htpy-hom-map g k g' k' hA hA' hC hC' hD hD' σA σC σD
+        back-right back-right' back-right-H
+        front-right front-right' front-right-H)
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+  (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+  (H : coherence-square-maps g f k h)
+  where
+
+  id-cube :
+    coherence-cube-maps f g h k f g h k id id id id
+      H refl-htpy refl-htpy refl-htpy refl-htpy H
+  id-cube = left-unit-law-left-whisker-comp H ∙h inv-htpy-right-unit-htpy
+
+module _
+  {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+  (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+  {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
+  (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
+  (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
+  (top : (h' ∘ f') ~ (k' ∘ g'))
+  (back-left : (f ∘ hA) ~ (hB ∘ f'))
+  (back-right : (g ∘ hA) ~ (hC ∘ g'))
+  (front-left : (h ∘ hB) ~ (hD ∘ h'))
+  (front-right : (k ∘ hC) ~ (hD ∘ k'))
+  (bottom : (h ∘ f) ~ (k ∘ g))
+  (α :
+    coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
+      top back-left back-right front-left front-right bottom)
+  where
+
+  section-displayed-cube-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4 ⊔ l1' ⊔ l2' ⊔ l3' ⊔ l4')
+  section-displayed-cube-over =
+    Σ ( section-displayed-map-over f f' hA hB back-left)
+      ( λ sF →
+        Σ ( section-displayed-map-over k k' hC hD front-right)
+          ( λ sK →
+            Σ ( coherence-square-maps g
+                ( map-section hA (pr1 sF))
+                ( map-section hC (pr1 sK))
+                ( g'))
+              ( λ G →
+                Σ ( htpy-hom-map g g
+                    ( hA ∘ map-section hA (pr1 sF))
+                    ( hC ∘ map-section hC (pr1 sK))
+                    ( pasting-vertical-coherence-square-maps g
+                      ( map-section hA (pr1 sF))
+                      ( map-section hC (pr1 sK))
+                      g' hA hC g
+                      G back-right)
+                    id id refl-htpy
+                    ( is-section-map-section hA (pr1 sF))
+                    ( is-section-map-section hC (pr1 sK)))
+                  ( λ sG →
+                    Σ ( coherence-square-maps h
+                        ( map-section hB (pr1 (pr2 sF)))
+                        ( map-section hD (pr1 (pr2 sK)))
+                        ( h'))
+                      ( λ H →
+                        Σ ( htpy-hom-map h h
+                            ( hB ∘ map-section hB (pr1 (pr2 sF)))
+                            ( hD ∘ map-section hD (pr1 (pr2 sK)))
+                            ( pasting-vertical-coherence-square-maps h
+                              ( map-section hB (pr1 (pr2 sF)))
+                              ( map-section hD (pr1 (pr2 sK)))
+                              h' hB hD h
+                              H front-left)
+                            id id refl-htpy
+                            ( is-section-map-section hB (pr1 (pr2 sF)))
+                            ( is-section-map-section hD (pr1 (pr2 sK))))
+                          ( λ sH →
+                            Σ ( coherence-cube-maps f' g' h' k' f g h k
+                                ( map-section hA (pr1 sF))
+                                ( map-section hB (pr1 (pr2 sF)))
+                                ( map-section hC (pr1 sK))
+                                ( map-section hD (pr1 (pr2 sK)))
+                                ( bottom)
+                                ( pr1 (pr2 (pr2 sF)))
+                                ( G)
+                                ( H)
+                                ( pr1 (pr2 (pr2 sK)))
+                                ( top))
+                              ( λ β →
+                                htpy-hom-square f g h k f g h k bottom bottom
+                                  ( hA ∘ map-section hA (pr1 sF))
+                                  ( hB ∘ map-section hB (pr1 (pr2 sF)))
+                                  ( hC ∘ map-section hC (pr1 sK))
+                                  ( hD ∘ map-section hD (pr1 (pr2 sK)))
+                                  ( pasting-vertical-coherence-square-maps f
+                                    ( map-section hA (pr1 sF))
+                                    ( map-section hB (pr1 (pr2 sF)))
+                                    f' hA hB f
+                                    ( pr1 (pr2 (pr2 sF)))
+                                    ( back-left))
+                                  ( pasting-vertical-coherence-square-maps g
+                                    ( map-section hA (pr1 sF))
+                                    ( map-section hC (pr1 sK))
+                                    g' hA hC g
+                                    ( G)
+                                    ( back-right))
+                                  ( pasting-vertical-coherence-square-maps h
+                                    ( map-section hB (pr1 (pr2 sF)))
+                                    ( map-section hD (pr1 (pr2 sK)))
+                                    h' hB hD h
+                                    ( H)
+                                    ( front-left))
+                                  ( pasting-vertical-coherence-square-maps k
+                                    ( map-section hC (pr1 sK))
+                                    ( map-section hD (pr1 (pr2 sK)))
+                                    k' hC hD k
+                                    ( pr1 (pr2 (pr2 sK)))
+                                    ( front-right))
+                                  ( pasting-vertical-coherence-cube-maps f g h k
+                                    f' g' h' k' f g h k
+                                    hA hB hC hD
+                                    ( map-section hA (pr1 sF))
+                                    ( map-section hB (pr1 (pr2 sF)))
+                                    ( map-section hC (pr1 sK))
+                                    ( map-section hD (pr1 (pr2 sK)))
+                                    ( top)
+                                    back-left back-right front-left front-right bottom
+                                    ( bottom)
+                                    ( pr1 (pr2 (pr2 sF)))
+                                    ( G)
+                                    ( H)
+                                    ( pr1 (pr2 (pr2 sK)))
+                                    ( α)
+                                    ( β))
+                                  id id id id
+                                  refl-htpy refl-htpy refl-htpy refl-htpy
+                                  ( id-cube f g h k bottom)
+                                  ( is-section-map-section hA (pr1 sF))
+                                  ( is-section-map-section hB (pr1 (pr2 sF)))
+                                  ( is-section-map-section hC (pr1 sK))
+                                  ( is-section-map-section hD (pr1 (pr2 sK)))
+                                  ( pr2 (pr2 (pr2 sF)))
+                                  ( sG)
+                                  ( sH)
+                                  ( pr2 (pr2 (pr2 sK))))))))))
+
 module _
   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
   {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
@@ -862,61 +1136,6 @@ module _
   coh-tot-square-over (p , q) =
     ap-pr1-eq-pair-Σ (bottom p) (top q) ∙ inv right-unit
 
-  section-displayed-cube-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4 ⊔ l5 ⊔ l6 ⊔ l7 ⊔ l8)
-  section-displayed-cube-over =
-    Σ ( section-displayed-map-over {Q = Q2} f1 (f1' _))
-      ( λ sF1 →
-        Σ ( section-displayed-map-over {Q = Q4} f2 (f2' _))
-          ( λ sF2 →
-            Σ ( coherence-square-maps g1
-                ( map-section pr1 (pr1 sF1))
-                ( map-section pr1 (pr1 sF2))
-                ( tot-map-over g1 g1'))
-              ( λ G1 →
-                Σ ( coherence-square-maps g2
-                    ( map-section pr1 (pr1 (pr2 sF1)))
-                    ( map-section pr1 (pr1 (pr2 sF2)))
-                    ( tot-map-over g2 g2'))
-                  ( λ G2 →
-                    Σ ( coherence-cube-maps
-                        ( tot-map-over f1 f1')
-                        ( tot-map-over g1 g1')
-                        ( tot-map-over g2 g2')
-                        ( tot-map-over f2 f2')
-                        f1 g1 g2 f2
-                        ( map-section pr1 (pr1 sF1))
-                        ( map-section pr1 (pr1 (pr2 sF1)))
-                        ( map-section pr1 (pr1 sF2))
-                        ( map-section pr1 (pr1 (pr2 sF2)))
-                        ( bottom)
-                        ( pr1 (pr2 (pr2 sF1)))
-                        ( G1)
-                        ( G2)
-                        ( pr1 (pr2 (pr2 sF2)))
-                        ( tot-square-over))
-                      ( λ α →
-                        pasting-vertical-coherence-cube-maps f1 g1 g2 f2
-                          ( tot-map-over f1 f1')
-                          ( tot-map-over g1 g1')
-                          ( tot-map-over g2 g2')
-                          ( tot-map-over f2 f2')
-                          f1 g1 g2 f2
-                          pr1 pr1 pr1 pr1
-                          ( map-section pr1 (pr1 sF1))
-                          ( map-section pr1 (pr1 (pr2 sF1)))
-                          ( map-section pr1 (pr1 sF2))
-                          ( map-section pr1 (pr1 (pr2 sF2)))
-                          ( tot-square-over)
-                          refl-htpy refl-htpy refl-htpy refl-htpy
-                          bottom bottom
-                          ( pr1 (pr2 (pr2 sF1)))
-                          ( G1)
-                          ( G2)
-                          ( pr1 (pr2 (pr2 sF2)))
-                          ( coh-tot-square-over)
-                          ( α) ~ {!!}
-                          )))))
-
   module _
     (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p)
     (s3 : (p : P3) → Q3 p) (s4 : (p : P4) → Q4 p)
@@ -927,7 +1146,7 @@ module _
     where
     open import foundation.action-on-identifications-binary-functions
 
-    _ :
+    lemma :
       pasting-vertical-coherence-square-maps g1
         ( map-section-family s1) (map-section-family s3)
         ( tot-map-over g1 g1') (tot-map-over f1 f1')
@@ -935,8 +1154,10 @@ module _
         ( eq-pair-eq-fiber ∘ G1)
         ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})) ~
       ( λ p → eq-pair-Σ (bottom p) (top (s1 p) ∙ ap (f2' (g1 p)) (G1 p)))
-    _ = λ p → ap (eq-pair-Σ (bottom p) (top (s1 p)) ∙_) ([i] p) ∙
-              {!!}
+    lemma = λ p → ap
+              ( eq-pair-Σ (bottom p) (top (s1 p)) ∙_)
+              ( [i] p) ∙
+              ( inv (concat-vertical-eq-pair (bottom p) (top (s1 p)) (ap (f2' (g1 p)) (G1 p))))
         where
         [i] =
           λ (p : P1) →
@@ -949,29 +1170,45 @@ module _
         s1 s2 s3 s4
         G1 F1 F2 G2
         bottom top →
-      section-displayed-cube-over
+      section-displayed-cube-over f1 g1 g2 f2
+        ( tot-map-over f1 f1')
+        ( tot-map-over g1 g1')
+        ( tot-map-over g2 g2')
+        ( tot-map-over f2 f2')
+        pr1 pr1 pr1 pr1
+        ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p}))
+        refl-htpy refl-htpy refl-htpy refl-htpy
+        ( bottom)
+        ( coh-tot-square-over)
     pr1 (section-cube-over-sect-square-over α) =
       ( section-dependent-function s1) ,
       ( section-dependent-function s2) ,
-      ( λ p → eq-pair-eq-fiber (F1 p)) ,
+      ( eq-pair-eq-fiber ∘ F1) ,
       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F1 p))
     pr1 (pr2 (section-cube-over-sect-square-over α)) =
       ( section-dependent-function s3) ,
       ( section-dependent-function s4) ,
-      ( λ p → eq-pair-eq-fiber (F2 p)) ,
+      ( eq-pair-eq-fiber ∘ F2) ,
       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F2 p))
     pr2 (pr2 (section-cube-over-sect-square-over α)) =
-      ( λ p → eq-pair-eq-fiber (G1 p)) ,
-      ( λ p → eq-pair-eq-fiber (G2 p)) ,
+      ( eq-pair-eq-fiber ∘ G1) ,
+      ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G1 p)) ,
+      ( eq-pair-eq-fiber ∘ G2) ,
+      ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G2 p)) ,
       ( λ p →
         ap-binary
           ( _∙_)
           ( pasting-horizontal-comp f1' g2' s1 s2 s4 F1 G2 p)
           ( ap-map-section-family-lemma s4 (bottom p)) ∙
         {!!} ∙
+        ap (eq-pair-Σ (bottom p)) (inv (α p) ∙ assoc (top (s1 p)) (ap (f2' (g1 p)) (G1 p)) (F2 (g1 p))) ∙
+        concat-vertical-eq-pair
+          ( bottom p)
+          ( top (s1 p))
+          ( ap (f2' (g1 p)) (G1 p) ∙ F2 (g1 p)) ∙
         ap-binary
           ( _∙_)
           ( refl {x = eq-pair-Σ (bottom p) (top (s1 p))})
           ( inv (pasting-horizontal-comp g1' f2' s1 s3 s4 G1 F2 p))) ,
-      ( {!!})
+      {!!}
 ```

From dbc3f6697c3919f10eb6a3b934f3f93f29ee13fc Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 5 Feb 2025 18:54:54 +0100
Subject: [PATCH 21/33] Work

---
 .../dependent-identifications.lagda.md        |    4 +-
 .../functoriality-stuff.lagda.md              | 1838 +++++++++++------
 .../stuff-over.lagda.md                       |  740 ++++---
 3 files changed, 1673 insertions(+), 909 deletions(-)

diff --git a/src/foundation/dependent-identifications.lagda.md b/src/foundation/dependent-identifications.lagda.md
index 4a1da7c967..77743467f5 100644
--- a/src/foundation/dependent-identifications.lagda.md
+++ b/src/foundation/dependent-identifications.lagda.md
@@ -116,14 +116,14 @@ module _
     dependent-identification B p x' y' →
     dependent-identification B q y' z' →
     dependent-identification B (p ∙ q) x' z'
-  concat-dependent-identification refl q refl q' = q'
+  concat-dependent-identification refl q p' q' = ap (tr B q) p' ∙ q'
 
   compute-concat-dependent-identification-left-base-refl :
     { y z : A} (q : y ＝ z) →
     { x' y' : B y} {z' : B z} (p' : x' ＝ y') →
     ( q' : dependent-identification B q y' z') →
     concat-dependent-identification refl q p' q' ＝ ap (tr B q) p' ∙ q'
-  compute-concat-dependent-identification-left-base-refl q refl q' = refl
+  compute-concat-dependent-identification-left-base-refl q p' q' = refl
 ```
 
 #### Strictly right unital concatenation of dependent identifications
diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index 37d0bbeb1a..ea2ed0e2ff 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -56,667 +56,1273 @@ open import synthetic-homotopy-theory.universal-property-sequential-colimits
 New idea: instead of bruteforcing this direction, show that a square induces
 coherent cubes, and show that it's an equivalence because it fits in a diagram.
 
+## Commuting cubes induce commuting squares in the colimit
+
 ```agda
-nat-lemma :
-  {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
-  {P : A → UU l3} {Q : B → UU l4}
-  (f : A → B) (h : (a : A) → P a → Q (f a))
-  {x y : A} {p : x ＝ y}
-  {q : f x ＝ f y} (α : ap f p ＝ q) →
-  coherence-square-maps
-    ( tr P p)
-    ( h x)
-    ( h y)
-    ( tr Q q)
-nat-lemma f h {p = p} refl x =
-  substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
+open import foundation.commuting-cubes-of-maps
+module _
+  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+  (up-a : universal-property-sequential-colimit a)
+  {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
+  (up-b : universal-property-sequential-colimit b)
+  {P : sequential-diagram l5} {V : UU l6} {p : cocone-sequential-diagram P V}
+  (up-p : universal-property-sequential-colimit p)
+  {Q : sequential-diagram l7} {W : UU l8} {q : cocone-sequential-diagram Q W}
+  (up-q : universal-property-sequential-colimit q)
+  (f' : hom-sequential-diagram P Q)
+  (f : hom-sequential-diagram A B)
+  (g : hom-sequential-diagram P A)
+  (h : hom-sequential-diagram Q B)
+  where
+
+  square-cube-sequential-colimit :
+    (faces :
+      (n : ℕ) →
+      coherence-square-maps
+        ( map-hom-sequential-diagram Q f' n)
+        ( map-hom-sequential-diagram A g n)
+        ( map-hom-sequential-diagram B h n)
+        ( map-hom-sequential-diagram B f n)) →
+    (cubes :
+      (n : ℕ) →
+      coherence-cube-maps
+        ( map-hom-sequential-diagram B f n)
+        ( map-sequential-diagram A n)
+        ( map-sequential-diagram B n)
+        ( map-hom-sequential-diagram B f (succ-ℕ n))
+        ( map-hom-sequential-diagram Q f' n)
+        ( map-sequential-diagram P n)
+        ( map-sequential-diagram Q n)
+        ( map-hom-sequential-diagram Q f' (succ-ℕ n))
+        ( map-hom-sequential-diagram A g n)
+        ( map-hom-sequential-diagram B h n)
+        ( map-hom-sequential-diagram A g (succ-ℕ n))
+        ( map-hom-sequential-diagram B h (succ-ℕ n))
+        ( naturality-map-hom-sequential-diagram Q f' n)
+        ( faces n)
+        ( naturality-map-hom-sequential-diagram A g n)
+        ( naturality-map-hom-sequential-diagram B h n)
+        ( faces (succ-ℕ n))
+        ( naturality-map-hom-sequential-diagram B f n)) →
+    coherence-square-maps
+      ( map-sequential-colimit-hom-sequential-diagram up-p q f')
+      ( map-sequential-colimit-hom-sequential-diagram up-p a g)
+      ( map-sequential-colimit-hom-sequential-diagram up-q b h)
+      ( map-sequential-colimit-hom-sequential-diagram up-a b f)
+  square-cube-sequential-colimit faces cubes =
+    inv-htpy
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-p up-a b
+        f g) ∙h
+    induced-htpy ∙h
+    preserves-comp-map-sequential-colimit-hom-sequential-diagram up-p up-q b h f'
+    where
+    comp1 comp2 : hom-sequential-diagram P B
+    comp1 = comp-hom-sequential-diagram P A B f g
+    comp2 = comp-hom-sequential-diagram P Q B h f'
+    induced-hom-htpy : htpy-hom-sequential-diagram B comp1 comp2
+    pr1 induced-hom-htpy = faces
+    pr2 induced-hom-htpy n =
+      assoc-htpy _ _ _ ∙h
+      inv-htpy (cubes n) ∙h
+      assoc-htpy _ _ _
+    induced-htpy :
+      map-sequential-colimit-hom-sequential-diagram up-p b comp1 ~
+      map-sequential-colimit-hom-sequential-diagram up-p b comp2
+    induced-htpy =
+      htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-p b
+        ( induced-hom-htpy)
 ```
 
-```agda
-open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
-open import synthetic-homotopy-theory.total-cocones-families-sequential-diagrams
-open import synthetic-homotopy-theory.total-sequential-diagrams
+## Concatenation of homotopies of morphisms of sequential diagrams
 
-open import foundation.action-on-identifications-functions
-open import foundation.commuting-squares-of-identifications
-open import foundation.functoriality-dependent-pair-types
-open import foundation.equality-dependent-pair-types
-open import foundation.identity-types
-open import synthetic-homotopy-theory.sequential-colimits
-open import synthetic-homotopy-theory.functoriality-sequential-colimits
+```agda
+open import foundation.whiskering-homotopies-concatenation
 module _
-  {l1 l2 l3 l4 : Level}
-  {A : sequential-diagram l1}
-  {X : UU l2} {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  (P : family-with-descent-data-sequential-colimit c l3)
-  {Y : UU l4}
-  {c' :
-    cocone-sequential-diagram
-      ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
-      ( Y)}
-  (up-c' : universal-property-sequential-colimit c')
+  {l1 l2 : Level}
+  {A : sequential-diagram l1} {B : sequential-diagram l2}
+  (f g h : hom-sequential-diagram A B)
   where
 
-  mediating-cocone :
-    cocone-sequential-diagram
-      ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
-      ( Σ X (family-cocone-family-with-descent-data-sequential-colimit P))
-  pr1 mediating-cocone n =
-    map-Σ
-      ( family-cocone-family-with-descent-data-sequential-colimit P)
-      ( map-cocone-sequential-diagram c n)
-      ( λ a → map-equiv-descent-data-family-with-descent-data-sequential-colimit P n a)
-  pr2 mediating-cocone n (a , p) =
-    eq-pair-Σ
-      ( coherence-cocone-sequential-diagram c n a)
+  module _
+    (H : htpy-hom-sequential-diagram B f g)
+    (K : htpy-hom-sequential-diagram B g h)
+    where
+
+    concat-htpy-hom-sequential-diagram : htpy-hom-sequential-diagram B f h
+    pr1 concat-htpy-hom-sequential-diagram n =
+      htpy-htpy-hom-sequential-diagram _ H n ∙h
+      htpy-htpy-hom-sequential-diagram _ K n
+    pr2 concat-htpy-hom-sequential-diagram n =
+      inv-htpy-assoc-htpy _ _ _ ∙h
+      right-whisker-concat-htpy
+        ( coherence-htpy-htpy-hom-sequential-diagram B H n)
+        ( htpy-htpy-hom-sequential-diagram _ K (succ-ℕ n) ·r map-sequential-diagram A n) ∙h
+      assoc-htpy _ _ _ ∙h
+      left-whisker-concat-htpy
+        ( map-sequential-diagram B n ·l htpy-htpy-hom-sequential-diagram _ H n)
+        ( coherence-htpy-htpy-hom-sequential-diagram B K n) ∙h
+      inv-htpy-assoc-htpy _ _ _ ∙h
+      right-whisker-concat-htpy
+        ( inv-htpy
+          ( distributive-left-whisker-comp-concat
+            ( map-sequential-diagram B n)
+            ( htpy-htpy-hom-sequential-diagram _ H n)
+            ( htpy-htpy-hom-sequential-diagram _ K n)))
+        ( naturality-map-hom-sequential-diagram B h n)
+
+  htpy-eq-concat-hom-sequential-diagram :
+    (p : f ＝ g) (q : g ＝ h) →
+    htpy-eq-sequential-diagram A B f h (p ∙ q) ＝
+    concat-htpy-hom-sequential-diagram
+      ( htpy-eq-sequential-diagram A B f g p)
+      ( htpy-eq-sequential-diagram A B g h q)
+  htpy-eq-concat-hom-sequential-diagram refl refl =
+    eq-pair-eq-fiber
+      ( inv
+        ( eq-binary-htpy _ _
+          λ n a →
+          right-unit ∙ right-unit ∙
+          ap
+            ( (inv (assoc _ refl refl) ∙ ap (_∙ refl) right-unit) ∙ refl ∙_)
+            ( ap-id right-unit) ∙
+          ap
+            ( _∙ right-unit)
+            ( right-unit ∙
+              ap
+                ( λ p → inv p ∙ ap (_∙ refl) right-unit)
+                ( middle-unit-law-assoc
+                    ( naturality-map-hom-sequential-diagram B f n a)
+                    ( refl)) ∙
+              left-inv (ap (_∙ refl) right-unit))))
+    where
+      open import foundation.binary-homotopies
+      open import foundation.path-algebra
+
+  eq-htpy-concat-hom-sequential-diagram :
+    (H : htpy-hom-sequential-diagram B f g)
+    (K : htpy-hom-sequential-diagram B g h) →
+    eq-htpy-sequential-diagram A B f h
+      ( concat-htpy-hom-sequential-diagram H K) ＝
+    eq-htpy-sequential-diagram A B f g H ∙
+    eq-htpy-sequential-diagram A B g h K
+  eq-htpy-concat-hom-sequential-diagram H K =
+    ap
+      ( eq-htpy-sequential-diagram A B f h)
       ( inv
-        ( coherence-square-equiv-descent-data-family-with-descent-data-sequential-colimit P n a p))
-
-  totι' : Y → Σ X (family-cocone-family-with-descent-data-sequential-colimit P)
-  totι' =
-    map-universal-property-sequential-colimit up-c' mediating-cocone
-  triangle-pr1∞-pr1 :
-    pr1-sequential-colimit-total-sequential-diagram
-      ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)
-      ( up-c')
-      ( c) ~
-    pr1 ∘ totι'
-  triangle-pr1∞-pr1 =
-    htpy-htpy-out-of-sequential-colimit up-c'
-      ( concat-htpy-cocone-sequential-diagram
-        ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c' c
-          ( pr1-total-sequential-diagram
-            ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)))
-        ( ( λ n →
-            inv-htpy (pr1 ·l (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n))) ,
-          ( λ n x →
-            ap (_∙ inv (ap pr1 (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))) right-unit ∙
-            horizontal-inv-coherence-square-identifications _
-              ( ap (pr1 ∘ totι') (coherence-cocone-sequential-diagram c' n x))
-              ( coherence-cocone-sequential-diagram c n (pr1 x))
-              _
-              ( ( ap
-                  ( _∙ ap pr1
-                    ( pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))
-                  ( ap-comp pr1
-                    ( totι')
-                    ( coherence-cocone-sequential-diagram c' n x))) ∙
-                ( inv
-                  ( ap-concat pr1
-                    ( ap
-                      ( totι')
-                      ( coherence-cocone-sequential-diagram c' n x)) _)) ∙
-                ( ap (ap pr1) (pr2 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n x)) ∙
-                ( ap-concat pr1
-                  ( pr1
-                    ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
-                    n x)
-                  ( coherence-cocone-sequential-diagram mediating-cocone n x)) ∙
-                ( ap
-                  ( ap pr1
-                    ( pr1
-                      ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
-                      n x) ∙_)
-                  ( ap-pr1-eq-pair-Σ
-                    ( coherence-cocone-sequential-diagram c n (pr1 x))
-                    ( _)))))))
+        ( htpy-eq-concat-hom-sequential-diagram
+          ( eq-htpy-sequential-diagram A B f g H)
+          ( eq-htpy-sequential-diagram A B g h K) ∙
+        ap-binary concat-htpy-hom-sequential-diagram
+          ( is-section-map-inv-equiv
+            ( extensionality-hom-sequential-diagram A B f g)
+            ( H))
+          ( is-section-map-inv-equiv
+            ( extensionality-hom-sequential-diagram A B g h)
+            ( K)))) ∙
+    is-retraction-map-inv-equiv
+      ( extensionality-hom-sequential-diagram A B f h)
+      ( eq-htpy-sequential-diagram A B f g H ∙
+        eq-htpy-sequential-diagram A B g h K)
+    where open import foundation.action-on-identifications-binary-functions
 ```
 
+## Whiskering of homotopies of morphisms of sequential diagrams
+
+### Right whiskering
+
 ```agda
 module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : sequential-diagram l1} {X : UU l2}
-  {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  {B : sequential-diagram l3} {Y : UU l4}
-  {c' : cocone-sequential-diagram B Y}
-  (up-c' : universal-property-sequential-colimit c')
-  (P : X → UU l5) (Q : Y → UU l6)
-  (f : hom-sequential-diagram A B)
-  (f' :
-    (x : X) → P x →
-    Q (map-sequential-colimit-hom-sequential-diagram up-c c' f x))
+  {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3}
   where
 
-  open import synthetic-homotopy-theory.flattening-lemma-sequential-colimits
-
-  ΣAP : sequential-diagram (l1 ⊔ l5)
-  ΣAP =
-    total-sequential-diagram (dependent-sequential-diagram-family-cocone c P)
-
-  ΣBQ : sequential-diagram (l3 ⊔ l6)
-  ΣBQ =
-    total-sequential-diagram (dependent-sequential-diagram-family-cocone c' Q)
-
-  totff' : hom-sequential-diagram ΣAP ΣBQ
-  pr1 totff' n =
-    map-Σ _
-      ( map-hom-sequential-diagram B f n)
-      ( λ a →
-        tr Q
-          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-            up-c c' f n a) ∘
-        f' (map-cocone-sequential-diagram c n a))
-  pr2 totff' = {!!}
-
-  totff'∞ : Σ X P → Σ Y Q
-  totff'∞ =
-    map-sequential-colimit-hom-sequential-diagram
-      ( flattening-lemma-sequential-colimit _ P up-c)
-      ( total-cocone-family-cocone-sequential-diagram c' Q)
-      ( totff')
-
-  _ :
-    totι' up-c
-      ( family-with-descent-data-family-cocone-sequential-diagram c P)
-      ( flattening-lemma-sequential-colimit c P up-c) ~
-    id
-  _ =
-    compute-map-universal-property-sequential-colimit-id
-      ( flattening-lemma-sequential-colimit _ P up-c)
-
-  _ :
-    coherence-square-maps
-      ( totι' up-c
-        ( family-with-descent-data-family-cocone-sequential-diagram c P)
-        ( flattening-lemma-sequential-colimit c P up-c))
-      ( totff'∞)
-      ( map-Σ Q
-        ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
-        f')
-      ( totι' up-c'
-        ( family-with-descent-data-family-cocone-sequential-diagram c' Q)
-        ( flattening-lemma-sequential-colimit c' Q up-c'))
-  _ =
-    ( compute-map-universal-property-sequential-colimit-id
-      ( flattening-lemma-sequential-colimit c' Q up-c') ·r _) ∙h
-    ( htpy-htpy-out-of-sequential-colimit
-      ( flattening-lemma-sequential-colimit c P up-c)
-      ( concat-htpy-cocone-sequential-diagram
-        ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-          ( flattening-lemma-sequential-colimit c P up-c)
-          ( total-cocone-family-cocone-sequential-diagram c' Q)
-          ( totff'))
-        ( ( λ n (a , p) →
-            inv
-              ( eq-pair-Σ
-                ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
-                  ( f)
-                  ( n)
-                  ( a))
-                refl)) ,
-          {!!}))) ∙h
-    ( _ ·l
-      ( inv-htpy
-        (compute-map-universal-property-sequential-colimit-id
-          ( flattening-lemma-sequential-colimit c P up-c))))
-
-    -- htpy-htpy-out-of-sequential-colimit
-    --   ( flattening-lemma-sequential-colimit c P up-c)
-    --   ( {!!})
+  htpy-eq-right-whisker :
+    {f g : B → C} (p : f ＝ g) (h : A → B) →
+    htpy-eq (ap (_∘ h) p) ＝ htpy-eq p ·r h
+  htpy-eq-right-whisker refl h = refl
+
+  eq-htpy-right-whisker :
+    {f g : B → C} (H : f ~ g) (h : A → B) →
+    eq-htpy (H ·r h) ＝ ap (_∘ h) (eq-htpy H)
+  eq-htpy-right-whisker H h =
+    ap eq-htpy
+      ( inv
+        ( htpy-eq-right-whisker (eq-htpy H) h ∙
+          ap (_·r h) (is-section-eq-htpy H))) ∙
+    is-retraction-eq-htpy (ap (_∘ h) (eq-htpy H))
+
+  htpy-eq-left-whisker :
+    {f g : A → B} (h : B → C) (p : f ＝ g) →
+    htpy-eq (ap (h ∘_) p) ＝ h ·l htpy-eq p
+  htpy-eq-left-whisker h refl = refl
+
+  -- alternatively, using homotopy induction
+  eq-htpy-left-whisker :
+    {f g : A → B} (h : B → C) (H : f ~ g) →
+    eq-htpy (h ·l H) ＝ ap (h ∘_) (eq-htpy H)
+  eq-htpy-left-whisker {f} h =
+    ind-htpy f
+      ( λ g H →
+        eq-htpy (h ·l H) ＝ ap (h ∘_) (eq-htpy H))
+      ( eq-htpy-refl-htpy (h ∘ f) ∙
+        inv (ap (ap (h ∘_)) (eq-htpy-refl-htpy f)))
+    where open import foundation.homotopy-induction
 ```
 
 ```agda
 module _
-  {l1 l2 l3 l4 : Level}
-  {A : sequential-diagram l1} {X : UU l2}
-  {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  {B : sequential-diagram l3} {Y : UU l4}
-  {c' : cocone-sequential-diagram B Y}
-  (up-c' : universal-property-sequential-colimit c')
-  (f : hom-sequential-diagram A B)
+  {l1 l2 l3 : Level}
+  {A : sequential-diagram l1} {B : sequential-diagram l2}
+  {X : sequential-diagram l3}
+  {f g : hom-sequential-diagram A B}
   where
-  open import foundation.homotopies-morphisms-arrows
+  open import foundation.whiskering-identifications-concatenation
 
-  interm :
-    coherence-square-maps
-      ( id)
-      ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
-      ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
-      ( id)
-  interm =
-    htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-c c'
-      ( refl-htpy-hom-sequential-diagram A B f)
-
-  preserves-refl-htpy-sequential-colimit :
-    htpy-hom-arrow
-      ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
-      ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
-      ( id , id , interm)
-      ( id , id , refl-htpy)
-  pr1 preserves-refl-htpy-sequential-colimit = refl-htpy
-  pr1 (pr2 preserves-refl-htpy-sequential-colimit) = refl-htpy
-  pr2 (pr2 preserves-refl-htpy-sequential-colimit) =
-    right-unit-htpy ∙h
-    htpy-eq
+  module _
+    (H : htpy-hom-sequential-diagram B f g)
+    (h : hom-sequential-diagram X A)
+    where
+
+    right-whisker-concat-htpy-hom-sequential-diagram :
+      htpy-hom-sequential-diagram B
+        ( comp-hom-sequential-diagram X A B f h)
+        ( comp-hom-sequential-diagram X A B g h)
+    pr1 right-whisker-concat-htpy-hom-sequential-diagram n =
+      htpy-htpy-hom-sequential-diagram _ H n ·r map-hom-sequential-diagram A h n
+    pr2 right-whisker-concat-htpy-hom-sequential-diagram n x =
+      assoc _ _ _ ∙
+      left-whisker-concat
+        ( naturality-map-hom-sequential-diagram B f n (map-hom-sequential-diagram A h n x))
+        ( inv-nat-htpy
+          ( htpy-htpy-hom-sequential-diagram B H (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram A h n x)) ∙
+      inv (assoc _ _ _) ∙
+      right-whisker-concat
+        ( coherence-htpy-htpy-hom-sequential-diagram B H n (map-hom-sequential-diagram A h n x))
+        ( ap
+          ( map-hom-sequential-diagram B g (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram A h n x)) ∙
+      assoc _ _ _
+
+  htpy-eq-right-whisker-htpy-hom-sequential-diagram :
+    (p : f ＝ g) (h : hom-sequential-diagram X A) →
+    htpy-eq-sequential-diagram X B
+      ( comp-hom-sequential-diagram X A B f h)
+      ( comp-hom-sequential-diagram X A B g h)
+      ( ap (λ f → comp-hom-sequential-diagram X A B f h) p) ＝
+    right-whisker-concat-htpy-hom-sequential-diagram
+      ( htpy-eq-sequential-diagram A B f g p)
+      ( h)
+  htpy-eq-right-whisker-htpy-hom-sequential-diagram refl h =
+    eq-pair-eq-fiber
+      ( eq-binary-htpy _ _
+        λ n x →
+        inv
+          ( right-unit ∙
+            ap-binary
+              ( λ p q →
+                p ∙
+                left-whisker-concat _ q ∙
+                inv (assoc _ refl _) ∙
+                right-whisker-concat _ _)
+              ( right-unit-law-assoc _ _)
+              ( inv-nat-refl-htpy _ _) ∙
+            ap
+              ( λ p →
+                right-unit ∙
+                left-whisker-concat _ (inv right-unit) ∙
+                left-whisker-concat _ right-unit ∙
+                inv p ∙
+                right-whisker-concat right-unit _)
+              ( middle-unit-law-assoc _ _) ∙
+            is-section-inv-concat'
+              ( right-whisker-concat right-unit _)
+              ( right-unit ∙
+                left-whisker-concat _ (inv right-unit) ∙
+                left-whisker-concat _ right-unit) ∙
+            ap
+              ( λ p → right-unit ∙ p ∙ left-whisker-concat _ right-unit)
+              ( ap-inv (naturality-map-hom-sequential-diagram B f n _ ∙_) right-unit) ∙
+            is-section-inv-concat'
+              ( ap (naturality-map-hom-sequential-diagram B f n _ ∙_) right-unit)
+              ( right-unit)))
+    where
+      open import foundation.binary-homotopies
+      open import foundation.path-algebra
+      open import foundation.action-on-identifications-binary-functions
+
+  eq-htpy-right-whisker-htpy-hom-sequential-diagram :
+    (H : htpy-hom-sequential-diagram B f g) (h : hom-sequential-diagram X A) →
+    eq-htpy-sequential-diagram X B
+      ( comp-hom-sequential-diagram X A B f h)
+      ( comp-hom-sequential-diagram X A B g h)
+      ( right-whisker-concat-htpy-hom-sequential-diagram H h) ＝
+    ap
+      ( λ f → comp-hom-sequential-diagram X A B f h)
+      ( eq-htpy-sequential-diagram A B f g H)
+  eq-htpy-right-whisker-htpy-hom-sequential-diagram H h =
+    ap
+      ( eq-htpy-sequential-diagram X B _ _)
+      ( inv
+        ( htpy-eq-right-whisker-htpy-hom-sequential-diagram
+            ( eq-htpy-sequential-diagram A B f g H)
+            ( h) ∙
+          ap
+            ( λ H → right-whisker-concat-htpy-hom-sequential-diagram H h)
+            ( is-section-map-inv-equiv
+              ( extensionality-hom-sequential-diagram A B f g)
+              ( H)))) ∙
+    is-retraction-map-inv-equiv
+      ( extensionality-hom-sequential-diagram X B
+        ( comp-hom-sequential-diagram X A B f h)
+        ( comp-hom-sequential-diagram X A B g h))
       ( ap
-        ( htpy-eq ∘ ap (map-sequential-colimit-hom-sequential-diagram up-c c'))
-        ( is-retraction-map-inv-equiv
-          ( extensionality-hom-sequential-diagram A B f f)
-          ( refl)))
+        ( λ f → comp-hom-sequential-diagram X A B f h)
+        ( eq-htpy-sequential-diagram A B f g H))
 ```
 
+### Left whiskering
+
 ```agda
 module _
-  {l1 l2 : Level}
-  {A : sequential-diagram l1}
-  (P : descent-data-sequential-colimit A l2)
+  {l1 l2 l3 : Level}
+  {A : sequential-diagram l1} {B : sequential-diagram l2}
+  {X : sequential-diagram l3}
+  (h : hom-sequential-diagram B X)
+  {f g : hom-sequential-diagram A B}
+  (H : htpy-hom-sequential-diagram B f g)
   where
+  open import foundation.whiskering-identifications-concatenation
 
-  section-descent-data-sequential-colimit : UU (l1 ⊔ l2)
-  section-descent-data-sequential-colimit =
-    Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
-        family-descent-data-sequential-colimit P n a)
-      ( λ s →
-        (n : ℕ) (a : family-sequential-diagram A n) →
-        map-family-descent-data-sequential-colimit P n a (s n a) ＝
-        s (succ-ℕ n) (map-sequential-diagram A n a))
+  left-whisker-concat-htpy-hom-sequential-diagram :
+    htpy-hom-sequential-diagram X
+      ( comp-hom-sequential-diagram A B X h f)
+      ( comp-hom-sequential-diagram A B X h g)
+  pr1 left-whisker-concat-htpy-hom-sequential-diagram n =
+    map-hom-sequential-diagram X h n ·l htpy-htpy-hom-sequential-diagram _ H n
+  pr2 left-whisker-concat-htpy-hom-sequential-diagram n a =
+    assoc _ _ _ ∙
+    left-whisker-concat
+      ( naturality-map-hom-sequential-diagram X h n (map-hom-sequential-diagram B f n a))
+      ( inv (ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
+        ap
+          ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
+          ( coherence-htpy-htpy-hom-sequential-diagram B H n a) ∙
+        ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
+    inv (assoc _ _ _) ∙
+    right-whisker-concat
+      ( left-whisker-concat
+          ( naturality-map-hom-sequential-diagram X h n
+            ( map-hom-sequential-diagram B f n a))
+          ( inv
+            ( ap-comp
+              ( map-hom-sequential-diagram X h (succ-ℕ n))
+              ( map-sequential-diagram B n)
+              ( htpy-htpy-hom-sequential-diagram B H n a))) ∙
+        nat-htpy
+          ( naturality-map-hom-sequential-diagram X h n)
+          ( htpy-htpy-hom-sequential-diagram B H n a) ∙
+        right-whisker-concat
+          ( ap-comp
+            ( map-sequential-diagram X n)
+            ( map-hom-sequential-diagram X h n)
+            ( htpy-htpy-hom-sequential-diagram B H n a))
+          ( naturality-map-hom-sequential-diagram X h n
+            ( map-hom-sequential-diagram B g n a)))
+      ( ap
+        ( map-hom-sequential-diagram X h (succ-ℕ n))
+        ( naturality-map-hom-sequential-diagram B g n a)) ∙
+    assoc _ _ _
+```
 
-module _
-  {l1 l2 l3 : Level}
-  {A : sequential-diagram l1}
-  {X : UU l2} {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  (P : X → UU l3)
-  where
+## Action on homotopies of morphisms of sequential diagrams preserves whiskering
 
-  sect-family-sect-dd-sequential-colimit :
-    section-descent-data-sequential-colimit
-      ( descent-data-family-cocone-sequential-diagram c P) →
-    ((x : X) → P x)
-  sect-family-sect-dd-sequential-colimit s =
-    map-dependent-universal-property-sequential-colimit
-      ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
-      ( s)
+```agda
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
 ```
 
 ```agda
 module _
-  {l1 l2 l3 l4 : Level}
-  {A : sequential-diagram l1}
-  (B : sequential-diagram l2)
-  (f : hom-sequential-diagram A B)
-  (P : descent-data-sequential-colimit A l3)
-  (Q : descent-data-sequential-colimit B l4)
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+  (up-a : universal-property-sequential-colimit a)
+  {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
+  (up-b : universal-property-sequential-colimit b)
+  {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
+  {f g : hom-sequential-diagram B C}
+  (H : htpy-hom-sequential-diagram C f g)
+  (h : hom-sequential-diagram A B)
   where
 
-  hom-over-hom : UU (l1 ⊔ l3 ⊔ l4)
-  hom-over-hom =
-    Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
-        family-descent-data-sequential-colimit P n a →
-        family-descent-data-sequential-colimit Q n
-          ( map-hom-sequential-diagram B f n a))
-      ( λ f'n →
-        (n : ℕ) →
-        square-over
-          { Q4 = family-descent-data-sequential-colimit Q (succ-ℕ n)}
-          ( map-sequential-diagram A n)
-          ( map-hom-sequential-diagram B f n)
-          ( map-hom-sequential-diagram B f (succ-ℕ n))
-          ( map-sequential-diagram B n)
-          ( λ {a} → map-family-descent-data-sequential-colimit P n a)
-          ( λ {a} → f'n n a)
-          ( λ {a} → f'n (succ-ℕ n) a)
-          ( λ {a} → map-family-descent-data-sequential-colimit Q n a)
-          ( naturality-map-hom-sequential-diagram B f n))
+  preserves-right-whisker-htpy-hom-sequential-diagram :
+    ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
+        ( right-whisker-concat-htpy-hom-sequential-diagram H h)) ∙h
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h)) ~
+    ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙h
+      ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-b c H ·r
+        map-sequential-colimit-hom-sequential-diagram up-a b h))
+  preserves-right-whisker-htpy-hom-sequential-diagram =
+    right-whisker-concat-htpy
+      ( htpy-eq
+        ( ap
+          ( λ p →
+            htpy-eq
+              ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p))
+          ( eq-htpy-right-whisker-htpy-hom-sequential-diagram H h)))
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h) ∙h
+    {!!}
+```
+
+```agda
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
-  {A : sequential-diagram l1} {X : UU l2}
-  {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  {B : sequential-diagram l3} {Y : UU l4}
-  {c' : cocone-sequential-diagram B Y}
-  (up-c' : universal-property-sequential-colimit c')
-  (f : hom-sequential-diagram A B)
-  (P : X → UU l5) (Q : Y → UU l6)
+  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+  (up-a : universal-property-sequential-colimit a)
+  {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
+  (up-b : universal-property-sequential-colimit b)
+  {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
+  (h : hom-sequential-diagram B C)
+  {f g : hom-sequential-diagram A B}
+  (H : htpy-hom-sequential-diagram B f g)
   where
 
-  private
-    f∞ : X → Y
-    f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f
-    DDMO : descent-data-sequential-colimit A (l5 ⊔ l6)
-    pr1 DDMO n a =
-      P (map-cocone-sequential-diagram c n a) →
-      Q (map-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
-    pr2 DDMO n a =
-      ( equiv-postcomp _
-        ( ( equiv-tr
-            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-            ( naturality-map-hom-sequential-diagram B f n a)) ∘e
-          ( equiv-tr Q (coherence-cocone-sequential-diagram c' n _)))) ∘e
-      ( equiv-precomp
-        ( inv-equiv (equiv-tr P (coherence-cocone-sequential-diagram c n a)))
-        ( _))
-
-  sect-over-DDMO-map-over :
-    ((a : X) → P a → Q (f∞ a)) →
-    section-descent-data-sequential-colimit DDMO
-  pr1 (sect-over-DDMO-map-over f∞') n a =
-    ( tr Q
-      ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
-    ( f∞' (map-cocone-sequential-diagram c n a))
-  pr2 (sect-over-DDMO-map-over f∞') n a =
-    eq-htpy
-      ( λ p →
-        {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a!})
-
-  sect-over-DDMO-map-over' :
-    ((a : X) → P a → Q (f∞ a)) →
-    section-descent-data-sequential-colimit DDMO
-  sect-over-DDMO-map-over' =
-    {!sect-family-sect-dd-sequential-colimit!}
-
-  map-over-sect-DDMO :
-    section-descent-data-sequential-colimit DDMO →
-    hom-over-hom B f
-      ( descent-data-family-cocone-sequential-diagram c P)
-      ( descent-data-family-cocone-sequential-diagram c' Q)
-  map-over-sect-DDMO =
-    tot
-      ( λ s →
-        map-Π
-          ( λ n →
-            ( map-implicit-Π
-              ( λ a →
-                ( concat-htpy
-                  ( inv-htpy
-                    ( ( ( tr
-                          ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-                          ( naturality-map-hom-sequential-diagram B f n a)) ∘
-                        ( tr Q
-                          ( coherence-cocone-sequential-diagram c' n
-                            (map-hom-sequential-diagram B f n a))) ∘
-                        ( s n a)) ·l
-                      ( is-retraction-inv-tr P
-                        ( coherence-cocone-sequential-diagram c n a))))
-                  ( _)) ∘
-                ( map-equiv
-                  ( equiv-htpy-precomp-htpy-Π _ _
-                    ( equiv-tr P
-                      ( coherence-cocone-sequential-diagram c n a)))) ∘
-                ( htpy-eq
-                  {f =
-                    ( tr
-                      ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-                      ( naturality-map-hom-sequential-diagram B f n a)) ∘
-                    ( tr Q
-                      ( coherence-cocone-sequential-diagram c' n
-                        ( map-hom-sequential-diagram B f n a))) ∘
-                    ( s n a) ∘
-                    ( tr P (inv (coherence-cocone-sequential-diagram c n a)))}
-                  { s (succ-ℕ n) (map-sequential-diagram A n a)}))) ∘
-            ( implicit-explicit-Π)))
-
-  map-over-diagram-map-over-colimit :
-    ((a : X) → P a → Q (f∞ a)) →
-    hom-over-hom B f
-      ( descent-data-family-cocone-sequential-diagram c P)
-      ( descent-data-family-cocone-sequential-diagram c' Q)
-  pr1 (map-over-diagram-map-over-colimit f∞') n a =
-    ( tr Q
-      ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
-    ( f∞' (map-cocone-sequential-diagram c n a))
-  pr2 (map-over-diagram-map-over-colimit f∞') n {a} =
-    pasting-vertical-coherence-square-maps
-      ( tr P (coherence-cocone-sequential-diagram c n a))
-      ( f∞' _)
-      ( f∞' _)
-      ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
-      ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
-      ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
-      ( ( tr
-          ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-          ( naturality-map-hom-sequential-diagram B f n a)) ∘
-        ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
-      ( λ q →
-        substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
-        inv (preserves-tr f∞' (coherence-cocone-sequential-diagram c n a) q))
-      ( ( inv-htpy
-          ( λ q →
-            ( tr-concat
-              ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-                up-c c' f n a)
-              ( _)
-              ( q)) ∙
-            ( tr-concat
-              ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
-              ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
-              ( tr Q
-                ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-                  up-c c' f n a)
-                ( q))) ∙
-            ( substitution-law-tr Q
-              ( map-cocone-sequential-diagram c' (succ-ℕ n))
-              ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
-        ( λ q →
-          ap
-            ( λ p → tr Q p q)
-            ( inv
-              ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
-        ( tr-concat
-          ( ap f∞ (coherence-cocone-sequential-diagram c n a))
-          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-            up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))
-
-  abstract
-    triangle-map-over-sect-DDMO :
-      coherence-triangle-maps
-        ( map-over-diagram-map-over-colimit)
-        ( map-over-sect-DDMO)
-        ( sect-over-DDMO-map-over)
-    triangle-map-over-sect-DDMO f∞' =
-      eq-pair-eq-fiber
-        ( eq-htpy
-          ( λ n →
-            eq-htpy-implicit
-              ( λ a →
-                eq-htpy
-                  ( λ p →
-                    {!!}))))
-
-    is-equiv-map-over-sect-DDMO :
-      is-equiv map-over-sect-DDMO
-    is-equiv-map-over-sect-DDMO =
-      is-equiv-tot-is-fiberwise-equiv
-        ( λ s →
-          is-equiv-map-Π-is-fiberwise-equiv
-            ( λ n →
-              is-equiv-comp _ _
-                ( is-equiv-implicit-explicit-Π)
-                ( is-equiv-map-implicit-Π-is-fiberwise-equiv
-                  ( λ a →
-                    is-equiv-comp _ _
-                      ( funext _ _)
-                      ( is-equiv-comp _ _
-                        ( is-equiv-map-equiv (equiv-htpy-precomp-htpy-Π _ _ _))
-                        ( is-equiv-concat-htpy _ _))))))
-
-    is-equiv-map-over-diagram-map-over-colimit :
-      is-equiv map-over-diagram-map-over-colimit
-    is-equiv-map-over-diagram-map-over-colimit =
-      {!is-equiv-left-map-triangle
-        ( map-over-diagram-map-over-colimit)
-        ( map-over-sect-DDMO)
-        ( sect-over-DDMO-map-over)
-        ( triangle-map-over-sect-DDMO)
-        ( is-equiv) !}
+  preserves-left-whisker-htpy-hom-sequential-diagram :
+    ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
+        ( left-whisker-concat-htpy-hom-sequential-diagram h H)) ∙h
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g)) ~
+    ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙h
+      ( map-sequential-colimit-hom-sequential-diagram up-b c h ·l
+        htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H))
+  preserves-left-whisker-htpy-hom-sequential-diagram = {!!}
 ```
 
+## Action on homotopies of morphisms of sequential diagrams preserves concatenation
+
 ```agda
-module big-thm
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : sequential-diagram l1}
-  {B : sequential-diagram l2}
-  {X : UU l3} {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  {Y : UU l4} {c' : cocone-sequential-diagram B Y}
-  (up-c' : universal-property-sequential-colimit c')
-  (H : hom-sequential-diagram A B)
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+  (up-a : universal-property-sequential-colimit a)
+  {B : sequential-diagram l3} {Y : UU l4} (b : cocone-sequential-diagram B Y)
+  {f g h : hom-sequential-diagram A B}
+  (H : htpy-hom-sequential-diagram B f g)
+  (K : htpy-hom-sequential-diagram B g h)
   where
 
-  -- the squares induce a map
+  preserves-concat-htpy-hom-sequential-diagram :
+    htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b
+      ( concat-htpy-hom-sequential-diagram f g h H K) ~
+    htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H ∙h
+    htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b K
+  preserves-concat-htpy-hom-sequential-diagram =
+    htpy-eq
+      ( ( ap
+          ( λ p →
+            htpy-eq
+              ( ap
+                ( map-sequential-colimit-hom-sequential-diagram up-a b)
+                ( p)))
+          ( eq-htpy-concat-hom-sequential-diagram f g h H K)) ∙
+        ( ap htpy-eq
+          ( ap-concat
+            ( map-sequential-colimit-hom-sequential-diagram up-a b)
+            ( eq-htpy-sequential-diagram A B f g H)
+            ( eq-htpy-sequential-diagram A B g h K))) ∙
+        ( htpy-eq-concat
+          ( ap
+            ( map-sequential-colimit-hom-sequential-diagram up-a b)
+            ( eq-htpy-sequential-diagram A B f g H))
+          ( ap
+            ( map-sequential-colimit-hom-sequential-diagram up-a b)
+            ( eq-htpy-sequential-diagram A B g h K))))
+```
+
+-- ```agda
+-- nat-lemma :
+--   {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
+--   {P : A → UU l3} {Q : B → UU l4}
+--   (f : A → B) (h : (a : A) → P a → Q (f a))
+--   {x y : A} {p : x ＝ y}
+--   {q : f x ＝ f y} (α : ap f p ＝ q) →
+--   coherence-square-maps
+--     ( tr P p)
+--     ( h x)
+--     ( h y)
+--     ( tr Q q)
+-- nat-lemma f h {p = p} refl x =
+--   substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
+-- ```
 
-  f∞ : X → Y
-  f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' H
+-- ##
 
-  Cn : (n : ℕ) →
-    f∞ ∘ map-cocone-sequential-diagram c n ~
-    map-cocone-sequential-diagram c' n ∘ map-hom-sequential-diagram B H n
-  Cn =
-    htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H
+-- ```agda
+-- open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
+-- open import synthetic-homotopy-theory.total-cocones-families-sequential-diagrams
+-- open import synthetic-homotopy-theory.total-sequential-diagrams
 
-  module _
-    (P : X → UU l5) (Q : Y → UU l6)
-    (f'∞ : {x : X} → P x → Q (f∞ x))
-    where
+-- open import foundation.action-on-identifications-functions
+-- open import foundation.commuting-squares-of-identifications
+-- open import foundation.functoriality-dependent-pair-types
+-- open import foundation.equality-dependent-pair-types
+-- open import foundation.identity-types
+-- open import synthetic-homotopy-theory.sequential-colimits
+-- open import synthetic-homotopy-theory.functoriality-sequential-colimits
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : sequential-diagram l1}
+--   {X : UU l2} {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   (P : family-with-descent-data-sequential-colimit c l3)
+--   {Y : UU l4}
+--   {c' :
+--     cocone-sequential-diagram
+--       ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
+--       ( Y)}
+--   (up-c' : universal-property-sequential-colimit c')
+--   where
 
-    An : ℕ → UU l1
-    An = family-sequential-diagram A
-    Bn : ℕ → UU l2
-    Bn = family-sequential-diagram B
-    an : {n : ℕ} → An n → An (succ-ℕ n)
-    an = map-sequential-diagram A _
-    bn : {n : ℕ} → Bn n → Bn (succ-ℕ n)
-    bn = map-sequential-diagram B _
-    fn : {n : ℕ} → An n → Bn n
-    fn = map-hom-sequential-diagram B H _
-    Hn : {n : ℕ} → bn {n} ∘ fn ~ fn ∘ an
-    Hn = naturality-map-hom-sequential-diagram B H _
-
-    -- a map-over induces squares-over
-
-    -- first, the sequences-over:
-    𝒟P : descent-data-sequential-colimit A l5
-    𝒟P = descent-data-family-cocone-sequential-diagram c P
-    𝒫 = dependent-sequential-diagram-descent-data 𝒟P
-    𝒟Q : descent-data-sequential-colimit B l6
-    𝒟Q = descent-data-family-cocone-sequential-diagram c' Q
-    𝒬 = dependent-sequential-diagram-descent-data 𝒟Q
-
-    Pn : {n : ℕ} → An n → UU l5
-    Pn = family-descent-data-sequential-colimit 𝒟P _
-    Qn : {n : ℕ} → Bn n → UU l6
-    Qn = family-descent-data-sequential-colimit 𝒟Q _
-
-    pn : {n : ℕ} (a : An n) → Pn a → Pn (an a)
-    pn = map-family-descent-data-sequential-colimit 𝒟P _
-    qn : {n : ℕ} (b : Bn n) → Qn b → Qn (bn b)
-    qn = map-family-descent-data-sequential-colimit 𝒟Q _
-
-    -- then, the maps over homs
-    f'∞n : {n : ℕ} (a : An n) → Pn a → Qn (fn a)
-    f'∞n a =
-      ( tr Q
-        ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
-          ( H)
-          ( _)
-          ( a))) ∘
-      ( f'∞)
-
-    -- then, the squares-over
-    f'∞n-square-over :
-      {n : ℕ} →
-      square-over {Q4 = Qn} (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _) Hn
-    f'∞n-square-over {n} {a} =
-      pasting-vertical-coherence-square-maps
-        ( tr P (coherence-cocone-sequential-diagram c n a))
-        ( f'∞)
-        ( f'∞)
-        ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
-        ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H _ a))
-        ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H _ (an a)))
-        ( ( tr
-            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-            ( Hn a)) ∘
-          ( tr Q (coherence-cocone-sequential-diagram c' n (fn a))))
-        ( λ q →
-          substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
-          inv (preserves-tr (λ p → f'∞ {p}) (coherence-cocone-sequential-diagram c n a) q))
-        ( ( inv-htpy
-            ( λ q →
-              ( tr-concat
-                ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-                  up-c c' H n a)
-                ( _)
-                ( q)) ∙
-              ( tr-concat
-                ( coherence-cocone-sequential-diagram c' n (fn a))
-                ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (Hn a))
-                ( tr Q
-                  ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-                    up-c c' H n a)
-                  ( q))) ∙
-              ( substitution-law-tr Q
-                ( map-cocone-sequential-diagram c' (succ-ℕ n))
-                ( Hn a)))) ∙h
-          ( λ q →
-            ap
-              ( λ p → tr Q p q)
-              ( inv
-                ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H n a))) ∙h
-          ( tr-concat
-            ( ap f∞ (coherence-cocone-sequential-diagram c n a))
-            ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-              up-c c' H (succ-ℕ n) (an a))))
-
-    thm :
-      (sA : section-dependent-sequential-diagram A 𝒫) →
-      (sB : section-dependent-sequential-diagram B 𝒬) →
-      (S : (n : ℕ) →
-        section-map-over (fn {n}) (f'∞n _)
-          ( map-section-dependent-sequential-diagram A 𝒫 sA n)
-          ( map-section-dependent-sequential-diagram B 𝒬 sB n)) →
-      ((n : ℕ) →
-        section-square-over (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _)
-          ( map-section-dependent-sequential-diagram A 𝒫 sA n)
-          ( map-section-dependent-sequential-diagram B 𝒬 sB n)
-          ( map-section-dependent-sequential-diagram A 𝒫 sA (succ-ℕ n))
-          ( map-section-dependent-sequential-diagram B 𝒬 sB (succ-ℕ n))
-          ( naturality-map-section-dependent-sequential-diagram A 𝒫 sA n)
-          ( S n)
-          ( S (succ-ℕ n))
-          ( naturality-map-section-dependent-sequential-diagram B 𝒬 sB n)
-          ( Hn)
-          ( f'∞n-square-over)) →
-      section-map-over f∞ f'∞
-        ( sect-family-sect-dd-sequential-colimit up-c P sA)
-        ( sect-family-sect-dd-sequential-colimit up-c' Q sB)
-    thm sA sB S α =
-      map-dependent-universal-property-sequential-colimit
-        ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
-        ( tS ,
-          ( λ n a →
-            map-compute-dependent-identification-eq-value
-              ( f'∞ ∘ sA∞)
-              ( sB∞ ∘ f∞)
-              ( coherence-cocone-sequential-diagram c n a)
-              ( tS n a)
-              ( tS (succ-ℕ n) (an a))
-              ( {!f'∞n-square-over!})))
-      where
-        sA∞ : (x : X) → P x
-        sA∞ = sect-family-sect-dd-sequential-colimit up-c P sA
-        sB∞ : (y : Y) → Q y
-        sB∞ = sect-family-sect-dd-sequential-colimit up-c' Q sB
-        tS :
-          (n : ℕ) →
-          (f'∞ ∘ sA∞ ∘ (map-cocone-sequential-diagram c n)) ~
-          (sB∞ ∘ f∞ ∘ map-cocone-sequential-diagram c n)
-        tS n a =
-          ap f'∞
-            ( pr1
-              ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
-                ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
-                ( sA)) n a) ∙
-          map-equiv
-            ( inv-equiv-ap-emb (emb-equiv (equiv-tr Q (Cn n a))))
-            ( S n a ∙
-              inv
-                ( apd sB∞ (Cn n a) ∙
-                  pr1
-                    ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
-                      ( dependent-universal-property-universal-property-sequential-colimit _ up-c')
-                      ( sB)) n (fn a)))
-```
+--   mediating-cocone :
+--     cocone-sequential-diagram
+--       ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
+--       ( Σ X (family-cocone-family-with-descent-data-sequential-colimit P))
+--   pr1 mediating-cocone n =
+--     map-Σ
+--       ( family-cocone-family-with-descent-data-sequential-colimit P)
+--       ( map-cocone-sequential-diagram c n)
+--       ( λ a → map-equiv-descent-data-family-with-descent-data-sequential-colimit P n a)
+--   pr2 mediating-cocone n (a , p) =
+--     eq-pair-Σ
+--       ( coherence-cocone-sequential-diagram c n a)
+--       ( inv
+--         ( coherence-square-equiv-descent-data-family-with-descent-data-sequential-colimit P n a p))
+
+--   totι' : Y → Σ X (family-cocone-family-with-descent-data-sequential-colimit P)
+--   totι' =
+--     map-universal-property-sequential-colimit up-c' mediating-cocone
+--   triangle-pr1∞-pr1 :
+--     pr1-sequential-colimit-total-sequential-diagram
+--       ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)
+--       ( up-c')
+--       ( c) ~
+--     pr1 ∘ totι'
+--   triangle-pr1∞-pr1 =
+--     htpy-htpy-out-of-sequential-colimit up-c'
+--       ( concat-htpy-cocone-sequential-diagram
+--         ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c' c
+--           ( pr1-total-sequential-diagram
+--             ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)))
+--         ( ( λ n →
+--             inv-htpy (pr1 ·l (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n))) ,
+--           ( λ n x →
+--             ap (_∙ inv (ap pr1 (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))) right-unit ∙
+--             horizontal-inv-coherence-square-identifications _
+--               ( ap (pr1 ∘ totι') (coherence-cocone-sequential-diagram c' n x))
+--               ( coherence-cocone-sequential-diagram c n (pr1 x))
+--               _
+--               ( ( ap
+--                   ( _∙ ap pr1
+--                     ( pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))
+--                   ( ap-comp pr1
+--                     ( totι')
+--                     ( coherence-cocone-sequential-diagram c' n x))) ∙
+--                 ( inv
+--                   ( ap-concat pr1
+--                     ( ap
+--                       ( totι')
+--                       ( coherence-cocone-sequential-diagram c' n x)) _)) ∙
+--                 ( ap (ap pr1) (pr2 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n x)) ∙
+--                 ( ap-concat pr1
+--                   ( pr1
+--                     ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
+--                     n x)
+--                   ( coherence-cocone-sequential-diagram mediating-cocone n x)) ∙
+--                 ( ap
+--                   ( ap pr1
+--                     ( pr1
+--                       ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
+--                       n x) ∙_)
+--                   ( ap-pr1-eq-pair-Σ
+--                     ( coherence-cocone-sequential-diagram c n (pr1 x))
+--                     ( _)))))))
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 : Level}
+--   {A : sequential-diagram l1}
+--   (P : descent-data-sequential-colimit A l2)
+--   where
+
+--   section-descent-data-sequential-colimit : UU (l1 ⊔ l2)
+--   section-descent-data-sequential-colimit =
+--     Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
+--         family-descent-data-sequential-colimit P n a)
+--       ( λ s →
+--         (n : ℕ) (a : family-sequential-diagram A n) →
+--         map-family-descent-data-sequential-colimit P n a (s n a) ＝
+--         s (succ-ℕ n) (map-sequential-diagram A n a))
+
+-- module _
+--   {l1 l2 l3 : Level}
+--   {A : sequential-diagram l1}
+--   {X : UU l2} {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   (P : X → UU l3)
+--   where
+
+--   sect-family-sect-dd-sequential-colimit :
+--     section-descent-data-sequential-colimit
+--       ( descent-data-family-cocone-sequential-diagram c P) →
+--     ((x : X) → P x)
+--   sect-family-sect-dd-sequential-colimit s =
+--     map-dependent-universal-property-sequential-colimit
+--       ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+--       ( s)
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : sequential-diagram l1} {X : UU l2}
+--   {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   {B : sequential-diagram l3} {Y : UU l4}
+--   {c' : cocone-sequential-diagram B Y}
+--   (up-c' : universal-property-sequential-colimit c')
+--   (P : X → UU l5) (Q : Y → UU l6)
+--   (f : hom-sequential-diagram A B)
+--   (f' :
+--     (x : X) → P x →
+--     Q (map-sequential-colimit-hom-sequential-diagram up-c c' f x))
+--   where
+
+--   open import synthetic-homotopy-theory.flattening-lemma-sequential-colimits
+
+--   ΣAP : sequential-diagram (l1 ⊔ l5)
+--   ΣAP =
+--     total-sequential-diagram (dependent-sequential-diagram-family-cocone c P)
+
+--   ΣBQ : sequential-diagram (l3 ⊔ l6)
+--   ΣBQ =
+--     total-sequential-diagram (dependent-sequential-diagram-family-cocone c' Q)
+
+--   private
+--     finf : X → Y
+--     finf = (map-sequential-colimit-hom-sequential-diagram up-c c' f)
+
+--   totff' : hom-sequential-diagram ΣAP ΣBQ
+--   pr1 totff' n =
+--     map-Σ _
+--       ( map-hom-sequential-diagram B f n)
+--       ( λ a →
+--         tr Q
+--           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--             up-c c' f n a) ∘
+--         f' (map-cocone-sequential-diagram c n a))
+--   pr2 totff' n (a , p) =
+--     eq-pair-Σ
+--       ( naturality-map-hom-sequential-diagram B f n a)
+--       ((pasting-vertical-coherence-square-maps
+--       ( tr P (coherence-cocone-sequential-diagram c n a))
+--       ( f' _)
+--       ( f' _)
+--       ( tr Q (ap finf (coherence-cocone-sequential-diagram c n a)))
+--       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
+--       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
+--       ( ( tr
+--           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--           ( naturality-map-hom-sequential-diagram B f n a)) ∘
+--         ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
+--       ( λ q →
+--         substitution-law-tr Q finf (coherence-cocone-sequential-diagram c n a) ∙
+--         inv (preserves-tr f' (coherence-cocone-sequential-diagram c n a) q))
+--       ( ( inv-htpy
+--           ( λ q →
+--             ( tr-concat
+--               ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                 up-c c' f n a)
+--               ( _)
+--               ( q)) ∙
+--             ( tr-concat
+--               ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+--               ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
+--               ( tr Q
+--                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                   up-c c' f n a)
+--                 ( q))) ∙
+--             ( substitution-law-tr Q
+--               ( map-cocone-sequential-diagram c' (succ-ℕ n))
+--               ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
+--         ( λ q →
+--           ap
+--             ( λ p → tr Q p q)
+--             ( inv
+--               ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
+--         ( tr-concat
+--           ( ap finf (coherence-cocone-sequential-diagram c n a))
+--           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--             up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))) p)
+
+
+--   totff'∞ : Σ X P → Σ Y Q
+--   totff'∞ =
+--     map-sequential-colimit-hom-sequential-diagram
+--       ( flattening-lemma-sequential-colimit _ P up-c)
+--       ( total-cocone-family-cocone-sequential-diagram c' Q)
+--       ( totff')
+
+--   pr1A∙ : hom-sequential-diagram ΣAP A
+--   pr1A∙ =
+--     pr1-total-sequential-diagram
+--       ( dependent-sequential-diagram-family-cocone c P)
+--   pr1B∙ : hom-sequential-diagram ΣBQ B
+--   pr1B∙ =
+--     pr1-total-sequential-diagram
+--       ( dependent-sequential-diagram-family-cocone c' Q)
+
+--   pr1∘totff' : hom-sequential-diagram ΣAP B
+--   pr1∘totff' = comp-hom-sequential-diagram ΣAP ΣBQ B pr1B∙ totff'
+--   f∘pr1 : hom-sequential-diagram ΣAP B
+--   f∘pr1 = comp-hom-sequential-diagram ΣAP A B f pr1A∙
+
+--   pr1coh∙ : htpy-hom-sequential-diagram B f∘pr1 pr1∘totff'
+--   pr1 pr1coh∙ n =
+--     refl-htpy
+--   pr2 pr1coh∙ n =
+--     right-unit-htpy ∙h
+--     right-unit-htpy ∙h
+--     ( λ x →
+--       inv
+--         ( ap-pr1-eq-pair-Σ
+--           ( naturality-map-hom-sequential-diagram B f n (pr1 x))
+--           ( _)))
+
+--   module _
+--     (sA :
+--       section-descent-data-sequential-colimit
+--         ( descent-data-family-cocone-sequential-diagram c P))
+--     (sB :
+--       section-descent-data-sequential-colimit
+--         ( descent-data-family-cocone-sequential-diagram c' Q))
+--     where
+--     open import foundation.sections
+
+--     -- vertical maps, the "sides" of the cubes
+--     sA∙ : hom-sequential-diagram A ΣAP
+--     pr1 sA∙ n = map-section-family (pr1 sA n)
+--     pr2 sA∙ n a = eq-pair-eq-fiber (pr2 sA n a)
+--     sB∙ : hom-sequential-diagram B ΣBQ
+--     pr1 sB∙ n = map-section-family (pr1 sB n)
+--     pr2 sB∙ n b = eq-pair-eq-fiber (pr2 sB n b)
+--     totff'∘sA∙ : hom-sequential-diagram A ΣBQ
+--     totff'∘sA∙ = comp-hom-sequential-diagram A ΣAP ΣBQ totff' sA∙
+--     sB∙∘f : hom-sequential-diagram A ΣBQ
+--     sB∙∘f = comp-hom-sequential-diagram A B ΣBQ sB∙ f
+--     -- the unaligned cubes
+--     H∙ :
+--       htpy-hom-sequential-diagram ΣBQ totff'∘sA∙ sB∙∘f
+--     pr1 H∙ n a = eq-pair-eq-fiber {!!}
+--     pr2 H∙ = {!!}
+
+--     pr1∙∘sA∙ : hom-sequential-diagram A A
+--     pr1∙∘sA∙ = comp-hom-sequential-diagram A ΣAP A pr1A∙ sA∙
+
+--     idA∙ : hom-sequential-diagram A A
+--     idA∙ = id-hom-sequential-diagram A
+--     idB∙ : hom-sequential-diagram B B
+--     idB∙ = id-hom-sequential-diagram B
+--     f∘idA∙ : hom-sequential-diagram A B
+--     f∘idA∙ = comp-hom-sequential-diagram A A B f idA∙
+--     idB∙∘f : hom-sequential-diagram A B
+--     idB∙∘f = comp-hom-sequential-diagram A B B idB∙ f
+--     refl∙ : htpy-hom-sequential-diagram B f∘idA∙ idB∙∘f
+--     pr1 refl∙ = ev-pair refl-htpy
+--     pr2 refl∙ n a =
+--       right-unit ∙
+--       right-unit ∙
+--       inv (ap-id (naturality-map-hom-sequential-diagram B f n a))
+--     -- the alignment: postcomposing H∙ with pr1coh∙ is homotopic with id
+--     ℋ :
+--       {!htpy²-hom-sequential-diagram!}
+--     ℋ = {!!}
+
+--   _ :
+--     totι' up-c
+--       ( family-with-descent-data-family-cocone-sequential-diagram c P)
+--       ( flattening-lemma-sequential-colimit c P up-c) ~
+--     id
+--   _ =
+--     compute-map-universal-property-sequential-colimit-id
+--       ( flattening-lemma-sequential-colimit _ P up-c)
+
+--   _ :
+--     coherence-square-maps
+--       ( totι' up-c
+--         ( family-with-descent-data-family-cocone-sequential-diagram c P)
+--         ( flattening-lemma-sequential-colimit c P up-c))
+--       ( totff'∞)
+--       ( map-Σ Q
+--         ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--         f')
+--       ( totι' up-c'
+--         ( family-with-descent-data-family-cocone-sequential-diagram c' Q)
+--         ( flattening-lemma-sequential-colimit c' Q up-c'))
+--   _ =
+--     ( compute-map-universal-property-sequential-colimit-id
+--       ( flattening-lemma-sequential-colimit c' Q up-c') ·r _) ∙h
+--     ( htpy-htpy-out-of-sequential-colimit
+--       ( flattening-lemma-sequential-colimit c P up-c)
+--       ( concat-htpy-cocone-sequential-diagram
+--         ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--           ( flattening-lemma-sequential-colimit c P up-c)
+--           ( total-cocone-family-cocone-sequential-diagram c' Q)
+--           ( totff'))
+--         ( ( λ n (a , p) →
+--             inv
+--               ( eq-pair-Σ
+--                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
+--                   ( f)
+--                   ( n)
+--                   ( a))
+--                 refl)) ,
+--           {!!}))) ∙h
+--     ( _ ·l
+--       ( inv-htpy
+--         (compute-map-universal-property-sequential-colimit-id
+--           ( flattening-lemma-sequential-colimit c P up-c))))
+
+--     -- htpy-htpy-out-of-sequential-colimit
+--     --   ( flattening-lemma-sequential-colimit c P up-c)
+--     --   ( {!!})
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : sequential-diagram l1} {X : UU l2}
+--   {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   {B : sequential-diagram l3} {Y : UU l4}
+--   {c' : cocone-sequential-diagram B Y}
+--   (up-c' : universal-property-sequential-colimit c')
+--   (f : hom-sequential-diagram A B)
+--   where
+--   open import foundation.homotopies-morphisms-arrows
+
+--   interm :
+--     coherence-square-maps
+--       ( id)
+--       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--       ( id)
+--   interm =
+--     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-c c'
+--       ( refl-htpy-hom-sequential-diagram A B f)
+
+--   preserves-refl-htpy-sequential-colimit :
+--     htpy-hom-arrow
+--       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--       ( id , id , interm)
+--       ( id , id , refl-htpy)
+--   pr1 preserves-refl-htpy-sequential-colimit = refl-htpy
+--   pr1 (pr2 preserves-refl-htpy-sequential-colimit) = refl-htpy
+--   pr2 (pr2 preserves-refl-htpy-sequential-colimit) =
+--     right-unit-htpy ∙h
+--     htpy-eq
+--       ( ap
+--         ( htpy-eq ∘ ap (map-sequential-colimit-hom-sequential-diagram up-c c'))
+--         ( is-retraction-map-inv-equiv
+--           ( extensionality-hom-sequential-diagram A B f f)
+--           ( refl)))
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : sequential-diagram l1}
+--   (B : sequential-diagram l2)
+--   (f : hom-sequential-diagram A B)
+--   (P : descent-data-sequential-colimit A l3)
+--   (Q : descent-data-sequential-colimit B l4)
+--   where
+
+--   hom-over-hom : UU (l1 ⊔ l3 ⊔ l4)
+--   hom-over-hom =
+--     Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
+--         family-descent-data-sequential-colimit P n a →
+--         family-descent-data-sequential-colimit Q n
+--           ( map-hom-sequential-diagram B f n a))
+--       ( λ f'n →
+--         (n : ℕ) →
+--         square-over
+--           { Q4 = family-descent-data-sequential-colimit Q (succ-ℕ n)}
+--           ( map-sequential-diagram A n)
+--           ( map-hom-sequential-diagram B f n)
+--           ( map-hom-sequential-diagram B f (succ-ℕ n))
+--           ( map-sequential-diagram B n)
+--           ( λ {a} → map-family-descent-data-sequential-colimit P n a)
+--           ( λ {a} → f'n n a)
+--           ( λ {a} → f'n (succ-ℕ n) a)
+--           ( λ {a} → map-family-descent-data-sequential-colimit Q n a)
+--           ( naturality-map-hom-sequential-diagram B f n))
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : sequential-diagram l1} {X : UU l2}
+--   {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   {B : sequential-diagram l3} {Y : UU l4}
+--   {c' : cocone-sequential-diagram B Y}
+--   (up-c' : universal-property-sequential-colimit c')
+--   (f : hom-sequential-diagram A B)
+--   (P : X → UU l5) (Q : Y → UU l6)
+--   where
+
+--   private
+--     f∞ : X → Y
+--     f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f
+--     DDMO : descent-data-sequential-colimit A (l5 ⊔ l6)
+--     pr1 DDMO n a =
+--       P (map-cocone-sequential-diagram c n a) →
+--       Q (map-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+--     pr2 DDMO n a =
+--       ( equiv-postcomp _
+--         ( ( equiv-tr
+--             ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--             ( naturality-map-hom-sequential-diagram B f n a)) ∘e
+--           ( equiv-tr Q (coherence-cocone-sequential-diagram c' n _)))) ∘e
+--       ( equiv-precomp
+--         ( inv-equiv (equiv-tr P (coherence-cocone-sequential-diagram c n a)))
+--         ( _))
+
+--   sect-over-DDMO-map-over :
+--     ((a : X) → P a → Q (f∞ a)) →
+--     section-descent-data-sequential-colimit DDMO
+--   pr1 (sect-over-DDMO-map-over f∞') n a =
+--     ( tr Q
+--       ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
+--     ( f∞' (map-cocone-sequential-diagram c n a))
+--   pr2 (sect-over-DDMO-map-over f∞') n a =
+--     eq-htpy
+--       ( λ p →
+--         {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a!})
+
+--   sect-over-DDMO-map-over' :
+--     ((a : X) → P a → Q (f∞ a)) →
+--     section-descent-data-sequential-colimit DDMO
+--   sect-over-DDMO-map-over' =
+--     {!sect-family-sect-dd-sequential-colimit!}
+
+--   map-over-sect-DDMO :
+--     section-descent-data-sequential-colimit DDMO →
+--     hom-over-hom B f
+--       ( descent-data-family-cocone-sequential-diagram c P)
+--       ( descent-data-family-cocone-sequential-diagram c' Q)
+--   map-over-sect-DDMO =
+--     tot
+--       ( λ s →
+--         map-Π
+--           ( λ n →
+--             ( map-implicit-Π
+--               ( λ a →
+--                 ( concat-htpy
+--                   ( inv-htpy
+--                     ( ( ( tr
+--                           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--                           ( naturality-map-hom-sequential-diagram B f n a)) ∘
+--                         ( tr Q
+--                           ( coherence-cocone-sequential-diagram c' n
+--                             (map-hom-sequential-diagram B f n a))) ∘
+--                         ( s n a)) ·l
+--                       ( is-retraction-inv-tr P
+--                         ( coherence-cocone-sequential-diagram c n a))))
+--                   ( _)) ∘
+--                 ( map-equiv
+--                   ( equiv-htpy-precomp-htpy-Π _ _
+--                     ( equiv-tr P
+--                       ( coherence-cocone-sequential-diagram c n a)))) ∘
+--                 ( htpy-eq
+--                   {f =
+--                     ( tr
+--                       ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--                       ( naturality-map-hom-sequential-diagram B f n a)) ∘
+--                     ( tr Q
+--                       ( coherence-cocone-sequential-diagram c' n
+--                         ( map-hom-sequential-diagram B f n a))) ∘
+--                     ( s n a) ∘
+--                     ( tr P (inv (coherence-cocone-sequential-diagram c n a)))}
+--                   { s (succ-ℕ n) (map-sequential-diagram A n a)}))) ∘
+--             ( implicit-explicit-Π)))
+
+--   map-over-diagram-map-over-colimit :
+--     ((a : X) → P a → Q (f∞ a)) →
+--     hom-over-hom B f
+--       ( descent-data-family-cocone-sequential-diagram c P)
+--       ( descent-data-family-cocone-sequential-diagram c' Q)
+--   pr1 (map-over-diagram-map-over-colimit f∞') n a =
+--     ( tr Q
+--       ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
+--     ( f∞' (map-cocone-sequential-diagram c n a))
+--   pr2 (map-over-diagram-map-over-colimit f∞') n {a} =
+--     pasting-vertical-coherence-square-maps
+--       ( tr P (coherence-cocone-sequential-diagram c n a))
+--       ( f∞' _)
+--       ( f∞' _)
+--       ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
+--       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
+--       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
+--       ( ( tr
+--           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--           ( naturality-map-hom-sequential-diagram B f n a)) ∘
+--         ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
+--       ( λ q →
+--         substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
+--         inv (preserves-tr f∞' (coherence-cocone-sequential-diagram c n a) q))
+--       ( ( inv-htpy
+--           ( λ q →
+--             ( tr-concat
+--               ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                 up-c c' f n a)
+--               ( _)
+--               ( q)) ∙
+--             ( tr-concat
+--               ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+--               ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
+--               ( tr Q
+--                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                   up-c c' f n a)
+--                 ( q))) ∙
+--             ( substitution-law-tr Q
+--               ( map-cocone-sequential-diagram c' (succ-ℕ n))
+--               ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
+--         ( λ q →
+--           ap
+--             ( λ p → tr Q p q)
+--             ( inv
+--               ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
+--         ( tr-concat
+--           ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+--           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--             up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))
+
+--   abstract
+--     triangle-map-over-sect-DDMO :
+--       coherence-triangle-maps
+--         ( map-over-diagram-map-over-colimit)
+--         ( map-over-sect-DDMO)
+--         ( sect-over-DDMO-map-over)
+--     triangle-map-over-sect-DDMO f∞' =
+--       eq-pair-eq-fiber
+--         ( eq-htpy
+--           ( λ n →
+--             eq-htpy-implicit
+--               ( λ a →
+--                 eq-htpy
+--                   ( λ p →
+--                     {!!}))))
+
+--     is-equiv-map-over-sect-DDMO :
+--       is-equiv map-over-sect-DDMO
+--     is-equiv-map-over-sect-DDMO =
+--       is-equiv-tot-is-fiberwise-equiv
+--         ( λ s →
+--           is-equiv-map-Π-is-fiberwise-equiv
+--             ( λ n →
+--               is-equiv-comp _ _
+--                 ( is-equiv-implicit-explicit-Π)
+--                 ( is-equiv-map-implicit-Π-is-fiberwise-equiv
+--                   ( λ a →
+--                     is-equiv-comp _ _
+--                       ( funext _ _)
+--                       ( is-equiv-comp _ _
+--                         ( is-equiv-map-equiv (equiv-htpy-precomp-htpy-Π _ _ _))
+--                         ( is-equiv-concat-htpy _ _))))))
+
+--     is-equiv-map-over-diagram-map-over-colimit :
+--       is-equiv map-over-diagram-map-over-colimit
+--     is-equiv-map-over-diagram-map-over-colimit =
+--       {!is-equiv-left-map-triangle
+--         ( map-over-diagram-map-over-colimit)
+--         ( map-over-sect-DDMO)
+--         ( sect-over-DDMO-map-over)
+--         ( triangle-map-over-sect-DDMO)
+--         ( is-equiv) !}
+-- ```
+
+-- ```agda
+-- module big-thm
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : sequential-diagram l1}
+--   {B : sequential-diagram l2}
+--   {X : UU l3} {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   {Y : UU l4} {c' : cocone-sequential-diagram B Y}
+--   (up-c' : universal-property-sequential-colimit c')
+--   (H : hom-sequential-diagram A B)
+--   where
+
+--   -- the squares induce a map
+
+--   f∞ : X → Y
+--   f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' H
+
+--   Cn : (n : ℕ) →
+--     f∞ ∘ map-cocone-sequential-diagram c n ~
+--     map-cocone-sequential-diagram c' n ∘ map-hom-sequential-diagram B H n
+--   Cn =
+--     htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H
+
+--   module _
+--     (P : X → UU l5) (Q : Y → UU l6)
+--     (f'∞ : {x : X} → P x → Q (f∞ x))
+--     where
+
+--     An : ℕ → UU l1
+--     An = family-sequential-diagram A
+--     Bn : ℕ → UU l2
+--     Bn = family-sequential-diagram B
+--     an : {n : ℕ} → An n → An (succ-ℕ n)
+--     an = map-sequential-diagram A _
+--     bn : {n : ℕ} → Bn n → Bn (succ-ℕ n)
+--     bn = map-sequential-diagram B _
+--     fn : {n : ℕ} → An n → Bn n
+--     fn = map-hom-sequential-diagram B H _
+--     Hn : {n : ℕ} → bn {n} ∘ fn ~ fn ∘ an
+--     Hn = naturality-map-hom-sequential-diagram B H _
+
+--     -- a map-over induces squares-over
+
+--     -- first, the sequences-over:
+--     𝒟P : descent-data-sequential-colimit A l5
+--     𝒟P = descent-data-family-cocone-sequential-diagram c P
+--     𝒫 = dependent-sequential-diagram-descent-data 𝒟P
+--     𝒟Q : descent-data-sequential-colimit B l6
+--     𝒟Q = descent-data-family-cocone-sequential-diagram c' Q
+--     𝒬 = dependent-sequential-diagram-descent-data 𝒟Q
+
+--     Pn : {n : ℕ} → An n → UU l5
+--     Pn = family-descent-data-sequential-colimit 𝒟P _
+--     Qn : {n : ℕ} → Bn n → UU l6
+--     Qn = family-descent-data-sequential-colimit 𝒟Q _
+
+--     pn : {n : ℕ} (a : An n) → Pn a → Pn (an a)
+--     pn = map-family-descent-data-sequential-colimit 𝒟P _
+--     qn : {n : ℕ} (b : Bn n) → Qn b → Qn (bn b)
+--     qn = map-family-descent-data-sequential-colimit 𝒟Q _
+
+--     -- then, the maps over homs
+--     f'∞n : {n : ℕ} (a : An n) → Pn a → Qn (fn a)
+--     f'∞n a =
+--       ( tr Q
+--         ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
+--           ( H)
+--           ( _)
+--           ( a))) ∘
+--       ( f'∞)
+
+--     -- then, the squares-over
+--     f'∞n-square-over :
+--       {n : ℕ} →
+--       square-over {Q4 = Qn} (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _) Hn
+--     f'∞n-square-over {n} {a} =
+--       pasting-vertical-coherence-square-maps
+--         ( tr P (coherence-cocone-sequential-diagram c n a))
+--         ( f'∞)
+--         ( f'∞)
+--         ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
+--         ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H _ a))
+--         ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H _ (an a)))
+--         ( ( tr
+--             ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--             ( Hn a)) ∘
+--           ( tr Q (coherence-cocone-sequential-diagram c' n (fn a))))
+--         ( λ q →
+--           substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
+--           inv (preserves-tr (λ p → f'∞ {p}) (coherence-cocone-sequential-diagram c n a) q))
+--         ( ( inv-htpy
+--             ( λ q →
+--               ( tr-concat
+--                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                   up-c c' H n a)
+--                 ( _)
+--                 ( q)) ∙
+--               ( tr-concat
+--                 ( coherence-cocone-sequential-diagram c' n (fn a))
+--                 ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (Hn a))
+--                 ( tr Q
+--                   ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                     up-c c' H n a)
+--                   ( q))) ∙
+--               ( substitution-law-tr Q
+--                 ( map-cocone-sequential-diagram c' (succ-ℕ n))
+--                 ( Hn a)))) ∙h
+--           ( λ q →
+--             ap
+--               ( λ p → tr Q p q)
+--               ( inv
+--                 ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H n a))) ∙h
+--           ( tr-concat
+--             ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+--             ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--               up-c c' H (succ-ℕ n) (an a))))
+
+--     thm :
+--       (sA : section-dependent-sequential-diagram A 𝒫) →
+--       (sB : section-dependent-sequential-diagram B 𝒬) →
+--       (S : (n : ℕ) →
+--         section-map-over (fn {n}) (f'∞n _)
+--           ( map-section-dependent-sequential-diagram A 𝒫 sA n)
+--           ( map-section-dependent-sequential-diagram B 𝒬 sB n)) →
+--       ((n : ℕ) →
+--         section-square-over (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _)
+--           ( map-section-dependent-sequential-diagram A 𝒫 sA n)
+--           ( map-section-dependent-sequential-diagram B 𝒬 sB n)
+--           ( map-section-dependent-sequential-diagram A 𝒫 sA (succ-ℕ n))
+--           ( map-section-dependent-sequential-diagram B 𝒬 sB (succ-ℕ n))
+--           ( naturality-map-section-dependent-sequential-diagram A 𝒫 sA n)
+--           ( S n)
+--           ( S (succ-ℕ n))
+--           ( naturality-map-section-dependent-sequential-diagram B 𝒬 sB n)
+--           ( Hn)
+--           ( f'∞n-square-over)) →
+--       section-map-over f∞ f'∞
+--         ( sect-family-sect-dd-sequential-colimit up-c P sA)
+--         ( sect-family-sect-dd-sequential-colimit up-c' Q sB)
+--     thm sA sB S α =
+--       map-dependent-universal-property-sequential-colimit
+--         ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+--         ( tS ,
+--           ( λ n a →
+--             map-compute-dependent-identification-eq-value
+--               ( f'∞ ∘ sA∞)
+--               ( sB∞ ∘ f∞)
+--               ( coherence-cocone-sequential-diagram c n a)
+--               ( tS n a)
+--               ( tS (succ-ℕ n) (an a))
+--               ( {!f'∞n-square-over!})))
+--       where
+--         sA∞ : (x : X) → P x
+--         sA∞ = sect-family-sect-dd-sequential-colimit up-c P sA
+--         sB∞ : (y : Y) → Q y
+--         sB∞ = sect-family-sect-dd-sequential-colimit up-c' Q sB
+--         tS :
+--           (n : ℕ) →
+--           (f'∞ ∘ sA∞ ∘ (map-cocone-sequential-diagram c n)) ~
+--           (sB∞ ∘ f∞ ∘ map-cocone-sequential-diagram c n)
+--         tS n a =
+--           ap f'∞
+--             ( pr1
+--               ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+--                 ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+--                 ( sA)) n a) ∙
+--           map-equiv
+--             ( inv-equiv-ap-emb (emb-equiv (equiv-tr Q (Cn n a))))
+--             ( S n a ∙
+--               inv
+--                 ( apd sB∞ (Cn n a) ∙
+--                   pr1
+--                     ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+--                       ( dependent-universal-property-universal-property-sequential-colimit _ up-c')
+--                       ( sB)) n (fn a)))
+-- ```
diff --git a/src/synthetic-homotopy-theory/stuff-over.lagda.md b/src/synthetic-homotopy-theory/stuff-over.lagda.md
index 709671029f..05c40956f7 100644
--- a/src/synthetic-homotopy-theory/stuff-over.lagda.md
+++ b/src/synthetic-homotopy-theory/stuff-over.lagda.md
@@ -1,6 +1,7 @@
 # Stuff over other stuff
 
 ```agda
+{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
 module synthetic-homotopy-theory.stuff-over where
 ```
 
@@ -10,6 +11,7 @@ module synthetic-homotopy-theory.stuff-over where
 open import foundation.action-on-identifications-dependent-functions
 open import foundation.action-on-identifications-functions
 open import foundation.commuting-cubes-of-maps
+open import foundation.commuting-squares-of-homotopies
 open import foundation.commuting-squares-of-maps
 open import foundation.commuting-triangles-of-maps
 open import foundation.dependent-identifications
@@ -866,6 +868,52 @@ module _
   hom-htpy : UU (l2 ⊔ l3)
   hom-htpy = N ∙h (hB ·l top) ~ (bottom ·r hA) ∙h F
 
+-- module _
+--   where
+
+--   alt-map-coherence-square-homotopies
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4} {V : UU l5} {W : UU l6}
+  {f g : A → B} {f' g' : X → Y} {f'' g'' : V → W}
+  (mid : f' ~ g') (bottom : f ~ g) (top : f'' ~ g'')
+  {hA : X → A} {hB : Y → B} {hA' : V → X} {hB' : W → Y}
+  (bottom-N : f ∘ hA ~ hB ∘ f') (bottom-F : g ∘ hA ~ hB ∘ g')
+  (top-N : f' ∘ hA' ~ hB' ∘ f'') (top-F : g' ∘ hA' ~ hB' ∘ g'')
+  where
+
+  pasting-vertical-hom-htpy :
+    hom-htpy mid bottom {hB = hB} bottom-N bottom-F →
+    hom-htpy top mid {hB = hB'} top-N top-F →
+    hom-htpy top bottom {hB = hB ∘ hB'}
+      ( pasting-vertical-coherence-square-maps f'' hA' hB' f' hA hB f
+        top-N bottom-N)
+      ( pasting-vertical-coherence-square-maps g'' hA' hB' g' hA hB g
+        top-F bottom-F)
+  pasting-vertical-hom-htpy α β =
+    left-whisker-concat-coherence-square-homotopies
+      ( bottom-N ·r hA')
+      ( hB ·l mid ·r hA')
+      ( hB ·l top-N)
+      ( hB ·l top-F)
+      ( (hB ∘ hB') ·l top)
+      ( left-whisker-concat-htpy (hB ·l top-N)
+          ( inv-htpy (preserves-comp-left-whisker-comp hB hB' top)) ∙h
+        map-coherence-square-homotopies hB (mid ·r hA') top-N top-F (hB' ·l top)
+          ( β)) ∙h
+    right-whisker-concat-htpy (α ·r hA') (hB ·l top-F) ∙h
+    assoc-htpy (bottom ·r (hA ∘ hA')) (bottom-F ·r hA') (hB ·l top-F)
+
+module _
+  {l1 l2 : Level}
+  {A : UU l1} {B : UU l2}
+  {f g : A → B} (H : f ~ g)
+  where
+
+  id-hom-htpy : hom-htpy H H {hA = id} {hB = id} refl-htpy refl-htpy
+  id-hom-htpy = left-unit-law-left-whisker-comp H ∙h inv-htpy-right-unit-htpy
+
 module _
   {l1 l2 l3 l4 : Level}
   {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4}
@@ -881,7 +929,6 @@ module _
   (γN : htpy-hom-map f f' hA hB N hA' hB' N' σA σB)
   (γF : htpy-hom-map g g' hA hB F hA' hB' F' σA σB)
   where
-  open import foundation.commuting-squares-of-homotopies
 
   nudged-α nudged-β :
     (N ∙h (hB ·l top)) ∙h (σB ·r g') ~
@@ -911,304 +958,415 @@ module _
   htpy-hom-htpy : UU (l2 ⊔ l3)
   htpy-hom-htpy = nudged-α ~ nudged-β
 
-module _
-  {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
-  (f : A → B) (g : A → C) (h : B → D) (k : C → D)
-  {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
-  (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
-  (top : h' ∘ f' ~ k' ∘ g')
-  (bottom : h ∘ f ~ k ∘ g)
-  (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
-  (back-left : (f ∘ hA) ~ (hB ∘ f'))
-  (back-right : (g ∘ hA) ~ (hC ∘ g'))
-  (front-left : (h ∘ hB) ~ (hD ∘ h'))
-  (front-right : (k ∘ hC) ~ (hD ∘ k'))
-  (α :
-    coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
-      top back-left back-right front-left front-right bottom)
-  (hA' : A' → A) (hB' : B' → B) (hC' : C' → C) (hD' : D' → D)
-  (back-left' : (f ∘ hA') ~ (hB' ∘ f'))
-  (back-right' : (g ∘ hA') ~ (hC' ∘ g'))
-  (front-left' : (h ∘ hB') ~ (hD' ∘ h'))
-  (front-right' : (k ∘ hC') ~ (hD' ∘ k'))
-  (β :
-    coherence-cube-maps f g h k f' g' h' k' hA' hB' hC' hD'
-      top back-left' back-right' front-left' front-right' bottom)
-  (σA : hA ~ hA') (σB : hB ~ hB') (σC : hC ~ hC') (σD : hD ~ hD')
-  (back-left-H : htpy-hom-map f f' hA hB back-left hA' hB' back-left' σA σB)
-  (back-right-H : htpy-hom-map g g' hA hC back-right hA' hC' back-right' σA σC)
-  (front-left-H : htpy-hom-map h h' hB hD front-left hB' hD' front-left' σB σD)
-  (front-right-H : htpy-hom-map k k' hC hD front-right hC' hD' front-right' σC σD)
-  where
-  open import foundation.commuting-squares-of-homotopies
-
-  htpy-hom-square :
-    UU (l4 ⊔ l1')
-  htpy-hom-square =
-    htpy-hom-htpy (h ∘ f) (k ∘ g) (h' ∘ f') (k' ∘ g') bottom top hA hD
-      ( pasting-horizontal-coherence-square-maps f' h' hA hB hD f h back-left front-left)
-      ( pasting-horizontal-coherence-square-maps g' k' hA hC hD g k back-right front-right)
-      ( α)
-      hA' hD'
-      ( pasting-horizontal-coherence-square-maps f' h' hA' hB' hD' f h back-left' front-left')
-      ( pasting-horizontal-coherence-square-maps g' k' hA' hC' hD' g k back-right' front-right')
-      ( β)
-      σA σD
-      ( comp-htpy-hom-map f h f' h' hA hA' hB hB' hD hD' σA σB σD
-        back-left back-left' back-left-H
-        front-left front-left' front-left-H)
-      ( comp-htpy-hom-map g k g' k' hA hA' hC hC' hD hD' σA σC σD
-        back-right back-right' back-right-H
-        front-right front-right' front-right-H)
-
 module _
   {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
-  (f : A → B) (g : A → C) (h : B → D) (k : C → D)
-  (H : coherence-square-maps g f k h)
+  {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
+  {f' g' : A' → B'} (top : f' ~ g')
+  {f g : A → B} (bottom : f ~ g)
+  (hA : A' → A) (hB : B' → B)
+  (N : coherence-square-maps f' hA hB f)
+  (F : coherence-square-maps g' hA hB g)
+  (α : hom-htpy top bottom {hB = hB} N F)
   where
 
-  id-cube :
-    coherence-cube-maps f g h k f g h k id id id id
-      H refl-htpy refl-htpy refl-htpy refl-htpy H
-  id-cube = left-unit-law-left-whisker-comp H ∙h inv-htpy-right-unit-htpy
+  coh-section-hom-htpy :
+    (sA : section hA) (sB : section hB)
+    (sN : coherence-square-maps f (map-section hA sA) (map-section hB sB) f')
+    (sF : coherence-square-maps g (map-section hA sA) (map-section hB sB) g')
+    (β : hom-htpy bottom top {hB = map-section hB sB} sN sF)
+    (γN :
+      htpy-hom-map f f
+        ( hA ∘ map-section hA sA) (hB ∘ map-section hB sB)
+        ( pasting-vertical-coherence-square-maps f
+          ( map-section hA sA) (map-section hB sB)
+          f' hA hB f sN N)
+        id id refl-htpy
+        ( is-section-map-section hA sA)
+        ( is-section-map-section hB sB))
+    (γF :
+      htpy-hom-map g g
+        ( hA ∘ pr1 sA) (hB ∘ pr1 sB)
+        ( pasting-vertical-coherence-square-maps g (pr1 sA) (pr1 sB) g' hA
+          hB g sF F)
+        id id refl-htpy (pr2 sA) (pr2 sB)) →
+    UU (l1 ⊔ l2)
+  coh-section-hom-htpy sA sB sN sF β =
+    htpy-hom-htpy f g f g bottom bottom
+      ( hA ∘ map-section hA sA)
+      ( hB ∘ map-section hB sB)
+      ( pasting-vertical-coherence-square-maps f map-sA map-sB f' hA hB f sN N)
+      ( pasting-vertical-coherence-square-maps g map-sA map-sB g' hA hB g sF F)
+      ( pasting-vertical-hom-htpy top bottom bottom N F sN sF α β)
+      id id refl-htpy refl-htpy (id-hom-htpy bottom)
+      ( is-section-map-section hA sA)
+      ( is-section-map-section hB sB)
+    where
+      map-sA : A → A'
+      map-sA = map-section hA sA
+      map-sB : B → B'
+      map-sB = map-section hB sB
 
 module _
-  {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
-  (f : A → B) (g : A → C) (h : B → D) (k : C → D)
-  {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
-  (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
-  (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
-  (top : (h' ∘ f') ~ (k' ∘ g'))
-  (back-left : (f ∘ hA) ~ (hB ∘ f'))
-  (back-right : (g ∘ hA) ~ (hC ∘ g'))
-  (front-left : (h ∘ hB) ~ (hD ∘ h'))
-  (front-right : (k ∘ hC) ~ (hD ∘ k'))
-  (bottom : (h ∘ f) ~ (k ∘ g))
-  (α :
-    coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
-      top back-left back-right front-left front-right bottom)
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
   where
 
-  section-displayed-cube-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4 ⊔ l1' ⊔ l2' ⊔ l3' ⊔ l4')
-  section-displayed-cube-over =
-    Σ ( section-displayed-map-over f f' hA hB back-left)
-      ( λ sF →
-        Σ ( section-displayed-map-over k k' hC hD front-right)
-          ( λ sK →
-            Σ ( coherence-square-maps g
-                ( map-section hA (pr1 sF))
-                ( map-section hC (pr1 sK))
-                ( g'))
-              ( λ G →
-                Σ ( htpy-hom-map g g
-                    ( hA ∘ map-section hA (pr1 sF))
-                    ( hC ∘ map-section hC (pr1 sK))
-                    ( pasting-vertical-coherence-square-maps g
-                      ( map-section hA (pr1 sF))
-                      ( map-section hC (pr1 sK))
-                      g' hA hC g
-                      G back-right)
-                    id id refl-htpy
-                    ( is-section-map-section hA (pr1 sF))
-                    ( is-section-map-section hC (pr1 sK)))
-                  ( λ sG →
-                    Σ ( coherence-square-maps h
-                        ( map-section hB (pr1 (pr2 sF)))
-                        ( map-section hD (pr1 (pr2 sK)))
-                        ( h'))
-                      ( λ H →
-                        Σ ( htpy-hom-map h h
-                            ( hB ∘ map-section hB (pr1 (pr2 sF)))
-                            ( hD ∘ map-section hD (pr1 (pr2 sK)))
-                            ( pasting-vertical-coherence-square-maps h
-                              ( map-section hB (pr1 (pr2 sF)))
-                              ( map-section hD (pr1 (pr2 sK)))
-                              h' hB hD h
-                              H front-left)
-                            id id refl-htpy
-                            ( is-section-map-section hB (pr1 (pr2 sF)))
-                            ( is-section-map-section hD (pr1 (pr2 sK))))
-                          ( λ sH →
-                            Σ ( coherence-cube-maps f' g' h' k' f g h k
-                                ( map-section hA (pr1 sF))
-                                ( map-section hB (pr1 (pr2 sF)))
-                                ( map-section hC (pr1 sK))
-                                ( map-section hD (pr1 (pr2 sK)))
-                                ( bottom)
-                                ( pr1 (pr2 (pr2 sF)))
-                                ( G)
-                                ( H)
-                                ( pr1 (pr2 (pr2 sK)))
-                                ( top))
-                              ( λ β →
-                                htpy-hom-square f g h k f g h k bottom bottom
-                                  ( hA ∘ map-section hA (pr1 sF))
-                                  ( hB ∘ map-section hB (pr1 (pr2 sF)))
-                                  ( hC ∘ map-section hC (pr1 sK))
-                                  ( hD ∘ map-section hD (pr1 (pr2 sK)))
-                                  ( pasting-vertical-coherence-square-maps f
-                                    ( map-section hA (pr1 sF))
-                                    ( map-section hB (pr1 (pr2 sF)))
-                                    f' hA hB f
-                                    ( pr1 (pr2 (pr2 sF)))
-                                    ( back-left))
-                                  ( pasting-vertical-coherence-square-maps g
-                                    ( map-section hA (pr1 sF))
-                                    ( map-section hC (pr1 sK))
-                                    g' hA hC g
-                                    ( G)
-                                    ( back-right))
-                                  ( pasting-vertical-coherence-square-maps h
-                                    ( map-section hB (pr1 (pr2 sF)))
-                                    ( map-section hD (pr1 (pr2 sK)))
-                                    h' hB hD h
-                                    ( H)
-                                    ( front-left))
-                                  ( pasting-vertical-coherence-square-maps k
-                                    ( map-section hC (pr1 sK))
-                                    ( map-section hD (pr1 (pr2 sK)))
-                                    k' hC hD k
-                                    ( pr1 (pr2 (pr2 sK)))
-                                    ( front-right))
-                                  ( pasting-vertical-coherence-cube-maps f g h k
-                                    f' g' h' k' f g h k
-                                    hA hB hC hD
-                                    ( map-section hA (pr1 sF))
-                                    ( map-section hB (pr1 (pr2 sF)))
-                                    ( map-section hC (pr1 sK))
-                                    ( map-section hD (pr1 (pr2 sK)))
-                                    ( top)
-                                    back-left back-right front-left front-right bottom
-                                    ( bottom)
-                                    ( pr1 (pr2 (pr2 sF)))
-                                    ( G)
-                                    ( H)
-                                    ( pr1 (pr2 (pr2 sK)))
-                                    ( α)
-                                    ( β))
-                                  id id id id
-                                  refl-htpy refl-htpy refl-htpy refl-htpy
-                                  ( id-cube f g h k bottom)
-                                  ( is-section-map-section hA (pr1 sF))
-                                  ( is-section-map-section hB (pr1 (pr2 sF)))
-                                  ( is-section-map-section hC (pr1 sK))
-                                  ( is-section-map-section hD (pr1 (pr2 sK)))
-                                  ( pr2 (pr2 (pr2 sF)))
-                                  ( sG)
-                                  ( sH)
-                                  ( pr2 (pr2 (pr2 sK))))))))))
+  compute-concat-dependent-identification-right-base-refl :
+    { x y : A} (p : x ＝ y) →
+    { x' : B x} {y' z' : B y} (p' : dependent-identification B p x' y') →
+    ( q' : y' ＝ z') →
+    concat-dependent-identification B p refl p' q' ＝ ap (λ r → tr B r x') right-unit ∙ p' ∙ q'
+  compute-concat-dependent-identification-right-base-refl refl p' q' = ap (_∙ q') (ap-id p')
+
+  interchange-concat-eq-pair-Σ-left :
+    {y z : A} (q : y ＝ z) {x' y' : B y} {z' : B z} →
+    (p' : x' ＝ y')
+    (q' : dependent-identification B q y' z') →
+    eq-pair-eq-fiber p' ∙ eq-pair-Σ q q' ＝
+    eq-pair-Σ q (ap (tr B q) p' ∙ q')
+  interchange-concat-eq-pair-Σ-left q refl q' = refl
+
+  interchange-concat-eq-pair-Σ-right :
+    {x y : A} (p : x ＝ y) {x' : B x} {y' z' : B y} →
+    (p' : dependent-identification B p x' y') →
+    (q' : y' ＝ z') →
+    eq-pair-Σ p p' ∙ eq-pair-eq-fiber q' ＝
+    eq-pair-Σ p (p' ∙ q')
+  interchange-concat-eq-pair-Σ-right p p' refl =
+    right-unit ∙ ap (eq-pair-Σ p) (inv right-unit)
 
 module _
-  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
-  {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
-  {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
-  (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
-  (g1' : (p : P1) → Q1 p → Q3 (g1 p))
-  (f1' : (p : P1) → Q1 p → Q2 (f1 p))
-  (f2' : (p : P3) → Q3 p → Q4 (f2 p))
-  (g2' : (p : P2) → Q2 p → Q4 (g2 p))
-  (bottom : g2 ∘ f1 ~ f2 ∘ g1)
-  (top : square-over g1 f1 f2 g2 (g1' _) (f1' _) (f2' _) (g2' _) bottom)
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2} {P : A → UU l3} {Q : B → UU l4}
+  {f g : A → B} (H : f ~ g)
+  {f' : (a : A) → P a → Q (f a)} {g' : (a : A) → P a → Q (g a)}
+  (H' : htpy-over Q H (f' _) (g' _))
+  (sA : (a : A) → P a)
+  (sB : (b : B) → Q b)
+  (F : section-map-over f (f' _) sA sB)
+  (G : section-map-over g (g' _) sA sB)
+  (α : section-htpy-over H H' sA sB F G)
   where
-
-  tot-square-over :
-    coherence-square-maps
-      ( tot-map-over g1 g1')
-      ( tot-map-over f1 f1')
-      ( tot-map-over {B' = Q4} f2 f2')
-      ( tot-map-over g2 g2')
-  tot-square-over =
-    coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})
-
-  coh-tot-square-over :
-    coherence-cube-maps f1 g1 g2 f2
-      ( map-Σ Q2 f1 f1')
-      ( map-Σ Q3 g1 g1')
-      ( map-Σ Q4 g2 g2')
-      ( map-Σ Q4 f2 f2')
-      pr1 pr1 pr1 pr1
-      ( tot-square-over)
-      refl-htpy refl-htpy refl-htpy refl-htpy
-      ( bottom)
-  coh-tot-square-over (p , q) =
-    ap-pr1-eq-pair-Σ (bottom p) (top q) ∙ inv right-unit
-
-  module _
-    (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p)
-    (s3 : (p : P3) → Q3 p) (s4 : (p : P4) → Q4 p)
-    (G1 : (p : P1) → g1' p (s1 p) ＝ s3 (g1 p))
-    (F1 : (p : P1) → f1' p (s1 p) ＝ s2 (f1 p))
-    (F2 : (p : P3) → f2' p (s3 p) ＝ s4 (f2 p))
-    (G2 : (p : P2) → g2' p (s2 p) ＝ s4 (g2 p))
-    where
-    open import foundation.action-on-identifications-binary-functions
-
-    lemma :
-      pasting-vertical-coherence-square-maps g1
-        ( map-section-family s1) (map-section-family s3)
-        ( tot-map-over g1 g1') (tot-map-over f1 f1')
-        ( tot-map-over {B' = Q4} f2 f2') (tot-map-over g2 g2')
-        ( eq-pair-eq-fiber ∘ G1)
-        ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})) ~
-      ( λ p → eq-pair-Σ (bottom p) (top (s1 p) ∙ ap (f2' (g1 p)) (G1 p)))
-    lemma = λ p → ap
-              ( eq-pair-Σ (bottom p) (top (s1 p)) ∙_)
-              ( [i] p) ∙
-              ( inv (concat-vertical-eq-pair (bottom p) (top (s1 p)) (ap (f2' (g1 p)) (G1 p))))
-        where
-        [i] =
-          λ (p : P1) →
-          inv (ap-comp (map-Σ Q4 f2 f2') (pair (g1 p)) (G1 p)) ∙
-          ap-comp (pair (f2 (g1 p))) (f2' (g1 p)) (G1 p)
-
-    section-cube-over-sect-square-over :
-      section-square-over g1 f1 f2 g2
-        ( g1' _) (f1' _) (f2' _) (g2' _)
-        s1 s2 s3 s4
-        G1 F1 F2 G2
-        bottom top →
-      section-displayed-cube-over f1 g1 g2 f2
-        ( tot-map-over f1 f1')
-        ( tot-map-over g1 g1')
-        ( tot-map-over g2 g2')
-        ( tot-map-over f2 f2')
-        pr1 pr1 pr1 pr1
-        ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p}))
-        refl-htpy refl-htpy refl-htpy refl-htpy
-        ( bottom)
-        ( coh-tot-square-over)
-    pr1 (section-cube-over-sect-square-over α) =
-      ( section-dependent-function s1) ,
-      ( section-dependent-function s2) ,
-      ( eq-pair-eq-fiber ∘ F1) ,
-      ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F1 p))
-    pr1 (pr2 (section-cube-over-sect-square-over α)) =
-      ( section-dependent-function s3) ,
-      ( section-dependent-function s4) ,
-      ( eq-pair-eq-fiber ∘ F2) ,
-      ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F2 p))
-    pr2 (pr2 (section-cube-over-sect-square-over α)) =
-      ( eq-pair-eq-fiber ∘ G1) ,
-      ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G1 p)) ,
-      ( eq-pair-eq-fiber ∘ G2) ,
-      ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G2 p)) ,
-      ( λ p →
-        ap-binary
-          ( _∙_)
-          ( pasting-horizontal-comp f1' g2' s1 s2 s4 F1 G2 p)
-          ( ap-map-section-family-lemma s4 (bottom p)) ∙
-        {!!} ∙
-        ap (eq-pair-Σ (bottom p)) (inv (α p) ∙ assoc (top (s1 p)) (ap (f2' (g1 p)) (G1 p)) (F2 (g1 p))) ∙
-        concat-vertical-eq-pair
-          ( bottom p)
-          ( top (s1 p))
-          ( ap (f2' (g1 p)) (G1 p) ∙ F2 (g1 p)) ∙
-        ap-binary
-          ( _∙_)
-          ( refl {x = eq-pair-Σ (bottom p) (top (s1 p))})
-          ( inv (pasting-horizontal-comp g1' f2' s1 s3 s4 G1 F2 p))) ,
-      {!!}
-```
+  open import foundation.embeddings
+
+  _ : coh-section-hom-htpy
+    ( λ p → eq-pair-Σ (H (pr1 p)) (H' (pr2 p)))
+    ( H)
+    pr1 pr1 refl-htpy refl-htpy
+    ( λ p → ap-pr1-eq-pair-Σ (H (pr1 p)) (H' (pr2 p)) ∙ inv right-unit)
+    ( section-dependent-function sA)
+    ( section-dependent-function sB)
+    ( eq-pair-eq-fiber ∘ F)
+    ( eq-pair-eq-fiber ∘ G)
+    -- The point is that this will be `ap pr1`'d, so the α in the fiber is
+    -- projected away. This definition should probably be defined in a nicer way
+    -- to make the proof less opaque.
+    ( λ a →
+      ap (eq-pair-eq-fiber (F a) ∙_) (ap-map-section-family-lemma sB (H a)) ∙
+      interchange-concat-eq-pair-Σ-left (H a) (F a) (apd sB (H a)) ∙
+      ap (eq-pair-Σ (H a)) (inv (α a)) ∙
+      inv (interchange-concat-eq-pair-Σ-right (H a) (H' (sA a)) (G a)))
+    ( λ a → right-unit ∙ ap-pr1-eq-pair-eq-fiber (F a))
+    ( λ a → right-unit ∙ ap-pr1-eq-pair-eq-fiber (G a))
+  _ = {!!}
+
+-- module _
+--   {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
+--   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+--   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+--   {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
+--   (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
+--   (top : h' ∘ f' ~ k' ∘ g')
+--   (bottom : h ∘ f ~ k ∘ g)
+--   (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
+--   (back-left : (f ∘ hA) ~ (hB ∘ f'))
+--   (back-right : (g ∘ hA) ~ (hC ∘ g'))
+--   (front-left : (h ∘ hB) ~ (hD ∘ h'))
+--   (front-right : (k ∘ hC) ~ (hD ∘ k'))
+--   (α :
+--     coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
+--       top back-left back-right front-left front-right bottom)
+--   (hA' : A' → A) (hB' : B' → B) (hC' : C' → C) (hD' : D' → D)
+--   (back-left' : (f ∘ hA') ~ (hB' ∘ f'))
+--   (back-right' : (g ∘ hA') ~ (hC' ∘ g'))
+--   (front-left' : (h ∘ hB') ~ (hD' ∘ h'))
+--   (front-right' : (k ∘ hC') ~ (hD' ∘ k'))
+--   (β :
+--     coherence-cube-maps f g h k f' g' h' k' hA' hB' hC' hD'
+--       top back-left' back-right' front-left' front-right' bottom)
+--   (σA : hA ~ hA') (σB : hB ~ hB') (σC : hC ~ hC') (σD : hD ~ hD')
+--   (back-left-H : htpy-hom-map f f' hA hB back-left hA' hB' back-left' σA σB)
+--   (back-right-H : htpy-hom-map g g' hA hC back-right hA' hC' back-right' σA σC)
+--   (front-left-H : htpy-hom-map h h' hB hD front-left hB' hD' front-left' σB σD)
+--   (front-right-H : htpy-hom-map k k' hC hD front-right hC' hD' front-right' σC σD)
+--   where
+--   open import foundation.commuting-squares-of-homotopies
+
+--   htpy-hom-square :
+--     UU (l4 ⊔ l1')
+--   htpy-hom-square =
+--     htpy-hom-htpy (h ∘ f) (k ∘ g) (h' ∘ f') (k' ∘ g') bottom top hA hD
+--       ( pasting-horizontal-coherence-square-maps f' h' hA hB hD f h back-left front-left)
+--       ( pasting-horizontal-coherence-square-maps g' k' hA hC hD g k back-right front-right)
+--       ( α)
+--       hA' hD'
+--       ( pasting-horizontal-coherence-square-maps f' h' hA' hB' hD' f h back-left' front-left')
+--       ( pasting-horizontal-coherence-square-maps g' k' hA' hC' hD' g k back-right' front-right')
+--       ( β)
+--       σA σD
+--       ( comp-htpy-hom-map f h f' h' hA hA' hB hB' hD hD' σA σB σD
+--         back-left back-left' back-left-H
+--         front-left front-left' front-left-H)
+--       ( comp-htpy-hom-map g k g' k' hA hA' hC hC' hD hD' σA σC σD
+--         back-right back-right' back-right-H
+--         front-right front-right' front-right-H)
+
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+--   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+--   (H : coherence-square-maps g f k h)
+--   where
+
+--   id-cube :
+--     coherence-cube-maps f g h k f g h k id id id id
+--       H refl-htpy refl-htpy refl-htpy refl-htpy H
+--   id-cube = left-unit-law-left-whisker-comp H ∙h inv-htpy-right-unit-htpy
+
+-- module _
+--   {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
+--   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+--   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+--   {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
+--   (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
+--   (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
+--   (top : (h' ∘ f') ~ (k' ∘ g'))
+--   (back-left : (f ∘ hA) ~ (hB ∘ f'))
+--   (back-right : (g ∘ hA) ~ (hC ∘ g'))
+--   (front-left : (h ∘ hB) ~ (hD ∘ h'))
+--   (front-right : (k ∘ hC) ~ (hD ∘ k'))
+--   (bottom : (h ∘ f) ~ (k ∘ g))
+--   (α :
+--     coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
+--       top back-left back-right front-left front-right bottom)
+--   where
+
+--   section-displayed-cube-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4 ⊔ l1' ⊔ l2' ⊔ l3' ⊔ l4')
+--   section-displayed-cube-over =
+--     Σ ( section-displayed-map-over f f' hA hB back-left)
+--       ( λ sF →
+--         Σ ( section-displayed-map-over k k' hC hD front-right)
+--           ( λ sK →
+--             Σ ( coherence-square-maps g
+--                 ( map-section hA (pr1 sF))
+--                 ( map-section hC (pr1 sK))
+--                 ( g'))
+--               ( λ G →
+--                 Σ ( htpy-hom-map g g
+--                     ( hA ∘ map-section hA (pr1 sF))
+--                     ( hC ∘ map-section hC (pr1 sK))
+--                     ( pasting-vertical-coherence-square-maps g
+--                       ( map-section hA (pr1 sF))
+--                       ( map-section hC (pr1 sK))
+--                       g' hA hC g
+--                       G back-right)
+--                     id id refl-htpy
+--                     ( is-section-map-section hA (pr1 sF))
+--                     ( is-section-map-section hC (pr1 sK)))
+--                   ( λ sG →
+--                     Σ ( coherence-square-maps h
+--                         ( map-section hB (pr1 (pr2 sF)))
+--                         ( map-section hD (pr1 (pr2 sK)))
+--                         ( h'))
+--                       ( λ H →
+--                         Σ ( htpy-hom-map h h
+--                             ( hB ∘ map-section hB (pr1 (pr2 sF)))
+--                             ( hD ∘ map-section hD (pr1 (pr2 sK)))
+--                             ( pasting-vertical-coherence-square-maps h
+--                               ( map-section hB (pr1 (pr2 sF)))
+--                               ( map-section hD (pr1 (pr2 sK)))
+--                               h' hB hD h
+--                               H front-left)
+--                             id id refl-htpy
+--                             ( is-section-map-section hB (pr1 (pr2 sF)))
+--                             ( is-section-map-section hD (pr1 (pr2 sK))))
+--                           ( λ sH →
+--                             Σ ( coherence-cube-maps f' g' h' k' f g h k
+--                                 ( map-section hA (pr1 sF))
+--                                 ( map-section hB (pr1 (pr2 sF)))
+--                                 ( map-section hC (pr1 sK))
+--                                 ( map-section hD (pr1 (pr2 sK)))
+--                                 ( bottom)
+--                                 ( pr1 (pr2 (pr2 sF)))
+--                                 ( G)
+--                                 ( H)
+--                                 ( pr1 (pr2 (pr2 sK)))
+--                                 ( top))
+--                               ( λ β →
+--                                 htpy-hom-square f g h k f g h k bottom bottom
+--                                   ( hA ∘ map-section hA (pr1 sF))
+--                                   ( hB ∘ map-section hB (pr1 (pr2 sF)))
+--                                   ( hC ∘ map-section hC (pr1 sK))
+--                                   ( hD ∘ map-section hD (pr1 (pr2 sK)))
+--                                   ( pasting-vertical-coherence-square-maps f
+--                                     ( map-section hA (pr1 sF))
+--                                     ( map-section hB (pr1 (pr2 sF)))
+--                                     f' hA hB f
+--                                     ( pr1 (pr2 (pr2 sF)))
+--                                     ( back-left))
+--                                   ( pasting-vertical-coherence-square-maps g
+--                                     ( map-section hA (pr1 sF))
+--                                     ( map-section hC (pr1 sK))
+--                                     g' hA hC g
+--                                     ( G)
+--                                     ( back-right))
+--                                   ( pasting-vertical-coherence-square-maps h
+--                                     ( map-section hB (pr1 (pr2 sF)))
+--                                     ( map-section hD (pr1 (pr2 sK)))
+--                                     h' hB hD h
+--                                     ( H)
+--                                     ( front-left))
+--                                   ( pasting-vertical-coherence-square-maps k
+--                                     ( map-section hC (pr1 sK))
+--                                     ( map-section hD (pr1 (pr2 sK)))
+--                                     k' hC hD k
+--                                     ( pr1 (pr2 (pr2 sK)))
+--                                     ( front-right))
+--                                   ( pasting-vertical-coherence-cube-maps f g h k
+--                                     f' g' h' k' f g h k
+--                                     hA hB hC hD
+--                                     ( map-section hA (pr1 sF))
+--                                     ( map-section hB (pr1 (pr2 sF)))
+--                                     ( map-section hC (pr1 sK))
+--                                     ( map-section hD (pr1 (pr2 sK)))
+--                                     ( top)
+--                                     back-left back-right front-left front-right bottom
+--                                     ( bottom)
+--                                     ( pr1 (pr2 (pr2 sF)))
+--                                     ( G)
+--                                     ( H)
+--                                     ( pr1 (pr2 (pr2 sK)))
+--                                     ( α)
+--                                     ( β))
+--                                   id id id id
+--                                   refl-htpy refl-htpy refl-htpy refl-htpy
+--                                   ( id-cube f g h k bottom)
+--                                   ( is-section-map-section hA (pr1 sF))
+--                                   ( is-section-map-section hB (pr1 (pr2 sF)))
+--                                   ( is-section-map-section hC (pr1 sK))
+--                                   ( is-section-map-section hD (pr1 (pr2 sK)))
+--                                   ( pr2 (pr2 (pr2 sF)))
+--                                   ( sG)
+--                                   ( sH)
+--                                   ( pr2 (pr2 (pr2 sK))))))))))
+
+-- module _
+--   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+--   {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
+--   {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
+--   (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
+--   (g1' : (p : P1) → Q1 p → Q3 (g1 p))
+--   (f1' : (p : P1) → Q1 p → Q2 (f1 p))
+--   (f2' : (p : P3) → Q3 p → Q4 (f2 p))
+--   (g2' : (p : P2) → Q2 p → Q4 (g2 p))
+--   (bottom : g2 ∘ f1 ~ f2 ∘ g1)
+--   (top : square-over g1 f1 f2 g2 (g1' _) (f1' _) (f2' _) (g2' _) bottom)
+--   where
+
+--   tot-square-over :
+--     coherence-square-maps
+--       ( tot-map-over g1 g1')
+--       ( tot-map-over f1 f1')
+--       ( tot-map-over {B' = Q4} f2 f2')
+--       ( tot-map-over g2 g2')
+--   tot-square-over =
+--     coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})
+
+--   coh-tot-square-over :
+--     coherence-cube-maps f1 g1 g2 f2
+--       ( map-Σ Q2 f1 f1')
+--       ( map-Σ Q3 g1 g1')
+--       ( map-Σ Q4 g2 g2')
+--       ( map-Σ Q4 f2 f2')
+--       pr1 pr1 pr1 pr1
+--       ( tot-square-over)
+--       refl-htpy refl-htpy refl-htpy refl-htpy
+--       ( bottom)
+--   coh-tot-square-over (p , q) =
+--     ap-pr1-eq-pair-Σ (bottom p) (top q) ∙ inv right-unit
+
+--   module _
+--     (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p)
+--     (s3 : (p : P3) → Q3 p) (s4 : (p : P4) → Q4 p)
+--     (G1 : (p : P1) → g1' p (s1 p) ＝ s3 (g1 p))
+--     (F1 : (p : P1) → f1' p (s1 p) ＝ s2 (f1 p))
+--     (F2 : (p : P3) → f2' p (s3 p) ＝ s4 (f2 p))
+--     (G2 : (p : P2) → g2' p (s2 p) ＝ s4 (g2 p))
+--     where
+--     open import foundation.action-on-identifications-binary-functions
+
+--     lemma :
+--       pasting-vertical-coherence-square-maps g1
+--         ( map-section-family s1) (map-section-family s3)
+--         ( tot-map-over g1 g1') (tot-map-over f1 f1')
+--         ( tot-map-over {B' = Q4} f2 f2') (tot-map-over g2 g2')
+--         ( eq-pair-eq-fiber ∘ G1)
+--         ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})) ~
+--       ( λ p → eq-pair-Σ (bottom p) (top (s1 p) ∙ ap (f2' (g1 p)) (G1 p)))
+--     lemma = λ p → ap
+--               ( eq-pair-Σ (bottom p) (top (s1 p)) ∙_)
+--               ( [i] p) ∙
+--               ( inv (concat-vertical-eq-pair (bottom p) (top (s1 p)) (ap (f2' (g1 p)) (G1 p))))
+--         where
+--         [i] =
+--           λ (p : P1) →
+--           inv (ap-comp (map-Σ Q4 f2 f2') (pair (g1 p)) (G1 p)) ∙
+--           ap-comp (pair (f2 (g1 p))) (f2' (g1 p)) (G1 p)
+
+--     section-cube-over-sect-square-over :
+--       section-square-over g1 f1 f2 g2
+--         ( g1' _) (f1' _) (f2' _) (g2' _)
+--         s1 s2 s3 s4
+--         G1 F1 F2 G2
+--         bottom top →
+--       section-displayed-cube-over f1 g1 g2 f2
+--         ( tot-map-over f1 f1')
+--         ( tot-map-over g1 g1')
+--         ( tot-map-over g2 g2')
+--         ( tot-map-over f2 f2')
+--         pr1 pr1 pr1 pr1
+--         ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p}))
+--         refl-htpy refl-htpy refl-htpy refl-htpy
+--         ( bottom)
+--         ( coh-tot-square-over)
+--     pr1 (section-cube-over-sect-square-over α) =
+--       ( section-dependent-function s1) ,
+--       ( section-dependent-function s2) ,
+--       ( eq-pair-eq-fiber ∘ F1) ,
+--       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F1 p))
+--     pr1 (pr2 (section-cube-over-sect-square-over α)) =
+--       ( section-dependent-function s3) ,
+--       ( section-dependent-function s4) ,
+--       ( eq-pair-eq-fiber ∘ F2) ,
+--       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F2 p))
+--     pr2 (pr2 (section-cube-over-sect-square-over α)) =
+--       ( eq-pair-eq-fiber ∘ G1) ,
+--       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G1 p)) ,
+--       ( eq-pair-eq-fiber ∘ G2) ,
+--       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G2 p)) ,
+--       ( λ p →
+--         ap-binary
+--           ( _∙_)
+--           ( pasting-horizontal-comp f1' g2' s1 s2 s4 F1 G2 p)
+--           ( ap-map-section-family-lemma s4 (bottom p)) ∙
+--         {!!} ∙
+--         ap (eq-pair-Σ (bottom p)) (inv (α p) ∙ assoc (top (s1 p)) (ap (f2' (g1 p)) (G1 p)) (F2 (g1 p))) ∙
+--         concat-vertical-eq-pair
+--           ( bottom p)
+--           ( top (s1 p))
+--           ( ap (f2' (g1 p)) (G1 p) ∙ F2 (g1 p)) ∙
+--         ap-binary
+--           ( _∙_)
+--           ( refl {x = eq-pair-Σ (bottom p) (top (s1 p))})
+--           ( inv (pasting-horizontal-comp g1' f2' s1 s3 s4 G1 F2 p))) ,
+--       {!!}
+-- ```

From 83d5333adaf76c0aa3a742822955ca9616526003 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Thu, 6 Feb 2025 18:33:52 +0100
Subject: [PATCH 22/33] Some preservation properties

---
 .../functoriality-stuff.lagda.md              | 406 +++++++++++++++---
 .../morphisms-sequential-diagrams.lagda.md    |  51 +++
 2 files changed, 402 insertions(+), 55 deletions(-)

diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index ea2ed0e2ff..2fa9750471 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -227,6 +227,75 @@ module _
     where open import foundation.action-on-identifications-binary-functions
 ```
 
+## Vertical pasting of cubes of stuff
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : sequential-diagram l1} {B : sequential-diagram l2}
+  {A' : sequential-diagram l3} {B' : sequential-diagram l4}
+  {A'' : sequential-diagram l5} {B'' : sequential-diagram l6}
+  (top : hom-sequential-diagram A'' B'')
+  (top-left : hom-sequential-diagram A'' A')
+  (top-right : hom-sequential-diagram B'' B')
+  (mid : hom-sequential-diagram A' B')
+  (bottom-left : hom-sequential-diagram A' A)
+  (bottom-right : hom-sequential-diagram B' B)
+  (bottom : hom-sequential-diagram A B)
+  (H :
+    htpy-hom-sequential-diagram B
+      ( comp-hom-sequential-diagram A' A B bottom bottom-left)
+      ( comp-hom-sequential-diagram A' B' B bottom-right mid))
+  (K :
+    htpy-hom-sequential-diagram B'
+      ( comp-hom-sequential-diagram A'' A' B' mid top-left)
+      ( comp-hom-sequential-diagram A'' B'' B' top-right top))
+  -- (faces-top :
+  --   (n : ℕ) →
+  --   coherence-square-maps
+  --     ( map-hom-sequential-diagram B'' top n)
+  --     ( map-hom-sequential-diagram A' top-left n)
+  --     ( map-hom-sequential-diagram B' top-right n)
+  --     ( map-hom-sequential-diagram B' mid n))
+  -- (faces-bottom :
+  --   (n : ℕ) → {!!})
+  -- (cubes-top :
+  --   (n : ℕ) → {!!})
+  -- (cubes-bottom :
+  --   (n : ℕ) → {!!})
+  -- -- (cubes :
+  -- --   (n : ℕ) →
+  -- --   coherence-cube-maps
+  -- --     ( map-hom-sequential-diagram B f n)
+  -- --     ( map-sequential-diagram A n)
+  -- --     ( map-sequential-diagram B n)
+  -- --     ( map-hom-sequential-diagram B f (succ-ℕ n))
+  -- --     ( map-hom-sequential-diagram Q f' n)
+  -- --     ( map-sequential-diagram P n)
+  -- --     ( map-sequential-diagram Q n)
+  -- --     ( map-hom-sequential-diagram Q f' (succ-ℕ n))
+  -- --     ( map-hom-sequential-diagram A g n)
+  -- --     ( map-hom-sequential-diagram B h n)
+  -- --     ( map-hom-sequential-diagram A g (succ-ℕ n))
+  -- --     ( map-hom-sequential-diagram B h (succ-ℕ n))
+  -- --     ( naturality-map-hom-sequential-diagram Q f' n)
+  -- --     ( faces n)
+  -- --     ( naturality-map-hom-sequential-diagram A g n)
+  -- --     ( naturality-map-hom-sequential-diagram B h n)
+  -- --     ( faces (succ-ℕ n))
+  -- --     ( naturality-map-hom-sequential-diagram B f n)) →
+  where
+
+  pasting-vertical-coherence-square-hom-sequential-diagram :
+    htpy-hom-sequential-diagram B
+      ( comp-hom-sequential-diagram A'' A B bottom
+        ( comp-hom-sequential-diagram A'' A' A bottom-left top-left))
+      ( comp-hom-sequential-diagram A'' B'' B
+        ( comp-hom-sequential-diagram B'' B' B bottom-right top-right)
+        ( top))
+  pasting-vertical-coherence-square-hom-sequential-diagram = {!!}
+```
+
 ## Whiskering of homotopies of morphisms of sequential diagrams
 
 ### Right whiskering
@@ -388,60 +457,144 @@ module _
   {l1 l2 l3 : Level}
   {A : sequential-diagram l1} {B : sequential-diagram l2}
   {X : sequential-diagram l3}
-  (h : hom-sequential-diagram B X)
   {f g : hom-sequential-diagram A B}
-  (H : htpy-hom-sequential-diagram B f g)
   where
   open import foundation.whiskering-identifications-concatenation
 
-  left-whisker-concat-htpy-hom-sequential-diagram :
-    htpy-hom-sequential-diagram X
+  module _
+    (h : hom-sequential-diagram B X)
+    (H : htpy-hom-sequential-diagram B f g)
+    where
+
+    left-whisker-concat-htpy-hom-sequential-diagram :
+      htpy-hom-sequential-diagram X
+        ( comp-hom-sequential-diagram A B X h f)
+        ( comp-hom-sequential-diagram A B X h g)
+    pr1 left-whisker-concat-htpy-hom-sequential-diagram n =
+      map-hom-sequential-diagram X h n ·l htpy-htpy-hom-sequential-diagram _ H n
+    pr2 left-whisker-concat-htpy-hom-sequential-diagram n a =
+      assoc _ _ _ ∙
+      left-whisker-concat
+        ( naturality-map-hom-sequential-diagram X h n (map-hom-sequential-diagram B f n a))
+        ( inv (ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
+          ap
+            ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
+            ( coherence-htpy-htpy-hom-sequential-diagram B H n a) ∙
+          ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
+      inv (assoc _ _ _) ∙
+      right-whisker-concat
+        ( left-whisker-concat
+            ( naturality-map-hom-sequential-diagram X h n
+              ( map-hom-sequential-diagram B f n a))
+            ( inv
+              ( ap-comp
+                ( map-hom-sequential-diagram X h (succ-ℕ n))
+                ( map-sequential-diagram B n)
+                ( htpy-htpy-hom-sequential-diagram B H n a))) ∙
+          nat-htpy
+            ( naturality-map-hom-sequential-diagram X h n)
+            ( htpy-htpy-hom-sequential-diagram B H n a) ∙
+          right-whisker-concat
+            ( ap-comp
+              ( map-sequential-diagram X n)
+              ( map-hom-sequential-diagram X h n)
+              ( htpy-htpy-hom-sequential-diagram B H n a))
+            ( naturality-map-hom-sequential-diagram X h n
+              ( map-hom-sequential-diagram B g n a)))
+        ( ap
+          ( map-hom-sequential-diagram X h (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B g n a)) ∙
+      assoc _ _ _
+
+  htpy-eq-left-whisker-htpy-hom-sequential-diagram :
+    (h : hom-sequential-diagram B X) (p : f ＝ g) →
+    htpy-eq-sequential-diagram A X
       ( comp-hom-sequential-diagram A B X h f)
       ( comp-hom-sequential-diagram A B X h g)
-  pr1 left-whisker-concat-htpy-hom-sequential-diagram n =
-    map-hom-sequential-diagram X h n ·l htpy-htpy-hom-sequential-diagram _ H n
-  pr2 left-whisker-concat-htpy-hom-sequential-diagram n a =
-    assoc _ _ _ ∙
-    left-whisker-concat
-      ( naturality-map-hom-sequential-diagram X h n (map-hom-sequential-diagram B f n a))
-      ( inv (ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
-        ap
-          ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
-          ( coherence-htpy-htpy-hom-sequential-diagram B H n a) ∙
-        ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
-    inv (assoc _ _ _) ∙
-    right-whisker-concat
-      ( left-whisker-concat
-          ( naturality-map-hom-sequential-diagram X h n
-            ( map-hom-sequential-diagram B f n a))
-          ( inv
-            ( ap-comp
-              ( map-hom-sequential-diagram X h (succ-ℕ n))
-              ( map-sequential-diagram B n)
-              ( htpy-htpy-hom-sequential-diagram B H n a))) ∙
-        nat-htpy
-          ( naturality-map-hom-sequential-diagram X h n)
-          ( htpy-htpy-hom-sequential-diagram B H n a) ∙
-        right-whisker-concat
-          ( ap-comp
-            ( map-sequential-diagram X n)
-            ( map-hom-sequential-diagram X h n)
-            ( htpy-htpy-hom-sequential-diagram B H n a))
-          ( naturality-map-hom-sequential-diagram X h n
-            ( map-hom-sequential-diagram B g n a)))
+      ( ap (comp-hom-sequential-diagram A B X h) p) ＝
+    left-whisker-concat-htpy-hom-sequential-diagram h
+      ( htpy-eq-sequential-diagram A B f g p)
+  htpy-eq-left-whisker-htpy-hom-sequential-diagram h refl =
+    eq-pair-eq-fiber
+      ( eq-binary-htpy _ _
+        ( λ n a →
+          inv
+            ( right-unit ∙
+              ( ap-binary
+                ( λ p q →
+                  p ∙
+                  left-whisker-concat
+                    ( naturality-map-hom-sequential-diagram X h n
+                      ( map-hom-sequential-diagram B f n a))
+                    ( inv (ap-concat _ _ refl) ∙
+                      ap
+                        ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
+                        ( right-unit) ∙
+                      refl) ∙
+                  q ∙
+                  right-whisker-concat (right-unit ∙ refl) _)
+                ( right-unit-law-assoc _ (ap _ _) ∙
+                  left-whisker-concat right-unit (ap-inv _ right-unit))
+                ( ap inv (middle-unit-law-assoc _ _))) ∙
+              ( ap-binary
+                ( λ p q →
+                  right-unit ∙
+                  inv (left-whisker-concat _ right-unit) ∙
+                  left-whisker-concat _ p ∙
+                  inv (right-whisker-concat right-unit _) ∙
+                  right-whisker-concat q _)
+                ( right-unit ∙
+                  right-whisker-concat
+                    ( ap inv (compute-right-refl-ap-concat _ _) ∙
+                      distributive-inv-concat
+                        ( ap (ap _) right-unit)
+                        ( inv right-unit) ∙
+                      right-whisker-concat (inv-inv right-unit) _)
+                    ( ap (ap _) right-unit) ∙
+                  is-section-inv-concat' (ap (ap _) right-unit) right-unit)
+                ( right-unit)) ∙
+              is-section-inv-concat'
+                ( right-whisker-concat right-unit _)
+                ( right-unit ∙ inv _ ∙ _) ∙
+              is-section-inv-concat'
+                ( left-whisker-concat _ right-unit)
+                ( right-unit))))
+    where
+      open import foundation.action-on-identifications-binary-functions
+      open import foundation.binary-homotopies
+      open import foundation.path-algebra
+
+  eq-htpy-left-whisker-htpy-hom-sequential-diagram :
+    (h : hom-sequential-diagram B X) (H : htpy-hom-sequential-diagram B f g) →
+    eq-htpy-sequential-diagram A X
+      ( comp-hom-sequential-diagram A B X h f)
+      ( comp-hom-sequential-diagram A B X h g)
+      ( left-whisker-concat-htpy-hom-sequential-diagram h H) ＝
+    ap
+      ( comp-hom-sequential-diagram A B X h)
+      ( eq-htpy-sequential-diagram A B f g H)
+  eq-htpy-left-whisker-htpy-hom-sequential-diagram h H =
+    ap
+      ( eq-htpy-sequential-diagram A X _ _)
+      ( inv
+        ( htpy-eq-left-whisker-htpy-hom-sequential-diagram h
+            ( eq-htpy-sequential-diagram A B f g H) ∙
+          ap
+            ( left-whisker-concat-htpy-hom-sequential-diagram h)
+            ( is-section-map-inv-equiv
+              ( extensionality-hom-sequential-diagram A B f g)
+              ( H)))) ∙
+    is-retraction-map-inv-equiv
+      ( extensionality-hom-sequential-diagram A X
+        ( comp-hom-sequential-diagram A B X h f)
+        ( comp-hom-sequential-diagram A B X h g))
       ( ap
-        ( map-hom-sequential-diagram X h (succ-ℕ n))
-        ( naturality-map-hom-sequential-diagram B g n a)) ∙
-    assoc _ _ _
+        ( comp-hom-sequential-diagram A B X h)
+        ( eq-htpy-sequential-diagram A B f g H))
 ```
 
 ## Action on homotopies of morphisms of sequential diagrams preserves whiskering
 
-```agda
--- module _
---   {l1 l2 l3 l4 l5 l6 : Level}
-```
-
 ```agda
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
@@ -451,27 +604,80 @@ module _
   (up-b : universal-property-sequential-colimit b)
   {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
   {f g : hom-sequential-diagram B C}
-  (H : htpy-hom-sequential-diagram C f g)
-  (h : hom-sequential-diagram A B)
   where
 
+  coh-comp-hom-sequential-diagram :
+    (p : f ＝ g) (h : hom-sequential-diagram A B) →
+    ap
+      ( map-sequential-colimit-hom-sequential-diagram up-a c)
+      ( ap (λ f → comp-hom-sequential-diagram A B C f h) p) ∙
+    eq-htpy
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h) ＝
+    eq-htpy
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙
+    ap
+      ( _∘ map-sequential-colimit-hom-sequential-diagram up-a b h)
+      ( ap
+        ( map-sequential-colimit-hom-sequential-diagram up-b c)
+        ( p))
+  coh-comp-hom-sequential-diagram refl h = inv right-unit
+
   preserves-right-whisker-htpy-hom-sequential-diagram :
+    (H : htpy-hom-sequential-diagram C f g)
+    (h : hom-sequential-diagram A B) →
     ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
         ( right-whisker-concat-htpy-hom-sequential-diagram H h)) ∙h
       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h)) ~
     ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙h
       ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-b c H ·r
         map-sequential-colimit-hom-sequential-diagram up-a b h))
-  preserves-right-whisker-htpy-hom-sequential-diagram =
-    right-whisker-concat-htpy
-      ( htpy-eq
-        ( ap
+  preserves-right-whisker-htpy-hom-sequential-diagram H h =
+    htpy-eq
+      ( ( ap
           ( λ p →
             htpy-eq
-              ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p))
-          ( eq-htpy-right-whisker-htpy-hom-sequential-diagram H h)))
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h) ∙h
-    {!!}
+              ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p) ∙h
+            preserves-comp-map-sequential-colimit-hom-sequential-diagram
+              up-a up-b c g h)
+          ( eq-htpy-right-whisker-htpy-hom-sequential-diagram H h)) ∙
+        ( inv [i]) ∙
+        ( ap htpy-eq
+          ( coh-comp-hom-sequential-diagram
+            ( eq-htpy-sequential-diagram B C f g H)
+            ( h))) ∙
+        ( htpy-eq-concat _ _) ∙
+        ( ap-binary
+          ( _∙h_)
+          ( is-section-eq-htpy
+            ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+              up-a up-b c f h))
+           ( htpy-eq-right-whisker
+             ( ap
+               ( map-sequential-colimit-hom-sequential-diagram up-b c)
+               ( eq-htpy-sequential-diagram B C f g H))
+             ( map-sequential-colimit-hom-sequential-diagram up-a b h))))
+     where
+       open import foundation.action-on-identifications-binary-functions
+       [i] =
+         htpy-eq-concat
+           ( ap
+             ( map-sequential-colimit-hom-sequential-diagram up-a c)
+             ( ap
+               ( λ f → comp-hom-sequential-diagram A B C f h)
+               ( eq-htpy-sequential-diagram B C f g H)))
+           ( eq-htpy
+             ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+               up-a up-b c g h)) ∙
+         ap
+           ( htpy-eq
+             ( ap
+               ( map-sequential-colimit-hom-sequential-diagram up-a c)
+               ( ap
+                 ( λ f → comp-hom-sequential-diagram A B C f h)
+                 ( eq-htpy-sequential-diagram B C f g H))) ∙h_)
+           ( is-section-eq-htpy
+             ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+               up-a up-b c g h))
 ```
 
 ```agda
@@ -484,17 +690,69 @@ module _
   {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
   (h : hom-sequential-diagram B C)
   {f g : hom-sequential-diagram A B}
-  (H : htpy-hom-sequential-diagram B f g)
   where
 
+  coh-comp-hom-sequential-diagram' :
+    (p : f ＝ g) →
+    ap
+      ( map-sequential-colimit-hom-sequential-diagram up-a c)
+      ( ap (comp-hom-sequential-diagram A B C h) p) ∙
+    eq-htpy
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g) ＝
+    eq-htpy
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙
+    ap
+      ( map-sequential-colimit-hom-sequential-diagram up-b c h ∘_)
+      ( ap
+        ( map-sequential-colimit-hom-sequential-diagram up-a b)
+        ( p))
+  coh-comp-hom-sequential-diagram' refl = inv right-unit
+
   preserves-left-whisker-htpy-hom-sequential-diagram :
+    (H : htpy-hom-sequential-diagram B f g) →
     ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
         ( left-whisker-concat-htpy-hom-sequential-diagram h H)) ∙h
       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g)) ~
     ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙h
       ( map-sequential-colimit-hom-sequential-diagram up-b c h ·l
         htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H))
-  preserves-left-whisker-htpy-hom-sequential-diagram = {!!}
+  preserves-left-whisker-htpy-hom-sequential-diagram H =
+    htpy-eq
+      ( ap-binary
+          ( λ p q →
+            htpy-eq
+              ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p) ∙h
+            q)
+          ( eq-htpy-left-whisker-htpy-hom-sequential-diagram h H)
+          ( inv
+            ( is-section-eq-htpy
+              ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+                up-a up-b c h g))) ∙
+        inv
+          ( htpy-eq-concat
+            ( ap
+              ( map-sequential-colimit-hom-sequential-diagram up-a c)
+              ( ap
+                ( comp-hom-sequential-diagram A B C h)
+                ( eq-htpy-sequential-diagram A B f g H)))
+            ( eq-htpy
+              ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+                up-a up-b c h g))) ∙
+        ap htpy-eq
+          ( coh-comp-hom-sequential-diagram'
+            ( eq-htpy-sequential-diagram A B f g H)) ∙
+        htpy-eq-concat _ _ ∙
+        ap-binary _∙h_
+          ( is-section-eq-htpy
+            ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+              up-a up-b c h f))
+          ( htpy-eq-left-whisker
+            ( map-sequential-colimit-hom-sequential-diagram up-b c h)
+            ( ap
+              ( map-sequential-colimit-hom-sequential-diagram up-a b)
+              ( eq-htpy-sequential-diagram A B f g H))))
+     where
+       open import foundation.action-on-identifications-binary-functions
 ```
 
 ## Action on homotopies of morphisms of sequential diagrams preserves concatenation
@@ -538,6 +796,44 @@ module _
             ( eq-htpy-sequential-diagram A B g h K))))
 ```
 
+## Action on homotopies of morphisms of sequential diagrams preserves associativity
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+  (up-a : universal-property-sequential-colimit a)
+  {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
+  (up-b : universal-property-sequential-colimit b)
+  {C : sequential-diagram l5} {Z : UU l6} {c : cocone-sequential-diagram C Z}
+  (up-c : universal-property-sequential-colimit c)
+  {D : sequential-diagram l7} {V : UU l8} (d : cocone-sequential-diagram D V)
+  (f : hom-sequential-diagram A B) (g : hom-sequential-diagram B C)
+  (h : hom-sequential-diagram C D)
+  where
+
+  coh-assoc-comp-hom-sequential-diagram :
+    {!!}
+  coh-assoc-comp-hom-sequential-diagram = {!!}
+
+  preserves-assoc-comp-hom-sequential-diagram :
+    ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a d
+        ( assoc-comp-hom-sequential-diagram f g h)) ∙h
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-c d h
+        ( comp-hom-sequential-diagram A B C g f)) ∙h
+      ( map-sequential-colimit-hom-sequential-diagram up-c d h ·l
+        preserves-comp-map-sequential-colimit-hom-sequential-diagram
+          up-a up-b c g f)) ~
+    ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b d
+        ( comp-hom-sequential-diagram B C D h g)
+        ( f)) ∙h
+      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+          up-b up-c d h g ·r
+        map-sequential-colimit-hom-sequential-diagram up-a b f))
+  preserves-assoc-comp-hom-sequential-diagram =
+    {!!}
+```
+
 -- ```agda
 -- nat-lemma :
 --   {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
diff --git a/src/synthetic-homotopy-theory/morphisms-sequential-diagrams.lagda.md b/src/synthetic-homotopy-theory/morphisms-sequential-diagrams.lagda.md
index a094834153..94686c5aed 100644
--- a/src/synthetic-homotopy-theory/morphisms-sequential-diagrams.lagda.md
+++ b/src/synthetic-homotopy-theory/morphisms-sequential-diagrams.lagda.md
@@ -274,3 +274,54 @@ module _
   eq-htpy-sequential-diagram f f' =
     map-inv-equiv (extensionality-hom-sequential-diagram f f')
 ```
+
+### Composition of morphisms of sequential diagrams is associative
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : sequential-diagram l1} {B : sequential-diagram l2}
+  {C : sequential-diagram l3} {D : sequential-diagram l4}
+  (f : hom-sequential-diagram A B) (g : hom-sequential-diagram B C)
+  (h : hom-sequential-diagram C D)
+  where
+
+  assoc-comp-hom-sequential-diagram :
+    htpy-hom-sequential-diagram D
+      ( comp-hom-sequential-diagram A B D
+        ( comp-hom-sequential-diagram B C D h g)
+        ( f))
+      ( comp-hom-sequential-diagram A C D h
+        ( comp-hom-sequential-diagram A B C g f))
+  pr1 assoc-comp-hom-sequential-diagram n = refl-htpy
+  pr2 assoc-comp-hom-sequential-diagram n =
+    right-unit-htpy ∙h
+    assoc-htpy
+      ( naturality-map-hom-sequential-diagram D h n ·r
+        ( map-hom-sequential-diagram C g n ∘
+          map-hom-sequential-diagram B f n))
+      ( map-hom-sequential-diagram D h (succ-ℕ n) ·l
+        naturality-map-hom-sequential-diagram C g n ·r
+        map-hom-sequential-diagram B f n)
+      ( ( map-hom-sequential-diagram D h (succ-ℕ n) ∘
+          map-hom-sequential-diagram C g (succ-ℕ n)) ·l
+        naturality-map-hom-sequential-diagram B f n) ∙h
+    left-whisker-concat-htpy
+      ( naturality-map-hom-sequential-diagram D h n ·r
+        ( map-hom-sequential-diagram C g n ∘ map-hom-sequential-diagram B f n))
+      ( left-whisker-concat-htpy
+          ( map-hom-sequential-diagram D h (succ-ℕ n) ·l
+            naturality-map-hom-sequential-diagram C g n ·r
+            map-hom-sequential-diagram B f n)
+          ( inv-preserves-comp-left-whisker-comp
+            ( map-hom-sequential-diagram D h (succ-ℕ n))
+            ( map-hom-sequential-diagram C g (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n)) ∙h
+        inv-htpy
+          ( distributive-left-whisker-comp-concat
+            ( map-hom-sequential-diagram D h (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram C g n ·r
+              map-hom-sequential-diagram B f n)
+            ( map-hom-sequential-diagram C g (succ-ℕ n) ·l
+              naturality-map-hom-sequential-diagram B f n)))
+```

From d5299f5975879802a749989554b0b2db94324885 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Mon, 24 Feb 2025 18:02:42 +0100
Subject: [PATCH 23/33] Move stuff around, new strategy

---
 ...cocones-under-sequential-diagrams.lagda.md |   32 +
 .../functoriality-stuff.lagda.md              | 1712 ++++-------------
 .../old-stuff.lagda.md                        | 1400 ++++++++++++++
 3 files changed, 1764 insertions(+), 1380 deletions(-)
 create mode 100644 src/synthetic-homotopy-theory/old-stuff.lagda.md

diff --git a/src/synthetic-homotopy-theory/dependent-cocones-under-sequential-diagrams.lagda.md b/src/synthetic-homotopy-theory/dependent-cocones-under-sequential-diagrams.lagda.md
index debb9262d7..95280a4e84 100644
--- a/src/synthetic-homotopy-theory/dependent-cocones-under-sequential-diagrams.lagda.md
+++ b/src/synthetic-homotopy-theory/dependent-cocones-under-sequential-diagrams.lagda.md
@@ -1,6 +1,7 @@
 # Dependent cocones under sequential diagrams
 
 ```agda
+{-# OPTIONS --allow-unsolved-metas #-}
 module synthetic-homotopy-theory.dependent-cocones-under-sequential-diagrams where
 ```
 
@@ -158,6 +159,37 @@ module _
   coherence-htpy-htpy-dependent-cocone-sequential-diagram = pr2 H
 ```
 
+### Inversion of homotopies of dependent cocones under sequential diagrams
+
+```agda
+module _
+  {l1 l2 l3 : Level} {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X} (P : X → UU l3)
+  {d d' : dependent-cocone-sequential-diagram c P}
+  (H : htpy-dependent-cocone-sequential-diagram P d d')
+  where
+
+  inv-htpy-dependent-cocone-sequential-diagram :
+    htpy-dependent-cocone-sequential-diagram P d' d
+  inv-htpy-dependent-cocone-sequential-diagram = ?
+```
+
+### Concatenation of homotopies of dependent cocones under sequential diagrams
+
+```agda
+module _
+  {l1 l2 l3 : Level} {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X} (P : X → UU l3)
+  {d d' d'' : dependent-cocone-sequential-diagram c P}
+  (H : htpy-dependent-cocone-sequential-diagram P d d')
+  (K : htpy-dependent-cocone-sequential-diagram P d' d'')
+  where
+
+  concat-htpy-dependent-cocone-sequential-diagram :
+    htpy-dependent-cocone-sequential-diagram P d d''
+  concat-htpy-dependent-cocone-sequential-diagram = {!!}
+```
+
 ### Obtaining dependent cocones under sequential diagrams by postcomposing cocones under sequential diagrams with dependent maps
 
 Given a cocone `c` with vertex `X`, and a dependent map `h : (x : X) → P x`, we
diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index 2fa9750471..56975dc874 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -39,6 +39,7 @@ open import foundation.whiskering-homotopies-composition
 -- open import foundation.whiskering-homotopies-concatenation
 
 open import synthetic-homotopy-theory.cocones-under-sequential-diagrams
+open import synthetic-homotopy-theory.dependent-cocones-under-sequential-diagrams
 open import synthetic-homotopy-theory.dependent-sequential-diagrams
 open import synthetic-homotopy-theory.dependent-universal-property-sequential-colimits
 open import synthetic-homotopy-theory.descent-data-sequential-colimits
@@ -47,1405 +48,63 @@ open import synthetic-homotopy-theory.morphisms-sequential-diagrams
 open import synthetic-homotopy-theory.sequential-diagrams
 open import synthetic-homotopy-theory.stuff-over
 open import synthetic-homotopy-theory.universal-property-sequential-colimits
+
+open import foundation.binary-homotopies
+open import foundation.commuting-squares-of-homotopies
+open import foundation.fundamental-theorem-of-identity-types
+open import foundation.homotopy-induction
+open import foundation.structure-identity-principle
+open import foundation.torsorial-type-families
 ```
 
 </details>
 
 ## Theorem
 
-New idea: instead of bruteforcing this direction, show that a square induces
-coherent cubes, and show that it's an equivalence because it fits in a diagram.
-
-## Commuting cubes induce commuting squares in the colimit
-
-```agda
-open import foundation.commuting-cubes-of-maps
-module _
-  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
-  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
-  (up-a : universal-property-sequential-colimit a)
-  {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
-  (up-b : universal-property-sequential-colimit b)
-  {P : sequential-diagram l5} {V : UU l6} {p : cocone-sequential-diagram P V}
-  (up-p : universal-property-sequential-colimit p)
-  {Q : sequential-diagram l7} {W : UU l8} {q : cocone-sequential-diagram Q W}
-  (up-q : universal-property-sequential-colimit q)
-  (f' : hom-sequential-diagram P Q)
-  (f : hom-sequential-diagram A B)
-  (g : hom-sequential-diagram P A)
-  (h : hom-sequential-diagram Q B)
-  where
-
-  square-cube-sequential-colimit :
-    (faces :
-      (n : ℕ) →
-      coherence-square-maps
-        ( map-hom-sequential-diagram Q f' n)
-        ( map-hom-sequential-diagram A g n)
-        ( map-hom-sequential-diagram B h n)
-        ( map-hom-sequential-diagram B f n)) →
-    (cubes :
-      (n : ℕ) →
-      coherence-cube-maps
-        ( map-hom-sequential-diagram B f n)
-        ( map-sequential-diagram A n)
-        ( map-sequential-diagram B n)
-        ( map-hom-sequential-diagram B f (succ-ℕ n))
-        ( map-hom-sequential-diagram Q f' n)
-        ( map-sequential-diagram P n)
-        ( map-sequential-diagram Q n)
-        ( map-hom-sequential-diagram Q f' (succ-ℕ n))
-        ( map-hom-sequential-diagram A g n)
-        ( map-hom-sequential-diagram B h n)
-        ( map-hom-sequential-diagram A g (succ-ℕ n))
-        ( map-hom-sequential-diagram B h (succ-ℕ n))
-        ( naturality-map-hom-sequential-diagram Q f' n)
-        ( faces n)
-        ( naturality-map-hom-sequential-diagram A g n)
-        ( naturality-map-hom-sequential-diagram B h n)
-        ( faces (succ-ℕ n))
-        ( naturality-map-hom-sequential-diagram B f n)) →
-    coherence-square-maps
-      ( map-sequential-colimit-hom-sequential-diagram up-p q f')
-      ( map-sequential-colimit-hom-sequential-diagram up-p a g)
-      ( map-sequential-colimit-hom-sequential-diagram up-q b h)
-      ( map-sequential-colimit-hom-sequential-diagram up-a b f)
-  square-cube-sequential-colimit faces cubes =
-    inv-htpy
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-p up-a b
-        f g) ∙h
-    induced-htpy ∙h
-    preserves-comp-map-sequential-colimit-hom-sequential-diagram up-p up-q b h f'
-    where
-    comp1 comp2 : hom-sequential-diagram P B
-    comp1 = comp-hom-sequential-diagram P A B f g
-    comp2 = comp-hom-sequential-diagram P Q B h f'
-    induced-hom-htpy : htpy-hom-sequential-diagram B comp1 comp2
-    pr1 induced-hom-htpy = faces
-    pr2 induced-hom-htpy n =
-      assoc-htpy _ _ _ ∙h
-      inv-htpy (cubes n) ∙h
-      assoc-htpy _ _ _
-    induced-htpy :
-      map-sequential-colimit-hom-sequential-diagram up-p b comp1 ~
-      map-sequential-colimit-hom-sequential-diagram up-p b comp2
-    induced-htpy =
-      htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-p b
-        ( induced-hom-htpy)
-```
-
-## Concatenation of homotopies of morphisms of sequential diagrams
-
-```agda
-open import foundation.whiskering-homotopies-concatenation
+-- ```agda
 module _
   {l1 l2 : Level}
-  {A : sequential-diagram l1} {B : sequential-diagram l2}
-  (f g h : hom-sequential-diagram A B)
-  where
-
-  module _
-    (H : htpy-hom-sequential-diagram B f g)
-    (K : htpy-hom-sequential-diagram B g h)
-    where
-
-    concat-htpy-hom-sequential-diagram : htpy-hom-sequential-diagram B f h
-    pr1 concat-htpy-hom-sequential-diagram n =
-      htpy-htpy-hom-sequential-diagram _ H n ∙h
-      htpy-htpy-hom-sequential-diagram _ K n
-    pr2 concat-htpy-hom-sequential-diagram n =
-      inv-htpy-assoc-htpy _ _ _ ∙h
-      right-whisker-concat-htpy
-        ( coherence-htpy-htpy-hom-sequential-diagram B H n)
-        ( htpy-htpy-hom-sequential-diagram _ K (succ-ℕ n) ·r map-sequential-diagram A n) ∙h
-      assoc-htpy _ _ _ ∙h
-      left-whisker-concat-htpy
-        ( map-sequential-diagram B n ·l htpy-htpy-hom-sequential-diagram _ H n)
-        ( coherence-htpy-htpy-hom-sequential-diagram B K n) ∙h
-      inv-htpy-assoc-htpy _ _ _ ∙h
-      right-whisker-concat-htpy
-        ( inv-htpy
-          ( distributive-left-whisker-comp-concat
-            ( map-sequential-diagram B n)
-            ( htpy-htpy-hom-sequential-diagram _ H n)
-            ( htpy-htpy-hom-sequential-diagram _ K n)))
-        ( naturality-map-hom-sequential-diagram B h n)
-
-  htpy-eq-concat-hom-sequential-diagram :
-    (p : f ＝ g) (q : g ＝ h) →
-    htpy-eq-sequential-diagram A B f h (p ∙ q) ＝
-    concat-htpy-hom-sequential-diagram
-      ( htpy-eq-sequential-diagram A B f g p)
-      ( htpy-eq-sequential-diagram A B g h q)
-  htpy-eq-concat-hom-sequential-diagram refl refl =
-    eq-pair-eq-fiber
-      ( inv
-        ( eq-binary-htpy _ _
-          λ n a →
-          right-unit ∙ right-unit ∙
-          ap
-            ( (inv (assoc _ refl refl) ∙ ap (_∙ refl) right-unit) ∙ refl ∙_)
-            ( ap-id right-unit) ∙
-          ap
-            ( _∙ right-unit)
-            ( right-unit ∙
-              ap
-                ( λ p → inv p ∙ ap (_∙ refl) right-unit)
-                ( middle-unit-law-assoc
-                    ( naturality-map-hom-sequential-diagram B f n a)
-                    ( refl)) ∙
-              left-inv (ap (_∙ refl) right-unit))))
-    where
-      open import foundation.binary-homotopies
-      open import foundation.path-algebra
-
-  eq-htpy-concat-hom-sequential-diagram :
-    (H : htpy-hom-sequential-diagram B f g)
-    (K : htpy-hom-sequential-diagram B g h) →
-    eq-htpy-sequential-diagram A B f h
-      ( concat-htpy-hom-sequential-diagram H K) ＝
-    eq-htpy-sequential-diagram A B f g H ∙
-    eq-htpy-sequential-diagram A B g h K
-  eq-htpy-concat-hom-sequential-diagram H K =
-    ap
-      ( eq-htpy-sequential-diagram A B f h)
-      ( inv
-        ( htpy-eq-concat-hom-sequential-diagram
-          ( eq-htpy-sequential-diagram A B f g H)
-          ( eq-htpy-sequential-diagram A B g h K) ∙
-        ap-binary concat-htpy-hom-sequential-diagram
-          ( is-section-map-inv-equiv
-            ( extensionality-hom-sequential-diagram A B f g)
-            ( H))
-          ( is-section-map-inv-equiv
-            ( extensionality-hom-sequential-diagram A B g h)
-            ( K)))) ∙
-    is-retraction-map-inv-equiv
-      ( extensionality-hom-sequential-diagram A B f h)
-      ( eq-htpy-sequential-diagram A B f g H ∙
-        eq-htpy-sequential-diagram A B g h K)
-    where open import foundation.action-on-identifications-binary-functions
-```
-
-## Vertical pasting of cubes of stuff
-
-```agda
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : sequential-diagram l1} {B : sequential-diagram l2}
-  {A' : sequential-diagram l3} {B' : sequential-diagram l4}
-  {A'' : sequential-diagram l5} {B'' : sequential-diagram l6}
-  (top : hom-sequential-diagram A'' B'')
-  (top-left : hom-sequential-diagram A'' A')
-  (top-right : hom-sequential-diagram B'' B')
-  (mid : hom-sequential-diagram A' B')
-  (bottom-left : hom-sequential-diagram A' A)
-  (bottom-right : hom-sequential-diagram B' B)
-  (bottom : hom-sequential-diagram A B)
-  (H :
-    htpy-hom-sequential-diagram B
-      ( comp-hom-sequential-diagram A' A B bottom bottom-left)
-      ( comp-hom-sequential-diagram A' B' B bottom-right mid))
-  (K :
-    htpy-hom-sequential-diagram B'
-      ( comp-hom-sequential-diagram A'' A' B' mid top-left)
-      ( comp-hom-sequential-diagram A'' B'' B' top-right top))
-  -- (faces-top :
-  --   (n : ℕ) →
-  --   coherence-square-maps
-  --     ( map-hom-sequential-diagram B'' top n)
-  --     ( map-hom-sequential-diagram A' top-left n)
-  --     ( map-hom-sequential-diagram B' top-right n)
-  --     ( map-hom-sequential-diagram B' mid n))
-  -- (faces-bottom :
-  --   (n : ℕ) → {!!})
-  -- (cubes-top :
-  --   (n : ℕ) → {!!})
-  -- (cubes-bottom :
-  --   (n : ℕ) → {!!})
-  -- -- (cubes :
-  -- --   (n : ℕ) →
-  -- --   coherence-cube-maps
-  -- --     ( map-hom-sequential-diagram B f n)
-  -- --     ( map-sequential-diagram A n)
-  -- --     ( map-sequential-diagram B n)
-  -- --     ( map-hom-sequential-diagram B f (succ-ℕ n))
-  -- --     ( map-hom-sequential-diagram Q f' n)
-  -- --     ( map-sequential-diagram P n)
-  -- --     ( map-sequential-diagram Q n)
-  -- --     ( map-hom-sequential-diagram Q f' (succ-ℕ n))
-  -- --     ( map-hom-sequential-diagram A g n)
-  -- --     ( map-hom-sequential-diagram B h n)
-  -- --     ( map-hom-sequential-diagram A g (succ-ℕ n))
-  -- --     ( map-hom-sequential-diagram B h (succ-ℕ n))
-  -- --     ( naturality-map-hom-sequential-diagram Q f' n)
-  -- --     ( faces n)
-  -- --     ( naturality-map-hom-sequential-diagram A g n)
-  -- --     ( naturality-map-hom-sequential-diagram B h n)
-  -- --     ( faces (succ-ℕ n))
-  -- --     ( naturality-map-hom-sequential-diagram B f n)) →
-  where
-
-  pasting-vertical-coherence-square-hom-sequential-diagram :
-    htpy-hom-sequential-diagram B
-      ( comp-hom-sequential-diagram A'' A B bottom
-        ( comp-hom-sequential-diagram A'' A' A bottom-left top-left))
-      ( comp-hom-sequential-diagram A'' B'' B
-        ( comp-hom-sequential-diagram B'' B' B bottom-right top-right)
-        ( top))
-  pasting-vertical-coherence-square-hom-sequential-diagram = {!!}
-```
-
-## Whiskering of homotopies of morphisms of sequential diagrams
-
-### Right whiskering
-
-```agda
-module _
-  {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3}
-  where
-
-  htpy-eq-right-whisker :
-    {f g : B → C} (p : f ＝ g) (h : A → B) →
-    htpy-eq (ap (_∘ h) p) ＝ htpy-eq p ·r h
-  htpy-eq-right-whisker refl h = refl
-
-  eq-htpy-right-whisker :
-    {f g : B → C} (H : f ~ g) (h : A → B) →
-    eq-htpy (H ·r h) ＝ ap (_∘ h) (eq-htpy H)
-  eq-htpy-right-whisker H h =
-    ap eq-htpy
-      ( inv
-        ( htpy-eq-right-whisker (eq-htpy H) h ∙
-          ap (_·r h) (is-section-eq-htpy H))) ∙
-    is-retraction-eq-htpy (ap (_∘ h) (eq-htpy H))
-
-  htpy-eq-left-whisker :
-    {f g : A → B} (h : B → C) (p : f ＝ g) →
-    htpy-eq (ap (h ∘_) p) ＝ h ·l htpy-eq p
-  htpy-eq-left-whisker h refl = refl
-
-  -- alternatively, using homotopy induction
-  eq-htpy-left-whisker :
-    {f g : A → B} (h : B → C) (H : f ~ g) →
-    eq-htpy (h ·l H) ＝ ap (h ∘_) (eq-htpy H)
-  eq-htpy-left-whisker {f} h =
-    ind-htpy f
-      ( λ g H →
-        eq-htpy (h ·l H) ＝ ap (h ∘_) (eq-htpy H))
-      ( eq-htpy-refl-htpy (h ∘ f) ∙
-        inv (ap (ap (h ∘_)) (eq-htpy-refl-htpy f)))
-    where open import foundation.homotopy-induction
-```
-
-```agda
-module _
-  {l1 l2 l3 : Level}
-  {A : sequential-diagram l1} {B : sequential-diagram l2}
-  {X : sequential-diagram l3}
-  {f g : hom-sequential-diagram A B}
+  {A : sequential-diagram l1}
+  (P : descent-data-sequential-colimit A l2)
   where
-  open import foundation.whiskering-identifications-concatenation
-
-  module _
-    (H : htpy-hom-sequential-diagram B f g)
-    (h : hom-sequential-diagram X A)
-    where
 
-    right-whisker-concat-htpy-hom-sequential-diagram :
-      htpy-hom-sequential-diagram B
-        ( comp-hom-sequential-diagram X A B f h)
-        ( comp-hom-sequential-diagram X A B g h)
-    pr1 right-whisker-concat-htpy-hom-sequential-diagram n =
-      htpy-htpy-hom-sequential-diagram _ H n ·r map-hom-sequential-diagram A h n
-    pr2 right-whisker-concat-htpy-hom-sequential-diagram n x =
-      assoc _ _ _ ∙
-      left-whisker-concat
-        ( naturality-map-hom-sequential-diagram B f n (map-hom-sequential-diagram A h n x))
-        ( inv-nat-htpy
-          ( htpy-htpy-hom-sequential-diagram B H (succ-ℕ n))
-          ( naturality-map-hom-sequential-diagram A h n x)) ∙
-      inv (assoc _ _ _) ∙
-      right-whisker-concat
-        ( coherence-htpy-htpy-hom-sequential-diagram B H n (map-hom-sequential-diagram A h n x))
-        ( ap
-          ( map-hom-sequential-diagram B g (succ-ℕ n))
-          ( naturality-map-hom-sequential-diagram A h n x)) ∙
-      assoc _ _ _
+  section-descent-data-sequential-colimit : UU (l1 ⊔ l2)
+  section-descent-data-sequential-colimit =
+    section-dependent-sequential-diagram A
+      ( dependent-sequential-diagram-descent-data P)
 
-  htpy-eq-right-whisker-htpy-hom-sequential-diagram :
-    (p : f ＝ g) (h : hom-sequential-diagram X A) →
-    htpy-eq-sequential-diagram X B
-      ( comp-hom-sequential-diagram X A B f h)
-      ( comp-hom-sequential-diagram X A B g h)
-      ( ap (λ f → comp-hom-sequential-diagram X A B f h) p) ＝
-    right-whisker-concat-htpy-hom-sequential-diagram
-      ( htpy-eq-sequential-diagram A B f g p)
-      ( h)
-  htpy-eq-right-whisker-htpy-hom-sequential-diagram refl h =
-    eq-pair-eq-fiber
-      ( eq-binary-htpy _ _
-        λ n x →
-        inv
-          ( right-unit ∙
-            ap-binary
-              ( λ p q →
-                p ∙
-                left-whisker-concat _ q ∙
-                inv (assoc _ refl _) ∙
-                right-whisker-concat _ _)
-              ( right-unit-law-assoc _ _)
-              ( inv-nat-refl-htpy _ _) ∙
-            ap
-              ( λ p →
-                right-unit ∙
-                left-whisker-concat _ (inv right-unit) ∙
-                left-whisker-concat _ right-unit ∙
-                inv p ∙
-                right-whisker-concat right-unit _)
-              ( middle-unit-law-assoc _ _) ∙
-            is-section-inv-concat'
-              ( right-whisker-concat right-unit _)
-              ( right-unit ∙
-                left-whisker-concat _ (inv right-unit) ∙
-                left-whisker-concat _ right-unit) ∙
-            ap
-              ( λ p → right-unit ∙ p ∙ left-whisker-concat _ right-unit)
-              ( ap-inv (naturality-map-hom-sequential-diagram B f n _ ∙_) right-unit) ∙
-            is-section-inv-concat'
-              ( ap (naturality-map-hom-sequential-diagram B f n _ ∙_) right-unit)
-              ( right-unit)))
-    where
-      open import foundation.binary-homotopies
-      open import foundation.path-algebra
-      open import foundation.action-on-identifications-binary-functions
-
-  eq-htpy-right-whisker-htpy-hom-sequential-diagram :
-    (H : htpy-hom-sequential-diagram B f g) (h : hom-sequential-diagram X A) →
-    eq-htpy-sequential-diagram X B
-      ( comp-hom-sequential-diagram X A B f h)
-      ( comp-hom-sequential-diagram X A B g h)
-      ( right-whisker-concat-htpy-hom-sequential-diagram H h) ＝
-    ap
-      ( λ f → comp-hom-sequential-diagram X A B f h)
-      ( eq-htpy-sequential-diagram A B f g H)
-  eq-htpy-right-whisker-htpy-hom-sequential-diagram H h =
-    ap
-      ( eq-htpy-sequential-diagram X B _ _)
-      ( inv
-        ( htpy-eq-right-whisker-htpy-hom-sequential-diagram
-            ( eq-htpy-sequential-diagram A B f g H)
-            ( h) ∙
-          ap
-            ( λ H → right-whisker-concat-htpy-hom-sequential-diagram H h)
-            ( is-section-map-inv-equiv
-              ( extensionality-hom-sequential-diagram A B f g)
-              ( H)))) ∙
-    is-retraction-map-inv-equiv
-      ( extensionality-hom-sequential-diagram X B
-        ( comp-hom-sequential-diagram X A B f h)
-        ( comp-hom-sequential-diagram X A B g h))
-      ( ap
-        ( λ f → comp-hom-sequential-diagram X A B f h)
-        ( eq-htpy-sequential-diagram A B f g H))
-```
-
-### Left whiskering
-
-```agda
 module _
   {l1 l2 l3 : Level}
-  {A : sequential-diagram l1} {B : sequential-diagram l2}
-  {X : sequential-diagram l3}
-  {f g : hom-sequential-diagram A B}
-  where
-  open import foundation.whiskering-identifications-concatenation
-
-  module _
-    (h : hom-sequential-diagram B X)
-    (H : htpy-hom-sequential-diagram B f g)
-    where
-
-    left-whisker-concat-htpy-hom-sequential-diagram :
-      htpy-hom-sequential-diagram X
-        ( comp-hom-sequential-diagram A B X h f)
-        ( comp-hom-sequential-diagram A B X h g)
-    pr1 left-whisker-concat-htpy-hom-sequential-diagram n =
-      map-hom-sequential-diagram X h n ·l htpy-htpy-hom-sequential-diagram _ H n
-    pr2 left-whisker-concat-htpy-hom-sequential-diagram n a =
-      assoc _ _ _ ∙
-      left-whisker-concat
-        ( naturality-map-hom-sequential-diagram X h n (map-hom-sequential-diagram B f n a))
-        ( inv (ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
-          ap
-            ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
-            ( coherence-htpy-htpy-hom-sequential-diagram B H n a) ∙
-          ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
-      inv (assoc _ _ _) ∙
-      right-whisker-concat
-        ( left-whisker-concat
-            ( naturality-map-hom-sequential-diagram X h n
-              ( map-hom-sequential-diagram B f n a))
-            ( inv
-              ( ap-comp
-                ( map-hom-sequential-diagram X h (succ-ℕ n))
-                ( map-sequential-diagram B n)
-                ( htpy-htpy-hom-sequential-diagram B H n a))) ∙
-          nat-htpy
-            ( naturality-map-hom-sequential-diagram X h n)
-            ( htpy-htpy-hom-sequential-diagram B H n a) ∙
-          right-whisker-concat
-            ( ap-comp
-              ( map-sequential-diagram X n)
-              ( map-hom-sequential-diagram X h n)
-              ( htpy-htpy-hom-sequential-diagram B H n a))
-            ( naturality-map-hom-sequential-diagram X h n
-              ( map-hom-sequential-diagram B g n a)))
-        ( ap
-          ( map-hom-sequential-diagram X h (succ-ℕ n))
-          ( naturality-map-hom-sequential-diagram B g n a)) ∙
-      assoc _ _ _
-
-  htpy-eq-left-whisker-htpy-hom-sequential-diagram :
-    (h : hom-sequential-diagram B X) (p : f ＝ g) →
-    htpy-eq-sequential-diagram A X
-      ( comp-hom-sequential-diagram A B X h f)
-      ( comp-hom-sequential-diagram A B X h g)
-      ( ap (comp-hom-sequential-diagram A B X h) p) ＝
-    left-whisker-concat-htpy-hom-sequential-diagram h
-      ( htpy-eq-sequential-diagram A B f g p)
-  htpy-eq-left-whisker-htpy-hom-sequential-diagram h refl =
-    eq-pair-eq-fiber
-      ( eq-binary-htpy _ _
-        ( λ n a →
-          inv
-            ( right-unit ∙
-              ( ap-binary
-                ( λ p q →
-                  p ∙
-                  left-whisker-concat
-                    ( naturality-map-hom-sequential-diagram X h n
-                      ( map-hom-sequential-diagram B f n a))
-                    ( inv (ap-concat _ _ refl) ∙
-                      ap
-                        ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
-                        ( right-unit) ∙
-                      refl) ∙
-                  q ∙
-                  right-whisker-concat (right-unit ∙ refl) _)
-                ( right-unit-law-assoc _ (ap _ _) ∙
-                  left-whisker-concat right-unit (ap-inv _ right-unit))
-                ( ap inv (middle-unit-law-assoc _ _))) ∙
-              ( ap-binary
-                ( λ p q →
-                  right-unit ∙
-                  inv (left-whisker-concat _ right-unit) ∙
-                  left-whisker-concat _ p ∙
-                  inv (right-whisker-concat right-unit _) ∙
-                  right-whisker-concat q _)
-                ( right-unit ∙
-                  right-whisker-concat
-                    ( ap inv (compute-right-refl-ap-concat _ _) ∙
-                      distributive-inv-concat
-                        ( ap (ap _) right-unit)
-                        ( inv right-unit) ∙
-                      right-whisker-concat (inv-inv right-unit) _)
-                    ( ap (ap _) right-unit) ∙
-                  is-section-inv-concat' (ap (ap _) right-unit) right-unit)
-                ( right-unit)) ∙
-              is-section-inv-concat'
-                ( right-whisker-concat right-unit _)
-                ( right-unit ∙ inv _ ∙ _) ∙
-              is-section-inv-concat'
-                ( left-whisker-concat _ right-unit)
-                ( right-unit))))
-    where
-      open import foundation.action-on-identifications-binary-functions
-      open import foundation.binary-homotopies
-      open import foundation.path-algebra
-
-  eq-htpy-left-whisker-htpy-hom-sequential-diagram :
-    (h : hom-sequential-diagram B X) (H : htpy-hom-sequential-diagram B f g) →
-    eq-htpy-sequential-diagram A X
-      ( comp-hom-sequential-diagram A B X h f)
-      ( comp-hom-sequential-diagram A B X h g)
-      ( left-whisker-concat-htpy-hom-sequential-diagram h H) ＝
-    ap
-      ( comp-hom-sequential-diagram A B X h)
-      ( eq-htpy-sequential-diagram A B f g H)
-  eq-htpy-left-whisker-htpy-hom-sequential-diagram h H =
-    ap
-      ( eq-htpy-sequential-diagram A X _ _)
-      ( inv
-        ( htpy-eq-left-whisker-htpy-hom-sequential-diagram h
-            ( eq-htpy-sequential-diagram A B f g H) ∙
-          ap
-            ( left-whisker-concat-htpy-hom-sequential-diagram h)
-            ( is-section-map-inv-equiv
-              ( extensionality-hom-sequential-diagram A B f g)
-              ( H)))) ∙
-    is-retraction-map-inv-equiv
-      ( extensionality-hom-sequential-diagram A X
-        ( comp-hom-sequential-diagram A B X h f)
-        ( comp-hom-sequential-diagram A B X h g))
-      ( ap
-        ( comp-hom-sequential-diagram A B X h)
-        ( eq-htpy-sequential-diagram A B f g H))
-```
-
-## Action on homotopies of morphisms of sequential diagrams preserves whiskering
-
-```agda
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
-  (up-a : universal-property-sequential-colimit a)
-  {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
-  (up-b : universal-property-sequential-colimit b)
-  {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
-  {f g : hom-sequential-diagram B C}
-  where
-
-  coh-comp-hom-sequential-diagram :
-    (p : f ＝ g) (h : hom-sequential-diagram A B) →
-    ap
-      ( map-sequential-colimit-hom-sequential-diagram up-a c)
-      ( ap (λ f → comp-hom-sequential-diagram A B C f h) p) ∙
-    eq-htpy
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h) ＝
-    eq-htpy
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙
-    ap
-      ( _∘ map-sequential-colimit-hom-sequential-diagram up-a b h)
-      ( ap
-        ( map-sequential-colimit-hom-sequential-diagram up-b c)
-        ( p))
-  coh-comp-hom-sequential-diagram refl h = inv right-unit
-
-  preserves-right-whisker-htpy-hom-sequential-diagram :
-    (H : htpy-hom-sequential-diagram C f g)
-    (h : hom-sequential-diagram A B) →
-    ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
-        ( right-whisker-concat-htpy-hom-sequential-diagram H h)) ∙h
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h)) ~
-    ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙h
-      ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-b c H ·r
-        map-sequential-colimit-hom-sequential-diagram up-a b h))
-  preserves-right-whisker-htpy-hom-sequential-diagram H h =
-    htpy-eq
-      ( ( ap
-          ( λ p →
-            htpy-eq
-              ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p) ∙h
-            preserves-comp-map-sequential-colimit-hom-sequential-diagram
-              up-a up-b c g h)
-          ( eq-htpy-right-whisker-htpy-hom-sequential-diagram H h)) ∙
-        ( inv [i]) ∙
-        ( ap htpy-eq
-          ( coh-comp-hom-sequential-diagram
-            ( eq-htpy-sequential-diagram B C f g H)
-            ( h))) ∙
-        ( htpy-eq-concat _ _) ∙
-        ( ap-binary
-          ( _∙h_)
-          ( is-section-eq-htpy
-            ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
-              up-a up-b c f h))
-           ( htpy-eq-right-whisker
-             ( ap
-               ( map-sequential-colimit-hom-sequential-diagram up-b c)
-               ( eq-htpy-sequential-diagram B C f g H))
-             ( map-sequential-colimit-hom-sequential-diagram up-a b h))))
-     where
-       open import foundation.action-on-identifications-binary-functions
-       [i] =
-         htpy-eq-concat
-           ( ap
-             ( map-sequential-colimit-hom-sequential-diagram up-a c)
-             ( ap
-               ( λ f → comp-hom-sequential-diagram A B C f h)
-               ( eq-htpy-sequential-diagram B C f g H)))
-           ( eq-htpy
-             ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
-               up-a up-b c g h)) ∙
-         ap
-           ( htpy-eq
-             ( ap
-               ( map-sequential-colimit-hom-sequential-diagram up-a c)
-               ( ap
-                 ( λ f → comp-hom-sequential-diagram A B C f h)
-                 ( eq-htpy-sequential-diagram B C f g H))) ∙h_)
-           ( is-section-eq-htpy
-             ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
-               up-a up-b c g h))
-```
-
-```agda
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
-  (up-a : universal-property-sequential-colimit a)
-  {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
-  (up-b : universal-property-sequential-colimit b)
-  {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
-  (h : hom-sequential-diagram B C)
-  {f g : hom-sequential-diagram A B}
-  where
-
-  coh-comp-hom-sequential-diagram' :
-    (p : f ＝ g) →
-    ap
-      ( map-sequential-colimit-hom-sequential-diagram up-a c)
-      ( ap (comp-hom-sequential-diagram A B C h) p) ∙
-    eq-htpy
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g) ＝
-    eq-htpy
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙
-    ap
-      ( map-sequential-colimit-hom-sequential-diagram up-b c h ∘_)
-      ( ap
-        ( map-sequential-colimit-hom-sequential-diagram up-a b)
-        ( p))
-  coh-comp-hom-sequential-diagram' refl = inv right-unit
-
-  preserves-left-whisker-htpy-hom-sequential-diagram :
-    (H : htpy-hom-sequential-diagram B f g) →
-    ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
-        ( left-whisker-concat-htpy-hom-sequential-diagram h H)) ∙h
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g)) ~
-    ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙h
-      ( map-sequential-colimit-hom-sequential-diagram up-b c h ·l
-        htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H))
-  preserves-left-whisker-htpy-hom-sequential-diagram H =
-    htpy-eq
-      ( ap-binary
-          ( λ p q →
-            htpy-eq
-              ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p) ∙h
-            q)
-          ( eq-htpy-left-whisker-htpy-hom-sequential-diagram h H)
-          ( inv
-            ( is-section-eq-htpy
-              ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
-                up-a up-b c h g))) ∙
-        inv
-          ( htpy-eq-concat
-            ( ap
-              ( map-sequential-colimit-hom-sequential-diagram up-a c)
-              ( ap
-                ( comp-hom-sequential-diagram A B C h)
-                ( eq-htpy-sequential-diagram A B f g H)))
-            ( eq-htpy
-              ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
-                up-a up-b c h g))) ∙
-        ap htpy-eq
-          ( coh-comp-hom-sequential-diagram'
-            ( eq-htpy-sequential-diagram A B f g H)) ∙
-        htpy-eq-concat _ _ ∙
-        ap-binary _∙h_
-          ( is-section-eq-htpy
-            ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
-              up-a up-b c h f))
-          ( htpy-eq-left-whisker
-            ( map-sequential-colimit-hom-sequential-diagram up-b c h)
-            ( ap
-              ( map-sequential-colimit-hom-sequential-diagram up-a b)
-              ( eq-htpy-sequential-diagram A B f g H))))
-     where
-       open import foundation.action-on-identifications-binary-functions
-```
-
-## Action on homotopies of morphisms of sequential diagrams preserves concatenation
-
-```agda
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
-  (up-a : universal-property-sequential-colimit a)
-  {B : sequential-diagram l3} {Y : UU l4} (b : cocone-sequential-diagram B Y)
-  {f g h : hom-sequential-diagram A B}
-  (H : htpy-hom-sequential-diagram B f g)
-  (K : htpy-hom-sequential-diagram B g h)
+  {A : sequential-diagram l1}
+  {X : UU l2} {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  (P : X → UU l3)
   where
 
-  preserves-concat-htpy-hom-sequential-diagram :
-    htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b
-      ( concat-htpy-hom-sequential-diagram f g h H K) ~
-    htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H ∙h
-    htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b K
-  preserves-concat-htpy-hom-sequential-diagram =
-    htpy-eq
-      ( ( ap
-          ( λ p →
-            htpy-eq
-              ( ap
-                ( map-sequential-colimit-hom-sequential-diagram up-a b)
-                ( p)))
-          ( eq-htpy-concat-hom-sequential-diagram f g h H K)) ∙
-        ( ap htpy-eq
-          ( ap-concat
-            ( map-sequential-colimit-hom-sequential-diagram up-a b)
-            ( eq-htpy-sequential-diagram A B f g H)
-            ( eq-htpy-sequential-diagram A B g h K))) ∙
-        ( htpy-eq-concat
-          ( ap
-            ( map-sequential-colimit-hom-sequential-diagram up-a b)
-            ( eq-htpy-sequential-diagram A B f g H))
-          ( ap
-            ( map-sequential-colimit-hom-sequential-diagram up-a b)
-            ( eq-htpy-sequential-diagram A B g h K))))
-```
-
-## Action on homotopies of morphisms of sequential diagrams preserves associativity
+  sect-family-sect-dd-sequential-colimit :
+    section-descent-data-sequential-colimit
+      ( descent-data-family-cocone-sequential-diagram c P) →
+    ((x : X) → P x)
+  sect-family-sect-dd-sequential-colimit s =
+    map-dependent-universal-property-sequential-colimit
+      ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+      ( s)
 
-```agda
 module _
-  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
-  {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
-  (up-a : universal-property-sequential-colimit a)
-  {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
-  (up-b : universal-property-sequential-colimit b)
-  {C : sequential-diagram l5} {Z : UU l6} {c : cocone-sequential-diagram C Z}
-  (up-c : universal-property-sequential-colimit c)
-  {D : sequential-diagram l7} {V : UU l8} (d : cocone-sequential-diagram D V)
-  (f : hom-sequential-diagram A B) (g : hom-sequential-diagram B C)
-  (h : hom-sequential-diagram C D)
+  {l1 l2 l3 : Level} {A : sequential-diagram l1} {X : UU l2}
+  (c : cocone-sequential-diagram A X)
+  (P : X → UU l3)
   where
-
-  coh-assoc-comp-hom-sequential-diagram :
-    {!!}
-  coh-assoc-comp-hom-sequential-diagram = {!!}
-
-  preserves-assoc-comp-hom-sequential-diagram :
-    ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a d
-        ( assoc-comp-hom-sequential-diagram f g h)) ∙h
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-c d h
-        ( comp-hom-sequential-diagram A B C g f)) ∙h
-      ( map-sequential-colimit-hom-sequential-diagram up-c d h ·l
-        preserves-comp-map-sequential-colimit-hom-sequential-diagram
-          up-a up-b c g f)) ~
-    ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b d
-        ( comp-hom-sequential-diagram B C D h g)
-        ( f)) ∙h
-      ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
-          up-b up-c d h g ·r
-        map-sequential-colimit-hom-sequential-diagram up-a b f))
-  preserves-assoc-comp-hom-sequential-diagram =
-    {!!}
+  open import synthetic-homotopy-theory.dependent-cocones-under-sequential-diagrams
+
+  section-descent-data-section-family-cocone-sequential-colimit :
+    ((x : X) → P x) →
+    section-descent-data-sequential-colimit
+      ( descent-data-family-cocone-sequential-diagram c P)
+  section-descent-data-section-family-cocone-sequential-colimit =
+    dependent-cocone-map-sequential-diagram c P
 ```
 
--- ```agda
--- nat-lemma :
---   {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
---   {P : A → UU l3} {Q : B → UU l4}
---   (f : A → B) (h : (a : A) → P a → Q (f a))
---   {x y : A} {p : x ＝ y}
---   {q : f x ＝ f y} (α : ap f p ＝ q) →
---   coherence-square-maps
---     ( tr P p)
---     ( h x)
---     ( h y)
---     ( tr Q q)
--- nat-lemma f h {p = p} refl x =
---   substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
--- ```
-
--- ##
-
--- ```agda
--- open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
--- open import synthetic-homotopy-theory.total-cocones-families-sequential-diagrams
--- open import synthetic-homotopy-theory.total-sequential-diagrams
-
--- open import foundation.action-on-identifications-functions
--- open import foundation.commuting-squares-of-identifications
--- open import foundation.functoriality-dependent-pair-types
--- open import foundation.equality-dependent-pair-types
--- open import foundation.identity-types
--- open import synthetic-homotopy-theory.sequential-colimits
--- open import synthetic-homotopy-theory.functoriality-sequential-colimits
--- module _
---   {l1 l2 l3 l4 : Level}
---   {A : sequential-diagram l1}
---   {X : UU l2} {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   (P : family-with-descent-data-sequential-colimit c l3)
---   {Y : UU l4}
---   {c' :
---     cocone-sequential-diagram
---       ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
---       ( Y)}
---   (up-c' : universal-property-sequential-colimit c')
---   where
-
---   mediating-cocone :
---     cocone-sequential-diagram
---       ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
---       ( Σ X (family-cocone-family-with-descent-data-sequential-colimit P))
---   pr1 mediating-cocone n =
---     map-Σ
---       ( family-cocone-family-with-descent-data-sequential-colimit P)
---       ( map-cocone-sequential-diagram c n)
---       ( λ a → map-equiv-descent-data-family-with-descent-data-sequential-colimit P n a)
---   pr2 mediating-cocone n (a , p) =
---     eq-pair-Σ
---       ( coherence-cocone-sequential-diagram c n a)
---       ( inv
---         ( coherence-square-equiv-descent-data-family-with-descent-data-sequential-colimit P n a p))
-
---   totι' : Y → Σ X (family-cocone-family-with-descent-data-sequential-colimit P)
---   totι' =
---     map-universal-property-sequential-colimit up-c' mediating-cocone
---   triangle-pr1∞-pr1 :
---     pr1-sequential-colimit-total-sequential-diagram
---       ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)
---       ( up-c')
---       ( c) ~
---     pr1 ∘ totι'
---   triangle-pr1∞-pr1 =
---     htpy-htpy-out-of-sequential-colimit up-c'
---       ( concat-htpy-cocone-sequential-diagram
---         ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c' c
---           ( pr1-total-sequential-diagram
---             ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)))
---         ( ( λ n →
---             inv-htpy (pr1 ·l (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n))) ,
---           ( λ n x →
---             ap (_∙ inv (ap pr1 (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))) right-unit ∙
---             horizontal-inv-coherence-square-identifications _
---               ( ap (pr1 ∘ totι') (coherence-cocone-sequential-diagram c' n x))
---               ( coherence-cocone-sequential-diagram c n (pr1 x))
---               _
---               ( ( ap
---                   ( _∙ ap pr1
---                     ( pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))
---                   ( ap-comp pr1
---                     ( totι')
---                     ( coherence-cocone-sequential-diagram c' n x))) ∙
---                 ( inv
---                   ( ap-concat pr1
---                     ( ap
---                       ( totι')
---                       ( coherence-cocone-sequential-diagram c' n x)) _)) ∙
---                 ( ap (ap pr1) (pr2 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n x)) ∙
---                 ( ap-concat pr1
---                   ( pr1
---                     ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
---                     n x)
---                   ( coherence-cocone-sequential-diagram mediating-cocone n x)) ∙
---                 ( ap
---                   ( ap pr1
---                     ( pr1
---                       ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
---                       n x) ∙_)
---                   ( ap-pr1-eq-pair-Σ
---                     ( coherence-cocone-sequential-diagram c n (pr1 x))
---                     ( _)))))))
--- ```
-
--- ```agda
--- module _
---   {l1 l2 : Level}
---   {A : sequential-diagram l1}
---   (P : descent-data-sequential-colimit A l2)
---   where
-
---   section-descent-data-sequential-colimit : UU (l1 ⊔ l2)
---   section-descent-data-sequential-colimit =
---     Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
---         family-descent-data-sequential-colimit P n a)
---       ( λ s →
---         (n : ℕ) (a : family-sequential-diagram A n) →
---         map-family-descent-data-sequential-colimit P n a (s n a) ＝
---         s (succ-ℕ n) (map-sequential-diagram A n a))
-
--- module _
---   {l1 l2 l3 : Level}
---   {A : sequential-diagram l1}
---   {X : UU l2} {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   (P : X → UU l3)
---   where
-
---   sect-family-sect-dd-sequential-colimit :
---     section-descent-data-sequential-colimit
---       ( descent-data-family-cocone-sequential-diagram c P) →
---     ((x : X) → P x)
---   sect-family-sect-dd-sequential-colimit s =
---     map-dependent-universal-property-sequential-colimit
---       ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
---       ( s)
--- ```
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 l5 l6 : Level}
---   {A : sequential-diagram l1} {X : UU l2}
---   {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   {B : sequential-diagram l3} {Y : UU l4}
---   {c' : cocone-sequential-diagram B Y}
---   (up-c' : universal-property-sequential-colimit c')
---   (P : X → UU l5) (Q : Y → UU l6)
---   (f : hom-sequential-diagram A B)
---   (f' :
---     (x : X) → P x →
---     Q (map-sequential-colimit-hom-sequential-diagram up-c c' f x))
---   where
-
---   open import synthetic-homotopy-theory.flattening-lemma-sequential-colimits
-
---   ΣAP : sequential-diagram (l1 ⊔ l5)
---   ΣAP =
---     total-sequential-diagram (dependent-sequential-diagram-family-cocone c P)
-
---   ΣBQ : sequential-diagram (l3 ⊔ l6)
---   ΣBQ =
---     total-sequential-diagram (dependent-sequential-diagram-family-cocone c' Q)
-
---   private
---     finf : X → Y
---     finf = (map-sequential-colimit-hom-sequential-diagram up-c c' f)
-
---   totff' : hom-sequential-diagram ΣAP ΣBQ
---   pr1 totff' n =
---     map-Σ _
---       ( map-hom-sequential-diagram B f n)
---       ( λ a →
---         tr Q
---           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---             up-c c' f n a) ∘
---         f' (map-cocone-sequential-diagram c n a))
---   pr2 totff' n (a , p) =
---     eq-pair-Σ
---       ( naturality-map-hom-sequential-diagram B f n a)
---       ((pasting-vertical-coherence-square-maps
---       ( tr P (coherence-cocone-sequential-diagram c n a))
---       ( f' _)
---       ( f' _)
---       ( tr Q (ap finf (coherence-cocone-sequential-diagram c n a)))
---       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
---       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
---       ( ( tr
---           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---           ( naturality-map-hom-sequential-diagram B f n a)) ∘
---         ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
---       ( λ q →
---         substitution-law-tr Q finf (coherence-cocone-sequential-diagram c n a) ∙
---         inv (preserves-tr f' (coherence-cocone-sequential-diagram c n a) q))
---       ( ( inv-htpy
---           ( λ q →
---             ( tr-concat
---               ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                 up-c c' f n a)
---               ( _)
---               ( q)) ∙
---             ( tr-concat
---               ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
---               ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
---               ( tr Q
---                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                   up-c c' f n a)
---                 ( q))) ∙
---             ( substitution-law-tr Q
---               ( map-cocone-sequential-diagram c' (succ-ℕ n))
---               ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
---         ( λ q →
---           ap
---             ( λ p → tr Q p q)
---             ( inv
---               ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
---         ( tr-concat
---           ( ap finf (coherence-cocone-sequential-diagram c n a))
---           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---             up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))) p)
-
-
---   totff'∞ : Σ X P → Σ Y Q
---   totff'∞ =
---     map-sequential-colimit-hom-sequential-diagram
---       ( flattening-lemma-sequential-colimit _ P up-c)
---       ( total-cocone-family-cocone-sequential-diagram c' Q)
---       ( totff')
-
---   pr1A∙ : hom-sequential-diagram ΣAP A
---   pr1A∙ =
---     pr1-total-sequential-diagram
---       ( dependent-sequential-diagram-family-cocone c P)
---   pr1B∙ : hom-sequential-diagram ΣBQ B
---   pr1B∙ =
---     pr1-total-sequential-diagram
---       ( dependent-sequential-diagram-family-cocone c' Q)
-
---   pr1∘totff' : hom-sequential-diagram ΣAP B
---   pr1∘totff' = comp-hom-sequential-diagram ΣAP ΣBQ B pr1B∙ totff'
---   f∘pr1 : hom-sequential-diagram ΣAP B
---   f∘pr1 = comp-hom-sequential-diagram ΣAP A B f pr1A∙
-
---   pr1coh∙ : htpy-hom-sequential-diagram B f∘pr1 pr1∘totff'
---   pr1 pr1coh∙ n =
---     refl-htpy
---   pr2 pr1coh∙ n =
---     right-unit-htpy ∙h
---     right-unit-htpy ∙h
---     ( λ x →
---       inv
---         ( ap-pr1-eq-pair-Σ
---           ( naturality-map-hom-sequential-diagram B f n (pr1 x))
---           ( _)))
-
---   module _
---     (sA :
---       section-descent-data-sequential-colimit
---         ( descent-data-family-cocone-sequential-diagram c P))
---     (sB :
---       section-descent-data-sequential-colimit
---         ( descent-data-family-cocone-sequential-diagram c' Q))
---     where
---     open import foundation.sections
-
---     -- vertical maps, the "sides" of the cubes
---     sA∙ : hom-sequential-diagram A ΣAP
---     pr1 sA∙ n = map-section-family (pr1 sA n)
---     pr2 sA∙ n a = eq-pair-eq-fiber (pr2 sA n a)
---     sB∙ : hom-sequential-diagram B ΣBQ
---     pr1 sB∙ n = map-section-family (pr1 sB n)
---     pr2 sB∙ n b = eq-pair-eq-fiber (pr2 sB n b)
---     totff'∘sA∙ : hom-sequential-diagram A ΣBQ
---     totff'∘sA∙ = comp-hom-sequential-diagram A ΣAP ΣBQ totff' sA∙
---     sB∙∘f : hom-sequential-diagram A ΣBQ
---     sB∙∘f = comp-hom-sequential-diagram A B ΣBQ sB∙ f
---     -- the unaligned cubes
---     H∙ :
---       htpy-hom-sequential-diagram ΣBQ totff'∘sA∙ sB∙∘f
---     pr1 H∙ n a = eq-pair-eq-fiber {!!}
---     pr2 H∙ = {!!}
-
---     pr1∙∘sA∙ : hom-sequential-diagram A A
---     pr1∙∘sA∙ = comp-hom-sequential-diagram A ΣAP A pr1A∙ sA∙
-
---     idA∙ : hom-sequential-diagram A A
---     idA∙ = id-hom-sequential-diagram A
---     idB∙ : hom-sequential-diagram B B
---     idB∙ = id-hom-sequential-diagram B
---     f∘idA∙ : hom-sequential-diagram A B
---     f∘idA∙ = comp-hom-sequential-diagram A A B f idA∙
---     idB∙∘f : hom-sequential-diagram A B
---     idB∙∘f = comp-hom-sequential-diagram A B B idB∙ f
---     refl∙ : htpy-hom-sequential-diagram B f∘idA∙ idB∙∘f
---     pr1 refl∙ = ev-pair refl-htpy
---     pr2 refl∙ n a =
---       right-unit ∙
---       right-unit ∙
---       inv (ap-id (naturality-map-hom-sequential-diagram B f n a))
---     -- the alignment: postcomposing H∙ with pr1coh∙ is homotopic with id
---     ℋ :
---       {!htpy²-hom-sequential-diagram!}
---     ℋ = {!!}
-
---   _ :
---     totι' up-c
---       ( family-with-descent-data-family-cocone-sequential-diagram c P)
---       ( flattening-lemma-sequential-colimit c P up-c) ~
---     id
---   _ =
---     compute-map-universal-property-sequential-colimit-id
---       ( flattening-lemma-sequential-colimit _ P up-c)
-
---   _ :
---     coherence-square-maps
---       ( totι' up-c
---         ( family-with-descent-data-family-cocone-sequential-diagram c P)
---         ( flattening-lemma-sequential-colimit c P up-c))
---       ( totff'∞)
---       ( map-Σ Q
---         ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---         f')
---       ( totι' up-c'
---         ( family-with-descent-data-family-cocone-sequential-diagram c' Q)
---         ( flattening-lemma-sequential-colimit c' Q up-c'))
---   _ =
---     ( compute-map-universal-property-sequential-colimit-id
---       ( flattening-lemma-sequential-colimit c' Q up-c') ·r _) ∙h
---     ( htpy-htpy-out-of-sequential-colimit
---       ( flattening-lemma-sequential-colimit c P up-c)
---       ( concat-htpy-cocone-sequential-diagram
---         ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---           ( flattening-lemma-sequential-colimit c P up-c)
---           ( total-cocone-family-cocone-sequential-diagram c' Q)
---           ( totff'))
---         ( ( λ n (a , p) →
---             inv
---               ( eq-pair-Σ
---                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
---                   ( f)
---                   ( n)
---                   ( a))
---                 refl)) ,
---           {!!}))) ∙h
---     ( _ ·l
---       ( inv-htpy
---         (compute-map-universal-property-sequential-colimit-id
---           ( flattening-lemma-sequential-colimit c P up-c))))
-
---     -- htpy-htpy-out-of-sequential-colimit
---     --   ( flattening-lemma-sequential-colimit c P up-c)
---     --   ( {!!})
--- ```
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 : Level}
---   {A : sequential-diagram l1} {X : UU l2}
---   {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   {B : sequential-diagram l3} {Y : UU l4}
---   {c' : cocone-sequential-diagram B Y}
---   (up-c' : universal-property-sequential-colimit c')
---   (f : hom-sequential-diagram A B)
---   where
---   open import foundation.homotopies-morphisms-arrows
-
---   interm :
---     coherence-square-maps
---       ( id)
---       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---       ( id)
---   interm =
---     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-c c'
---       ( refl-htpy-hom-sequential-diagram A B f)
-
---   preserves-refl-htpy-sequential-colimit :
---     htpy-hom-arrow
---       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---       ( id , id , interm)
---       ( id , id , refl-htpy)
---   pr1 preserves-refl-htpy-sequential-colimit = refl-htpy
---   pr1 (pr2 preserves-refl-htpy-sequential-colimit) = refl-htpy
---   pr2 (pr2 preserves-refl-htpy-sequential-colimit) =
---     right-unit-htpy ∙h
---     htpy-eq
---       ( ap
---         ( htpy-eq ∘ ap (map-sequential-colimit-hom-sequential-diagram up-c c'))
---         ( is-retraction-map-inv-equiv
---           ( extensionality-hom-sequential-diagram A B f f)
---           ( refl)))
--- ```
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 : Level}
---   {A : sequential-diagram l1}
---   (B : sequential-diagram l2)
---   (f : hom-sequential-diagram A B)
---   (P : descent-data-sequential-colimit A l3)
---   (Q : descent-data-sequential-colimit B l4)
---   where
-
---   hom-over-hom : UU (l1 ⊔ l3 ⊔ l4)
---   hom-over-hom =
---     Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
---         family-descent-data-sequential-colimit P n a →
---         family-descent-data-sequential-colimit Q n
---           ( map-hom-sequential-diagram B f n a))
---       ( λ f'n →
---         (n : ℕ) →
---         square-over
---           { Q4 = family-descent-data-sequential-colimit Q (succ-ℕ n)}
---           ( map-sequential-diagram A n)
---           ( map-hom-sequential-diagram B f n)
---           ( map-hom-sequential-diagram B f (succ-ℕ n))
---           ( map-sequential-diagram B n)
---           ( λ {a} → map-family-descent-data-sequential-colimit P n a)
---           ( λ {a} → f'n n a)
---           ( λ {a} → f'n (succ-ℕ n) a)
---           ( λ {a} → map-family-descent-data-sequential-colimit Q n a)
---           ( naturality-map-hom-sequential-diagram B f n))
--- module _
---   {l1 l2 l3 l4 l5 l6 : Level}
---   {A : sequential-diagram l1} {X : UU l2}
---   {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   {B : sequential-diagram l3} {Y : UU l4}
---   {c' : cocone-sequential-diagram B Y}
---   (up-c' : universal-property-sequential-colimit c')
---   (f : hom-sequential-diagram A B)
---   (P : X → UU l5) (Q : Y → UU l6)
---   where
-
---   private
---     f∞ : X → Y
---     f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f
---     DDMO : descent-data-sequential-colimit A (l5 ⊔ l6)
---     pr1 DDMO n a =
---       P (map-cocone-sequential-diagram c n a) →
---       Q (map-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
---     pr2 DDMO n a =
---       ( equiv-postcomp _
---         ( ( equiv-tr
---             ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---             ( naturality-map-hom-sequential-diagram B f n a)) ∘e
---           ( equiv-tr Q (coherence-cocone-sequential-diagram c' n _)))) ∘e
---       ( equiv-precomp
---         ( inv-equiv (equiv-tr P (coherence-cocone-sequential-diagram c n a)))
---         ( _))
-
---   sect-over-DDMO-map-over :
---     ((a : X) → P a → Q (f∞ a)) →
---     section-descent-data-sequential-colimit DDMO
---   pr1 (sect-over-DDMO-map-over f∞') n a =
---     ( tr Q
---       ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
---     ( f∞' (map-cocone-sequential-diagram c n a))
---   pr2 (sect-over-DDMO-map-over f∞') n a =
---     eq-htpy
---       ( λ p →
---         {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a!})
-
---   sect-over-DDMO-map-over' :
---     ((a : X) → P a → Q (f∞ a)) →
---     section-descent-data-sequential-colimit DDMO
---   sect-over-DDMO-map-over' =
---     {!sect-family-sect-dd-sequential-colimit!}
-
---   map-over-sect-DDMO :
---     section-descent-data-sequential-colimit DDMO →
---     hom-over-hom B f
---       ( descent-data-family-cocone-sequential-diagram c P)
---       ( descent-data-family-cocone-sequential-diagram c' Q)
---   map-over-sect-DDMO =
---     tot
---       ( λ s →
---         map-Π
---           ( λ n →
---             ( map-implicit-Π
---               ( λ a →
---                 ( concat-htpy
---                   ( inv-htpy
---                     ( ( ( tr
---                           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---                           ( naturality-map-hom-sequential-diagram B f n a)) ∘
---                         ( tr Q
---                           ( coherence-cocone-sequential-diagram c' n
---                             (map-hom-sequential-diagram B f n a))) ∘
---                         ( s n a)) ·l
---                       ( is-retraction-inv-tr P
---                         ( coherence-cocone-sequential-diagram c n a))))
---                   ( _)) ∘
---                 ( map-equiv
---                   ( equiv-htpy-precomp-htpy-Π _ _
---                     ( equiv-tr P
---                       ( coherence-cocone-sequential-diagram c n a)))) ∘
---                 ( htpy-eq
---                   {f =
---                     ( tr
---                       ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---                       ( naturality-map-hom-sequential-diagram B f n a)) ∘
---                     ( tr Q
---                       ( coherence-cocone-sequential-diagram c' n
---                         ( map-hom-sequential-diagram B f n a))) ∘
---                     ( s n a) ∘
---                     ( tr P (inv (coherence-cocone-sequential-diagram c n a)))}
---                   { s (succ-ℕ n) (map-sequential-diagram A n a)}))) ∘
---             ( implicit-explicit-Π)))
-
---   map-over-diagram-map-over-colimit :
---     ((a : X) → P a → Q (f∞ a)) →
---     hom-over-hom B f
---       ( descent-data-family-cocone-sequential-diagram c P)
---       ( descent-data-family-cocone-sequential-diagram c' Q)
---   pr1 (map-over-diagram-map-over-colimit f∞') n a =
---     ( tr Q
---       ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
---     ( f∞' (map-cocone-sequential-diagram c n a))
---   pr2 (map-over-diagram-map-over-colimit f∞') n {a} =
---     pasting-vertical-coherence-square-maps
---       ( tr P (coherence-cocone-sequential-diagram c n a))
---       ( f∞' _)
---       ( f∞' _)
---       ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
---       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
---       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
---       ( ( tr
---           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---           ( naturality-map-hom-sequential-diagram B f n a)) ∘
---         ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
---       ( λ q →
---         substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
---         inv (preserves-tr f∞' (coherence-cocone-sequential-diagram c n a) q))
---       ( ( inv-htpy
---           ( λ q →
---             ( tr-concat
---               ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                 up-c c' f n a)
---               ( _)
---               ( q)) ∙
---             ( tr-concat
---               ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
---               ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
---               ( tr Q
---                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                   up-c c' f n a)
---                 ( q))) ∙
---             ( substitution-law-tr Q
---               ( map-cocone-sequential-diagram c' (succ-ℕ n))
---               ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
---         ( λ q →
---           ap
---             ( λ p → tr Q p q)
---             ( inv
---               ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
---         ( tr-concat
---           ( ap f∞ (coherence-cocone-sequential-diagram c n a))
---           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---             up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))
-
---   abstract
---     triangle-map-over-sect-DDMO :
---       coherence-triangle-maps
---         ( map-over-diagram-map-over-colimit)
---         ( map-over-sect-DDMO)
---         ( sect-over-DDMO-map-over)
---     triangle-map-over-sect-DDMO f∞' =
---       eq-pair-eq-fiber
---         ( eq-htpy
---           ( λ n →
---             eq-htpy-implicit
---               ( λ a →
---                 eq-htpy
---                   ( λ p →
---                     {!!}))))
-
---     is-equiv-map-over-sect-DDMO :
---       is-equiv map-over-sect-DDMO
---     is-equiv-map-over-sect-DDMO =
---       is-equiv-tot-is-fiberwise-equiv
---         ( λ s →
---           is-equiv-map-Π-is-fiberwise-equiv
---             ( λ n →
---               is-equiv-comp _ _
---                 ( is-equiv-implicit-explicit-Π)
---                 ( is-equiv-map-implicit-Π-is-fiberwise-equiv
---                   ( λ a →
---                     is-equiv-comp _ _
---                       ( funext _ _)
---                       ( is-equiv-comp _ _
---                         ( is-equiv-map-equiv (equiv-htpy-precomp-htpy-Π _ _ _))
---                         ( is-equiv-concat-htpy _ _))))))
-
---     is-equiv-map-over-diagram-map-over-colimit :
---       is-equiv map-over-diagram-map-over-colimit
---     is-equiv-map-over-diagram-map-over-colimit =
---       {!is-equiv-left-map-triangle
---         ( map-over-diagram-map-over-colimit)
---         ( map-over-sect-DDMO)
---         ( sect-over-DDMO-map-over)
---         ( triangle-map-over-sect-DDMO)
---         ( is-equiv) !}
--- ```
-
 -- ```agda
 -- module big-thm
 --   {l1 l2 l3 l4 l5 l6 : Level}
@@ -1621,4 +280,297 @@ module _
 --                     ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
 --                       ( dependent-universal-property-universal-property-sequential-colimit _ up-c')
 --                       ( sB)) n (fn a)))
--- ```
+```
+
+```agda
+module _
+  {l1 l2 : Level} {A : sequential-diagram l1}
+  {B : dependent-sequential-diagram A l2}
+  (s t : section-dependent-sequential-diagram A B)
+  where
+
+  htpy-section-dependent-sequential-diagram : UU (l1 ⊔ l2)
+  htpy-section-dependent-sequential-diagram =
+    Σ ((n : ℕ) →
+        map-section-dependent-sequential-diagram A B s n ~
+        map-section-dependent-sequential-diagram A B t n)
+      ( λ H →
+        (n : ℕ) →
+        coherence-square-homotopies
+          ( map-dependent-sequential-diagram B n _ ·l H n)
+          ( naturality-map-section-dependent-sequential-diagram A B s n)
+          ( naturality-map-section-dependent-sequential-diagram A B t n)
+          ( H (succ-ℕ n) ·r map-sequential-diagram A n))
+
+module _
+  {l1 l2 : Level} {A : sequential-diagram l1}
+  {B : dependent-sequential-diagram A l2}
+  (s : section-dependent-sequential-diagram A B)
+  where
+
+  refl-htpy-section-dependent-sequential-diagram :
+    htpy-section-dependent-sequential-diagram s s
+  pr1 refl-htpy-section-dependent-sequential-diagram n =
+    refl-htpy
+  pr2 refl-htpy-section-dependent-sequential-diagram n =
+    right-unit-htpy
+
+  htpy-eq-section-dependent-sequential-diagram :
+    (t : section-dependent-sequential-diagram A B) →
+    s ＝ t → htpy-section-dependent-sequential-diagram s t
+  htpy-eq-section-dependent-sequential-diagram .s refl =
+    refl-htpy-section-dependent-sequential-diagram
+
+  abstract
+    is-torsorial-htpy-section-dependent-sequential-diagram :
+      is-torsorial (htpy-section-dependent-sequential-diagram s)
+    is-torsorial-htpy-section-dependent-sequential-diagram =
+      is-torsorial-Eq-structure
+        ( is-torsorial-binary-htpy _)
+        ( pr1 s , λ n → refl-htpy)
+        ( is-torsorial-binary-htpy _)
+
+    is-equiv-htpy-eq-section-dependent-sequential-diagram :
+      (t : section-dependent-sequential-diagram A B) →
+      is-equiv (htpy-eq-section-dependent-sequential-diagram t)
+    is-equiv-htpy-eq-section-dependent-sequential-diagram =
+      fundamental-theorem-id
+        ( is-torsorial-htpy-section-dependent-sequential-diagram)
+        ( htpy-eq-section-dependent-sequential-diagram)
+
+  equiv-htpy-eq-section-dependent-sequential-diagram :
+    (t : section-dependent-sequential-diagram A B) →
+    (s ＝ t) ≃
+    htpy-section-dependent-sequential-diagram s t
+  equiv-htpy-eq-section-dependent-sequential-diagram t =
+    ( htpy-eq-section-dependent-sequential-diagram t ,
+      is-equiv-htpy-eq-section-dependent-sequential-diagram t)
+
+  eq-htpy-section-dependent-sequential-diagram :
+    (t : section-dependent-sequential-diagram A B) →
+    htpy-section-dependent-sequential-diagram s t →
+    s ＝ t
+  eq-htpy-section-dependent-sequential-diagram t =
+    map-inv-equiv (equiv-htpy-eq-section-dependent-sequential-diagram t)
+
+module _
+  {l1 l2 : Level} {A : sequential-diagram l1}
+  (B : descent-data-sequential-colimit A l2)
+  (s t : section-descent-data-sequential-colimit B)
+  where
+
+  eq-htpy-section-descent-data-sequential-colimit :
+    htpy-section-dependent-sequential-diagram s t →
+    s ＝ t
+  eq-htpy-section-descent-data-sequential-colimit =
+    eq-htpy-section-dependent-sequential-diagram s t
+
+module _
+  {l1 l2 l3 : Level} {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  (P : X → UU l3)
+  (let P' = descent-data-family-cocone-sequential-diagram c P)
+  (s t : section-descent-data-sequential-colimit P')
+  where
+
+  htpy-colimit-htpy-diagram-section :
+    htpy-section-dependent-sequential-diagram s t →
+    sect-family-sect-dd-sequential-colimit up-c P s ~
+    sect-family-sect-dd-sequential-colimit up-c P t
+  htpy-colimit-htpy-diagram-section H =
+    htpy-eq
+      ( ap
+        ( sect-family-sect-dd-sequential-colimit up-c P)
+        ( eq-htpy-section-dependent-sequential-diagram s t H))
+```
+
+```agda
+module _
+  {l1 l2 l3 : Level} {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  (P : X → UU l3)
+  where
+
+  htpy-section-out-of-sequential-colimit : (s t : (x : X) → P x) → UU (l1 ⊔ l3)
+  htpy-section-out-of-sequential-colimit s t =
+    htpy-section-dependent-sequential-diagram
+      ( section-descent-data-section-family-cocone-sequential-colimit c P s)
+      ( section-descent-data-section-family-cocone-sequential-colimit c P t)
+
+  equiv-htpy-section-out-of-sequential-colimit :
+    (s t : (x : X) → P x) →
+    htpy-section-out-of-sequential-colimit s t ≃ (s ~ t)
+  equiv-htpy-section-out-of-sequential-colimit s t =
+    ( inv-equiv
+      ( equiv-dependent-universal-property-sequential-colimit
+        ( dependent-universal-property-universal-property-sequential-colimit c
+          ( up-c)))) ∘e
+    ( equiv-tot
+      ( λ H →
+        equiv-Π-equiv-family
+          ( λ n →
+            equiv-Π-equiv-family
+              ( λ a →
+                compute-dependent-identification-eq-value s t
+                  ( coherence-cocone-sequential-diagram c n a)
+                  ( H n a)
+                  ( H (succ-ℕ n) (map-sequential-diagram A n a))))))
+
+  -- (2.i)
+  htpy-htpy-section-out-of-sequential-colimit :
+    (s t : (x : X) → P x) →
+    htpy-section-out-of-sequential-colimit s t → (s ~ t)
+  htpy-htpy-section-out-of-sequential-colimit s t =
+    map-equiv (equiv-htpy-section-out-of-sequential-colimit s t)
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (Q : Y → UU l5)
+  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
+  (f : hom-sequential-diagram A B)
+  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (let P = Q ∘ f∞)
+  (let P' = descent-data-family-cocone-sequential-diagram c P)
+  (let C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (s : section-descent-data-sequential-colimit Q')
+  (let s∞ = sect-family-sect-dd-sequential-colimit up-c' Q s)
+  -- remove later
+  (t : section-descent-data-sequential-colimit P')
+  (let t∞ = sect-family-sect-dd-sequential-colimit up-c P t)
+  where
+
+  private
+    γ :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      coherence-square-maps
+        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+        ( tr Q (C n a))
+        ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+    γ n a q =
+      inv
+        ( ( tr-concat
+            ( C n a)
+            ( _)
+            ( q)) ∙
+          ( tr-concat
+            ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+            ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) _)
+            ( _)) ∙
+          ( substitution-law-tr Q
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))) ∙
+      ap
+        ( λ p → tr Q p q)
+        ( inv
+          ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∙
+      tr-concat
+        ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+        ( C (succ-ℕ n) (map-sequential-diagram A n a))
+        ( q) ∙
+      ap
+        ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+        ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a))
+
+    γ-flip :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      coherence-square-maps
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+        ( tr Q (inv (C n a)))
+        ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+    γ-flip n a =
+      vertical-inv-equiv-coherence-square-maps
+        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+        ( equiv-tr Q (C n a))
+        ( equiv-tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+        ( γ n a)
+
+  comp-over-diagram :
+    section-descent-data-sequential-colimit
+      ( descent-data-family-cocone-sequential-diagram c (Q ∘ f∞))
+  pr1 comp-over-diagram n a =
+    tr Q
+      ( inv (C n a))
+      ( map-section-dependent-sequential-diagram _ _ s n
+        (map-hom-sequential-diagram B f n a))
+  pr2 comp-over-diagram n a =
+    ( γ-flip n a
+      ( map-section-dependent-sequential-diagram _ _ s n
+        ( map-hom-sequential-diagram B f n a))) ∙
+    ( ap
+      ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+      ( ( ap
+          ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( naturality-map-section-dependent-sequential-diagram _ _ s n
+            ( map-hom-sequential-diagram B f n a))) ∙
+        ( apd
+          ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B f n a))))
+
+  lemma-1-1 :
+    htpy-section-dependent-sequential-diagram
+      ( section-descent-data-section-family-cocone-sequential-colimit c P
+        ( sect-family-sect-dd-sequential-colimit up-c P comp-over-diagram))
+      ( comp-over-diagram)
+  lemma-1-1 =
+    htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+      ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
+      ( comp-over-diagram)
+
+  -- needs work
+  lemma-1-2 :
+    htpy-section-dependent-sequential-diagram
+      ( section-descent-data-section-family-cocone-sequential-colimit c P
+        ( s∞ ∘ f∞))
+      ( comp-over-diagram)
+  pr1 lemma-1-2 n a = {!!}
+  pr2 lemma-1-2 = {!!}
+
+  lemma-1 :
+    s∞ ∘ f∞ ~ sect-family-sect-dd-sequential-colimit up-c P comp-over-diagram
+  lemma-1 =
+    htpy-htpy-section-out-of-sequential-colimit up-c P _ _
+      ( concat-htpy-dependent-cocone-sequential-diagram P
+        ( lemma-1-2)
+        ( inv-htpy-dependent-cocone-sequential-diagram P lemma-1-1))
+
+  -- needs work, needs another input
+  lemma-2 : htpy-section-dependent-sequential-diagram t comp-over-diagram
+  pr1 lemma-2 = {!!}
+  pr2 lemma-2 = {!!}
+
+  theorem : t∞ ~ s∞ ∘ f∞
+  theorem =
+    htpy-colimit-htpy-diagram-section up-c P t comp-over-diagram lemma-2 ∙h
+    inv-htpy lemma-1
+```
+
diff --git a/src/synthetic-homotopy-theory/old-stuff.lagda.md b/src/synthetic-homotopy-theory/old-stuff.lagda.md
new file mode 100644
index 0000000000..8234ecbf02
--- /dev/null
+++ b/src/synthetic-homotopy-theory/old-stuff.lagda.md
@@ -0,0 +1,1400 @@
+New idea: instead of bruteforcing this direction, show that a square induces
+coherent cubes, and show that it's an equivalence because it fits in a diagram.
+
+-- ## Commuting cubes induce commuting squares in the colimit
+
+-- ```agda
+-- open import foundation.commuting-cubes-of-maps
+-- module _
+--   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+--   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+--   (up-a : universal-property-sequential-colimit a)
+--   {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
+--   (up-b : universal-property-sequential-colimit b)
+--   {P : sequential-diagram l5} {V : UU l6} {p : cocone-sequential-diagram P V}
+--   (up-p : universal-property-sequential-colimit p)
+--   {Q : sequential-diagram l7} {W : UU l8} {q : cocone-sequential-diagram Q W}
+--   (up-q : universal-property-sequential-colimit q)
+--   (f' : hom-sequential-diagram P Q)
+--   (f : hom-sequential-diagram A B)
+--   (g : hom-sequential-diagram P A)
+--   (h : hom-sequential-diagram Q B)
+--   where
+
+--   square-cube-sequential-colimit :
+--     (faces :
+--       (n : ℕ) →
+--       coherence-square-maps
+--         ( map-hom-sequential-diagram Q f' n)
+--         ( map-hom-sequential-diagram A g n)
+--         ( map-hom-sequential-diagram B h n)
+--         ( map-hom-sequential-diagram B f n)) →
+--     (cubes :
+--       (n : ℕ) →
+--       coherence-cube-maps
+--         ( map-hom-sequential-diagram B f n)
+--         ( map-sequential-diagram A n)
+--         ( map-sequential-diagram B n)
+--         ( map-hom-sequential-diagram B f (succ-ℕ n))
+--         ( map-hom-sequential-diagram Q f' n)
+--         ( map-sequential-diagram P n)
+--         ( map-sequential-diagram Q n)
+--         ( map-hom-sequential-diagram Q f' (succ-ℕ n))
+--         ( map-hom-sequential-diagram A g n)
+--         ( map-hom-sequential-diagram B h n)
+--         ( map-hom-sequential-diagram A g (succ-ℕ n))
+--         ( map-hom-sequential-diagram B h (succ-ℕ n))
+--         ( naturality-map-hom-sequential-diagram Q f' n)
+--         ( faces n)
+--         ( naturality-map-hom-sequential-diagram A g n)
+--         ( naturality-map-hom-sequential-diagram B h n)
+--         ( faces (succ-ℕ n))
+--         ( naturality-map-hom-sequential-diagram B f n)) →
+--     coherence-square-maps
+--       ( map-sequential-colimit-hom-sequential-diagram up-p q f')
+--       ( map-sequential-colimit-hom-sequential-diagram up-p a g)
+--       ( map-sequential-colimit-hom-sequential-diagram up-q b h)
+--       ( map-sequential-colimit-hom-sequential-diagram up-a b f)
+--   square-cube-sequential-colimit faces cubes =
+--     inv-htpy
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-p up-a b
+--         f g) ∙h
+--     induced-htpy ∙h
+--     preserves-comp-map-sequential-colimit-hom-sequential-diagram up-p up-q b h f'
+--     where
+--     comp1 comp2 : hom-sequential-diagram P B
+--     comp1 = comp-hom-sequential-diagram P A B f g
+--     comp2 = comp-hom-sequential-diagram P Q B h f'
+--     induced-hom-htpy : htpy-hom-sequential-diagram B comp1 comp2
+--     pr1 induced-hom-htpy = faces
+--     pr2 induced-hom-htpy n =
+--       assoc-htpy _ _ _ ∙h
+--       inv-htpy (cubes n) ∙h
+--       assoc-htpy _ _ _
+--     induced-htpy :
+--       map-sequential-colimit-hom-sequential-diagram up-p b comp1 ~
+--       map-sequential-colimit-hom-sequential-diagram up-p b comp2
+--     induced-htpy =
+--       htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-p b
+--         ( induced-hom-htpy)
+-- ```
+
+-- ## Concatenation of homotopies of morphisms of sequential diagrams
+
+-- ```agda
+-- open import foundation.whiskering-homotopies-concatenation
+-- module _
+--   {l1 l2 : Level}
+--   {A : sequential-diagram l1} {B : sequential-diagram l2}
+--   (f g h : hom-sequential-diagram A B)
+--   where
+
+--   module _
+--     (H : htpy-hom-sequential-diagram B f g)
+--     (K : htpy-hom-sequential-diagram B g h)
+--     where
+
+--     concat-htpy-hom-sequential-diagram : htpy-hom-sequential-diagram B f h
+--     pr1 concat-htpy-hom-sequential-diagram n =
+--       htpy-htpy-hom-sequential-diagram _ H n ∙h
+--       htpy-htpy-hom-sequential-diagram _ K n
+--     pr2 concat-htpy-hom-sequential-diagram n =
+--       inv-htpy-assoc-htpy _ _ _ ∙h
+--       right-whisker-concat-htpy
+--         ( coherence-htpy-htpy-hom-sequential-diagram B H n)
+--         ( htpy-htpy-hom-sequential-diagram _ K (succ-ℕ n) ·r map-sequential-diagram A n) ∙h
+--       assoc-htpy _ _ _ ∙h
+--       left-whisker-concat-htpy
+--         ( map-sequential-diagram B n ·l htpy-htpy-hom-sequential-diagram _ H n)
+--         ( coherence-htpy-htpy-hom-sequential-diagram B K n) ∙h
+--       inv-htpy-assoc-htpy _ _ _ ∙h
+--       right-whisker-concat-htpy
+--         ( inv-htpy
+--           ( distributive-left-whisker-comp-concat
+--             ( map-sequential-diagram B n)
+--             ( htpy-htpy-hom-sequential-diagram _ H n)
+--             ( htpy-htpy-hom-sequential-diagram _ K n)))
+--         ( naturality-map-hom-sequential-diagram B h n)
+
+--   htpy-eq-concat-hom-sequential-diagram :
+--     (p : f ＝ g) (q : g ＝ h) →
+--     htpy-eq-sequential-diagram A B f h (p ∙ q) ＝
+--     concat-htpy-hom-sequential-diagram
+--       ( htpy-eq-sequential-diagram A B f g p)
+--       ( htpy-eq-sequential-diagram A B g h q)
+--   htpy-eq-concat-hom-sequential-diagram refl refl =
+--     eq-pair-eq-fiber
+--       ( inv
+--         ( eq-binary-htpy _ _
+--           λ n a →
+--           right-unit ∙ right-unit ∙
+--           ap
+--             ( (inv (assoc _ refl refl) ∙ ap (_∙ refl) right-unit) ∙ refl ∙_)
+--             ( ap-id right-unit) ∙
+--           ap
+--             ( _∙ right-unit)
+--             ( right-unit ∙
+--               ap
+--                 ( λ p → inv p ∙ ap (_∙ refl) right-unit)
+--                 ( middle-unit-law-assoc
+--                     ( naturality-map-hom-sequential-diagram B f n a)
+--                     ( refl)) ∙
+--               left-inv (ap (_∙ refl) right-unit))))
+--     where
+--       open import foundation.binary-homotopies
+--       open import foundation.path-algebra
+
+--   eq-htpy-concat-hom-sequential-diagram :
+--     (H : htpy-hom-sequential-diagram B f g)
+--     (K : htpy-hom-sequential-diagram B g h) →
+--     eq-htpy-sequential-diagram A B f h
+--       ( concat-htpy-hom-sequential-diagram H K) ＝
+--     eq-htpy-sequential-diagram A B f g H ∙
+--     eq-htpy-sequential-diagram A B g h K
+--   eq-htpy-concat-hom-sequential-diagram H K =
+--     ap
+--       ( eq-htpy-sequential-diagram A B f h)
+--       ( inv
+--         ( htpy-eq-concat-hom-sequential-diagram
+--           ( eq-htpy-sequential-diagram A B f g H)
+--           ( eq-htpy-sequential-diagram A B g h K) ∙
+--         ap-binary concat-htpy-hom-sequential-diagram
+--           ( is-section-map-inv-equiv
+--             ( extensionality-hom-sequential-diagram A B f g)
+--             ( H))
+--           ( is-section-map-inv-equiv
+--             ( extensionality-hom-sequential-diagram A B g h)
+--             ( K)))) ∙
+--     is-retraction-map-inv-equiv
+--       ( extensionality-hom-sequential-diagram A B f h)
+--       ( eq-htpy-sequential-diagram A B f g H ∙
+--         eq-htpy-sequential-diagram A B g h K)
+--     where open import foundation.action-on-identifications-binary-functions
+-- ```
+
+-- ## Vertical pasting of cubes of stuff
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : sequential-diagram l1} {B : sequential-diagram l2}
+--   {A' : sequential-diagram l3} {B' : sequential-diagram l4}
+--   {A'' : sequential-diagram l5} {B'' : sequential-diagram l6}
+--   (top : hom-sequential-diagram A'' B'')
+--   (top-left : hom-sequential-diagram A'' A')
+--   (top-right : hom-sequential-diagram B'' B')
+--   (mid : hom-sequential-diagram A' B')
+--   (bottom-left : hom-sequential-diagram A' A)
+--   (bottom-right : hom-sequential-diagram B' B)
+--   (bottom : hom-sequential-diagram A B)
+--   (H :
+--     htpy-hom-sequential-diagram B
+--       ( comp-hom-sequential-diagram A' A B bottom bottom-left)
+--       ( comp-hom-sequential-diagram A' B' B bottom-right mid))
+--   (K :
+--     htpy-hom-sequential-diagram B'
+--       ( comp-hom-sequential-diagram A'' A' B' mid top-left)
+--       ( comp-hom-sequential-diagram A'' B'' B' top-right top))
+--   -- (faces-top :
+--   --   (n : ℕ) →
+--   --   coherence-square-maps
+--   --     ( map-hom-sequential-diagram B'' top n)
+--   --     ( map-hom-sequential-diagram A' top-left n)
+--   --     ( map-hom-sequential-diagram B' top-right n)
+--   --     ( map-hom-sequential-diagram B' mid n))
+--   -- (faces-bottom :
+--   --   (n : ℕ) → {!!})
+--   -- (cubes-top :
+--   --   (n : ℕ) → {!!})
+--   -- (cubes-bottom :
+--   --   (n : ℕ) → {!!})
+--   -- -- (cubes :
+--   -- --   (n : ℕ) →
+--   -- --   coherence-cube-maps
+--   -- --     ( map-hom-sequential-diagram B f n)
+--   -- --     ( map-sequential-diagram A n)
+--   -- --     ( map-sequential-diagram B n)
+--   -- --     ( map-hom-sequential-diagram B f (succ-ℕ n))
+--   -- --     ( map-hom-sequential-diagram Q f' n)
+--   -- --     ( map-sequential-diagram P n)
+--   -- --     ( map-sequential-diagram Q n)
+--   -- --     ( map-hom-sequential-diagram Q f' (succ-ℕ n))
+--   -- --     ( map-hom-sequential-diagram A g n)
+--   -- --     ( map-hom-sequential-diagram B h n)
+--   -- --     ( map-hom-sequential-diagram A g (succ-ℕ n))
+--   -- --     ( map-hom-sequential-diagram B h (succ-ℕ n))
+--   -- --     ( naturality-map-hom-sequential-diagram Q f' n)
+--   -- --     ( faces n)
+--   -- --     ( naturality-map-hom-sequential-diagram A g n)
+--   -- --     ( naturality-map-hom-sequential-diagram B h n)
+--   -- --     ( faces (succ-ℕ n))
+--   -- --     ( naturality-map-hom-sequential-diagram B f n)) →
+--   where
+
+--   pasting-vertical-coherence-square-hom-sequential-diagram :
+--     htpy-hom-sequential-diagram B
+--       ( comp-hom-sequential-diagram A'' A B bottom
+--         ( comp-hom-sequential-diagram A'' A' A bottom-left top-left))
+--       ( comp-hom-sequential-diagram A'' B'' B
+--         ( comp-hom-sequential-diagram B'' B' B bottom-right top-right)
+--         ( top))
+--   pasting-vertical-coherence-square-hom-sequential-diagram = {!!}
+-- ```
+
+-- ## Whiskering of homotopies of morphisms of sequential diagrams
+
+-- ### Right whiskering
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3}
+--   where
+
+--   htpy-eq-right-whisker :
+--     {f g : B → C} (p : f ＝ g) (h : A → B) →
+--     htpy-eq (ap (_∘ h) p) ＝ htpy-eq p ·r h
+--   htpy-eq-right-whisker refl h = refl
+
+--   eq-htpy-right-whisker :
+--     {f g : B → C} (H : f ~ g) (h : A → B) →
+--     eq-htpy (H ·r h) ＝ ap (_∘ h) (eq-htpy H)
+--   eq-htpy-right-whisker H h =
+--     ap eq-htpy
+--       ( inv
+--         ( htpy-eq-right-whisker (eq-htpy H) h ∙
+--           ap (_·r h) (is-section-eq-htpy H))) ∙
+--     is-retraction-eq-htpy (ap (_∘ h) (eq-htpy H))
+
+--   htpy-eq-left-whisker :
+--     {f g : A → B} (h : B → C) (p : f ＝ g) →
+--     htpy-eq (ap (h ∘_) p) ＝ h ·l htpy-eq p
+--   htpy-eq-left-whisker h refl = refl
+
+--   -- alternatively, using homotopy induction
+--   eq-htpy-left-whisker :
+--     {f g : A → B} (h : B → C) (H : f ~ g) →
+--     eq-htpy (h ·l H) ＝ ap (h ∘_) (eq-htpy H)
+--   eq-htpy-left-whisker {f} h =
+--     ind-htpy f
+--       ( λ g H →
+--         eq-htpy (h ·l H) ＝ ap (h ∘_) (eq-htpy H))
+--       ( eq-htpy-refl-htpy (h ∘ f) ∙
+--         inv (ap (ap (h ∘_)) (eq-htpy-refl-htpy f)))
+--     where open import foundation.homotopy-induction
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 : Level}
+--   {A : sequential-diagram l1} {B : sequential-diagram l2}
+--   {X : sequential-diagram l3}
+--   {f g : hom-sequential-diagram A B}
+--   where
+--   open import foundation.whiskering-identifications-concatenation
+
+--   module _
+--     (H : htpy-hom-sequential-diagram B f g)
+--     (h : hom-sequential-diagram X A)
+--     where
+
+--     right-whisker-concat-htpy-hom-sequential-diagram :
+--       htpy-hom-sequential-diagram B
+--         ( comp-hom-sequential-diagram X A B f h)
+--         ( comp-hom-sequential-diagram X A B g h)
+--     pr1 right-whisker-concat-htpy-hom-sequential-diagram n =
+--       htpy-htpy-hom-sequential-diagram _ H n ·r map-hom-sequential-diagram A h n
+--     pr2 right-whisker-concat-htpy-hom-sequential-diagram n x =
+--       assoc _ _ _ ∙
+--       left-whisker-concat
+--         ( naturality-map-hom-sequential-diagram B f n (map-hom-sequential-diagram A h n x))
+--         ( inv-nat-htpy
+--           ( htpy-htpy-hom-sequential-diagram B H (succ-ℕ n))
+--           ( naturality-map-hom-sequential-diagram A h n x)) ∙
+--       inv (assoc _ _ _) ∙
+--       right-whisker-concat
+--         ( coherence-htpy-htpy-hom-sequential-diagram B H n (map-hom-sequential-diagram A h n x))
+--         ( ap
+--           ( map-hom-sequential-diagram B g (succ-ℕ n))
+--           ( naturality-map-hom-sequential-diagram A h n x)) ∙
+--       assoc _ _ _
+
+--   htpy-eq-right-whisker-htpy-hom-sequential-diagram :
+--     (p : f ＝ g) (h : hom-sequential-diagram X A) →
+--     htpy-eq-sequential-diagram X B
+--       ( comp-hom-sequential-diagram X A B f h)
+--       ( comp-hom-sequential-diagram X A B g h)
+--       ( ap (λ f → comp-hom-sequential-diagram X A B f h) p) ＝
+--     right-whisker-concat-htpy-hom-sequential-diagram
+--       ( htpy-eq-sequential-diagram A B f g p)
+--       ( h)
+--   htpy-eq-right-whisker-htpy-hom-sequential-diagram refl h =
+--     eq-pair-eq-fiber
+--       ( eq-binary-htpy _ _
+--         λ n x →
+--         inv
+--           ( right-unit ∙
+--             ap-binary
+--               ( λ p q →
+--                 p ∙
+--                 left-whisker-concat _ q ∙
+--                 inv (assoc _ refl _) ∙
+--                 right-whisker-concat _ _)
+--               ( right-unit-law-assoc _ _)
+--               ( inv-nat-refl-htpy _ _) ∙
+--             ap
+--               ( λ p →
+--                 right-unit ∙
+--                 left-whisker-concat _ (inv right-unit) ∙
+--                 left-whisker-concat _ right-unit ∙
+--                 inv p ∙
+--                 right-whisker-concat right-unit _)
+--               ( middle-unit-law-assoc _ _) ∙
+--             is-section-inv-concat'
+--               ( right-whisker-concat right-unit _)
+--               ( right-unit ∙
+--                 left-whisker-concat _ (inv right-unit) ∙
+--                 left-whisker-concat _ right-unit) ∙
+--             ap
+--               ( λ p → right-unit ∙ p ∙ left-whisker-concat _ right-unit)
+--               ( ap-inv (naturality-map-hom-sequential-diagram B f n _ ∙_) right-unit) ∙
+--             is-section-inv-concat'
+--               ( ap (naturality-map-hom-sequential-diagram B f n _ ∙_) right-unit)
+--               ( right-unit)))
+--     where
+--       open import foundation.binary-homotopies
+--       open import foundation.path-algebra
+--       open import foundation.action-on-identifications-binary-functions
+
+--   eq-htpy-right-whisker-htpy-hom-sequential-diagram :
+--     (H : htpy-hom-sequential-diagram B f g) (h : hom-sequential-diagram X A) →
+--     eq-htpy-sequential-diagram X B
+--       ( comp-hom-sequential-diagram X A B f h)
+--       ( comp-hom-sequential-diagram X A B g h)
+--       ( right-whisker-concat-htpy-hom-sequential-diagram H h) ＝
+--     ap
+--       ( λ f → comp-hom-sequential-diagram X A B f h)
+--       ( eq-htpy-sequential-diagram A B f g H)
+--   eq-htpy-right-whisker-htpy-hom-sequential-diagram H h =
+--     ap
+--       ( eq-htpy-sequential-diagram X B _ _)
+--       ( inv
+--         ( htpy-eq-right-whisker-htpy-hom-sequential-diagram
+--             ( eq-htpy-sequential-diagram A B f g H)
+--             ( h) ∙
+--           ap
+--             ( λ H → right-whisker-concat-htpy-hom-sequential-diagram H h)
+--             ( is-section-map-inv-equiv
+--               ( extensionality-hom-sequential-diagram A B f g)
+--               ( H)))) ∙
+--     is-retraction-map-inv-equiv
+--       ( extensionality-hom-sequential-diagram X B
+--         ( comp-hom-sequential-diagram X A B f h)
+--         ( comp-hom-sequential-diagram X A B g h))
+--       ( ap
+--         ( λ f → comp-hom-sequential-diagram X A B f h)
+--         ( eq-htpy-sequential-diagram A B f g H))
+-- ```
+
+-- ### Left whiskering
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 : Level}
+--   {A : sequential-diagram l1} {B : sequential-diagram l2}
+--   {X : sequential-diagram l3}
+--   {f g : hom-sequential-diagram A B}
+--   where
+--   open import foundation.whiskering-identifications-concatenation
+
+--   module _
+--     (h : hom-sequential-diagram B X)
+--     (H : htpy-hom-sequential-diagram B f g)
+--     where
+
+--     left-whisker-concat-htpy-hom-sequential-diagram :
+--       htpy-hom-sequential-diagram X
+--         ( comp-hom-sequential-diagram A B X h f)
+--         ( comp-hom-sequential-diagram A B X h g)
+--     pr1 left-whisker-concat-htpy-hom-sequential-diagram n =
+--       map-hom-sequential-diagram X h n ·l htpy-htpy-hom-sequential-diagram _ H n
+--     pr2 left-whisker-concat-htpy-hom-sequential-diagram n a =
+--       assoc _ _ _ ∙
+--       left-whisker-concat
+--         ( naturality-map-hom-sequential-diagram X h n (map-hom-sequential-diagram B f n a))
+--         ( inv (ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
+--           ap
+--             ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
+--             ( coherence-htpy-htpy-hom-sequential-diagram B H n a) ∙
+--           ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
+--       inv (assoc _ _ _) ∙
+--       right-whisker-concat
+--         ( left-whisker-concat
+--             ( naturality-map-hom-sequential-diagram X h n
+--               ( map-hom-sequential-diagram B f n a))
+--             ( inv
+--               ( ap-comp
+--                 ( map-hom-sequential-diagram X h (succ-ℕ n))
+--                 ( map-sequential-diagram B n)
+--                 ( htpy-htpy-hom-sequential-diagram B H n a))) ∙
+--           nat-htpy
+--             ( naturality-map-hom-sequential-diagram X h n)
+--             ( htpy-htpy-hom-sequential-diagram B H n a) ∙
+--           right-whisker-concat
+--             ( ap-comp
+--               ( map-sequential-diagram X n)
+--               ( map-hom-sequential-diagram X h n)
+--               ( htpy-htpy-hom-sequential-diagram B H n a))
+--             ( naturality-map-hom-sequential-diagram X h n
+--               ( map-hom-sequential-diagram B g n a)))
+--         ( ap
+--           ( map-hom-sequential-diagram X h (succ-ℕ n))
+--           ( naturality-map-hom-sequential-diagram B g n a)) ∙
+--       assoc _ _ _
+
+--   htpy-eq-left-whisker-htpy-hom-sequential-diagram :
+--     (h : hom-sequential-diagram B X) (p : f ＝ g) →
+--     htpy-eq-sequential-diagram A X
+--       ( comp-hom-sequential-diagram A B X h f)
+--       ( comp-hom-sequential-diagram A B X h g)
+--       ( ap (comp-hom-sequential-diagram A B X h) p) ＝
+--     left-whisker-concat-htpy-hom-sequential-diagram h
+--       ( htpy-eq-sequential-diagram A B f g p)
+--   htpy-eq-left-whisker-htpy-hom-sequential-diagram h refl =
+--     eq-pair-eq-fiber
+--       ( eq-binary-htpy _ _
+--         ( λ n a →
+--           inv
+--             ( right-unit ∙
+--               ( ap-binary
+--                 ( λ p q →
+--                   p ∙
+--                   left-whisker-concat
+--                     ( naturality-map-hom-sequential-diagram X h n
+--                       ( map-hom-sequential-diagram B f n a))
+--                     ( inv (ap-concat _ _ refl) ∙
+--                       ap
+--                         ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
+--                         ( right-unit) ∙
+--                       refl) ∙
+--                   q ∙
+--                   right-whisker-concat (right-unit ∙ refl) _)
+--                 ( right-unit-law-assoc _ (ap _ _) ∙
+--                   left-whisker-concat right-unit (ap-inv _ right-unit))
+--                 ( ap inv (middle-unit-law-assoc _ _))) ∙
+--               ( ap-binary
+--                 ( λ p q →
+--                   right-unit ∙
+--                   inv (left-whisker-concat _ right-unit) ∙
+--                   left-whisker-concat _ p ∙
+--                   inv (right-whisker-concat right-unit _) ∙
+--                   right-whisker-concat q _)
+--                 ( right-unit ∙
+--                   right-whisker-concat
+--                     ( ap inv (compute-right-refl-ap-concat _ _) ∙
+--                       distributive-inv-concat
+--                         ( ap (ap _) right-unit)
+--                         ( inv right-unit) ∙
+--                       right-whisker-concat (inv-inv right-unit) _)
+--                     ( ap (ap _) right-unit) ∙
+--                   is-section-inv-concat' (ap (ap _) right-unit) right-unit)
+--                 ( right-unit)) ∙
+--               is-section-inv-concat'
+--                 ( right-whisker-concat right-unit _)
+--                 ( right-unit ∙ inv _ ∙ _) ∙
+--               is-section-inv-concat'
+--                 ( left-whisker-concat _ right-unit)
+--                 ( right-unit))))
+--     where
+--       open import foundation.action-on-identifications-binary-functions
+--       open import foundation.binary-homotopies
+--       open import foundation.path-algebra
+
+--   eq-htpy-left-whisker-htpy-hom-sequential-diagram :
+--     (h : hom-sequential-diagram B X) (H : htpy-hom-sequential-diagram B f g) →
+--     eq-htpy-sequential-diagram A X
+--       ( comp-hom-sequential-diagram A B X h f)
+--       ( comp-hom-sequential-diagram A B X h g)
+--       ( left-whisker-concat-htpy-hom-sequential-diagram h H) ＝
+--     ap
+--       ( comp-hom-sequential-diagram A B X h)
+--       ( eq-htpy-sequential-diagram A B f g H)
+--   eq-htpy-left-whisker-htpy-hom-sequential-diagram h H =
+--     ap
+--       ( eq-htpy-sequential-diagram A X _ _)
+--       ( inv
+--         ( htpy-eq-left-whisker-htpy-hom-sequential-diagram h
+--             ( eq-htpy-sequential-diagram A B f g H) ∙
+--           ap
+--             ( left-whisker-concat-htpy-hom-sequential-diagram h)
+--             ( is-section-map-inv-equiv
+--               ( extensionality-hom-sequential-diagram A B f g)
+--               ( H)))) ∙
+--     is-retraction-map-inv-equiv
+--       ( extensionality-hom-sequential-diagram A X
+--         ( comp-hom-sequential-diagram A B X h f)
+--         ( comp-hom-sequential-diagram A B X h g))
+--       ( ap
+--         ( comp-hom-sequential-diagram A B X h)
+--         ( eq-htpy-sequential-diagram A B f g H))
+-- ```
+
+-- ## Action on homotopies of morphisms of sequential diagrams preserves whiskering
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+--   (up-a : universal-property-sequential-colimit a)
+--   {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
+--   (up-b : universal-property-sequential-colimit b)
+--   {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
+--   {f g : hom-sequential-diagram B C}
+--   where
+
+--   coh-comp-hom-sequential-diagram :
+--     (p : f ＝ g) (h : hom-sequential-diagram A B) →
+--     ap
+--       ( map-sequential-colimit-hom-sequential-diagram up-a c)
+--       ( ap (λ f → comp-hom-sequential-diagram A B C f h) p) ∙
+--     eq-htpy
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h) ＝
+--     eq-htpy
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙
+--     ap
+--       ( _∘ map-sequential-colimit-hom-sequential-diagram up-a b h)
+--       ( ap
+--         ( map-sequential-colimit-hom-sequential-diagram up-b c)
+--         ( p))
+--   coh-comp-hom-sequential-diagram refl h = inv right-unit
+
+--   preserves-right-whisker-htpy-hom-sequential-diagram :
+--     (H : htpy-hom-sequential-diagram C f g)
+--     (h : hom-sequential-diagram A B) →
+--     ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
+--         ( right-whisker-concat-htpy-hom-sequential-diagram H h)) ∙h
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h)) ~
+--     ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙h
+--       ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-b c H ·r
+--         map-sequential-colimit-hom-sequential-diagram up-a b h))
+--   preserves-right-whisker-htpy-hom-sequential-diagram H h =
+--     htpy-eq
+--       ( ( ap
+--           ( λ p →
+--             htpy-eq
+--               ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p) ∙h
+--             preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--               up-a up-b c g h)
+--           ( eq-htpy-right-whisker-htpy-hom-sequential-diagram H h)) ∙
+--         ( inv [i]) ∙
+--         ( ap htpy-eq
+--           ( coh-comp-hom-sequential-diagram
+--             ( eq-htpy-sequential-diagram B C f g H)
+--             ( h))) ∙
+--         ( htpy-eq-concat _ _) ∙
+--         ( ap-binary
+--           ( _∙h_)
+--           ( is-section-eq-htpy
+--             ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--               up-a up-b c f h))
+--            ( htpy-eq-right-whisker
+--              ( ap
+--                ( map-sequential-colimit-hom-sequential-diagram up-b c)
+--                ( eq-htpy-sequential-diagram B C f g H))
+--              ( map-sequential-colimit-hom-sequential-diagram up-a b h))))
+--      where
+--        open import foundation.action-on-identifications-binary-functions
+--        [i] =
+--          htpy-eq-concat
+--            ( ap
+--              ( map-sequential-colimit-hom-sequential-diagram up-a c)
+--              ( ap
+--                ( λ f → comp-hom-sequential-diagram A B C f h)
+--                ( eq-htpy-sequential-diagram B C f g H)))
+--            ( eq-htpy
+--              ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--                up-a up-b c g h)) ∙
+--          ap
+--            ( htpy-eq
+--              ( ap
+--                ( map-sequential-colimit-hom-sequential-diagram up-a c)
+--                ( ap
+--                  ( λ f → comp-hom-sequential-diagram A B C f h)
+--                  ( eq-htpy-sequential-diagram B C f g H))) ∙h_)
+--            ( is-section-eq-htpy
+--              ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--                up-a up-b c g h))
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+--   (up-a : universal-property-sequential-colimit a)
+--   {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
+--   (up-b : universal-property-sequential-colimit b)
+--   {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
+--   (h : hom-sequential-diagram B C)
+--   {f g : hom-sequential-diagram A B}
+--   where
+
+--   coh-comp-hom-sequential-diagram' :
+--     (p : f ＝ g) →
+--     ap
+--       ( map-sequential-colimit-hom-sequential-diagram up-a c)
+--       ( ap (comp-hom-sequential-diagram A B C h) p) ∙
+--     eq-htpy
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g) ＝
+--     eq-htpy
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙
+--     ap
+--       ( map-sequential-colimit-hom-sequential-diagram up-b c h ∘_)
+--       ( ap
+--         ( map-sequential-colimit-hom-sequential-diagram up-a b)
+--         ( p))
+--   coh-comp-hom-sequential-diagram' refl = inv right-unit
+
+--   preserves-left-whisker-htpy-hom-sequential-diagram :
+--     (H : htpy-hom-sequential-diagram B f g) →
+--     ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
+--         ( left-whisker-concat-htpy-hom-sequential-diagram h H)) ∙h
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g)) ~
+--     ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙h
+--       ( map-sequential-colimit-hom-sequential-diagram up-b c h ·l
+--         htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H))
+--   preserves-left-whisker-htpy-hom-sequential-diagram H =
+--     htpy-eq
+--       ( ap-binary
+--           ( λ p q →
+--             htpy-eq
+--               ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p) ∙h
+--             q)
+--           ( eq-htpy-left-whisker-htpy-hom-sequential-diagram h H)
+--           ( inv
+--             ( is-section-eq-htpy
+--               ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--                 up-a up-b c h g))) ∙
+--         inv
+--           ( htpy-eq-concat
+--             ( ap
+--               ( map-sequential-colimit-hom-sequential-diagram up-a c)
+--               ( ap
+--                 ( comp-hom-sequential-diagram A B C h)
+--                 ( eq-htpy-sequential-diagram A B f g H)))
+--             ( eq-htpy
+--               ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--                 up-a up-b c h g))) ∙
+--         ap htpy-eq
+--           ( coh-comp-hom-sequential-diagram'
+--             ( eq-htpy-sequential-diagram A B f g H)) ∙
+--         htpy-eq-concat _ _ ∙
+--         ap-binary _∙h_
+--           ( is-section-eq-htpy
+--             ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--               up-a up-b c h f))
+--           ( htpy-eq-left-whisker
+--             ( map-sequential-colimit-hom-sequential-diagram up-b c h)
+--             ( ap
+--               ( map-sequential-colimit-hom-sequential-diagram up-a b)
+--               ( eq-htpy-sequential-diagram A B f g H))))
+--      where
+--        open import foundation.action-on-identifications-binary-functions
+-- ```
+
+-- ## Action on homotopies of morphisms of sequential diagrams preserves concatenation
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+--   (up-a : universal-property-sequential-colimit a)
+--   {B : sequential-diagram l3} {Y : UU l4} (b : cocone-sequential-diagram B Y)
+--   {f g h : hom-sequential-diagram A B}
+--   (H : htpy-hom-sequential-diagram B f g)
+--   (K : htpy-hom-sequential-diagram B g h)
+--   where
+
+--   preserves-concat-htpy-hom-sequential-diagram :
+--     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b
+--       ( concat-htpy-hom-sequential-diagram f g h H K) ~
+--     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H ∙h
+--     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b K
+--   preserves-concat-htpy-hom-sequential-diagram =
+--     htpy-eq
+--       ( ( ap
+--           ( λ p →
+--             htpy-eq
+--               ( ap
+--                 ( map-sequential-colimit-hom-sequential-diagram up-a b)
+--                 ( p)))
+--           ( eq-htpy-concat-hom-sequential-diagram f g h H K)) ∙
+--         ( ap htpy-eq
+--           ( ap-concat
+--             ( map-sequential-colimit-hom-sequential-diagram up-a b)
+--             ( eq-htpy-sequential-diagram A B f g H)
+--             ( eq-htpy-sequential-diagram A B g h K))) ∙
+--         ( htpy-eq-concat
+--           ( ap
+--             ( map-sequential-colimit-hom-sequential-diagram up-a b)
+--             ( eq-htpy-sequential-diagram A B f g H))
+--           ( ap
+--             ( map-sequential-colimit-hom-sequential-diagram up-a b)
+--             ( eq-htpy-sequential-diagram A B g h K))))
+-- ```
+
+-- ## Action on homotopies of morphisms of sequential diagrams preserves associativity
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+--   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
+--   (up-a : universal-property-sequential-colimit a)
+--   {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
+--   (up-b : universal-property-sequential-colimit b)
+--   {C : sequential-diagram l5} {Z : UU l6} {c : cocone-sequential-diagram C Z}
+--   (up-c : universal-property-sequential-colimit c)
+--   {D : sequential-diagram l7} {V : UU l8} (d : cocone-sequential-diagram D V)
+--   (f : hom-sequential-diagram A B) (g : hom-sequential-diagram B C)
+--   (h : hom-sequential-diagram C D)
+--   where
+
+--   coh-assoc-comp-hom-sequential-diagram :
+--     {!!}
+--   coh-assoc-comp-hom-sequential-diagram = {!!}
+
+--   preserves-assoc-comp-hom-sequential-diagram :
+--     ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a d
+--         ( assoc-comp-hom-sequential-diagram f g h)) ∙h
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-c d h
+--         ( comp-hom-sequential-diagram A B C g f)) ∙h
+--       ( map-sequential-colimit-hom-sequential-diagram up-c d h ·l
+--         preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--           up-a up-b c g f)) ~
+--     ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b d
+--         ( comp-hom-sequential-diagram B C D h g)
+--         ( f)) ∙h
+--       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
+--           up-b up-c d h g ·r
+--         map-sequential-colimit-hom-sequential-diagram up-a b f))
+--   preserves-assoc-comp-hom-sequential-diagram =
+--     {!!}
+-- ```
+
+-- ```agda
+-- nat-lemma :
+--   {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
+--   {P : A → UU l3} {Q : B → UU l4}
+--   (f : A → B) (h : (a : A) → P a → Q (f a))
+--   {x y : A} {p : x ＝ y}
+--   {q : f x ＝ f y} (α : ap f p ＝ q) →
+--   coherence-square-maps
+--     ( tr P p)
+--     ( h x)
+--     ( h y)
+--     ( tr Q q)
+-- nat-lemma f h {p = p} refl x =
+--   substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
+-- ```
+
+-- ##
+
+-- ```agda
+-- open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
+-- open import synthetic-homotopy-theory.total-cocones-families-sequential-diagrams
+-- open import synthetic-homotopy-theory.total-sequential-diagrams
+
+-- open import foundation.action-on-identifications-functions
+-- open import foundation.commuting-squares-of-identifications
+-- open import foundation.functoriality-dependent-pair-types
+-- open import foundation.equality-dependent-pair-types
+-- open import foundation.identity-types
+-- open import synthetic-homotopy-theory.sequential-colimits
+-- open import synthetic-homotopy-theory.functoriality-sequential-colimits
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : sequential-diagram l1}
+--   {X : UU l2} {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   (P : family-with-descent-data-sequential-colimit c l3)
+--   {Y : UU l4}
+--   {c' :
+--     cocone-sequential-diagram
+--       ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
+--       ( Y)}
+--   (up-c' : universal-property-sequential-colimit c')
+--   where
+
+--   mediating-cocone :
+--     cocone-sequential-diagram
+--       ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
+--       ( Σ X (family-cocone-family-with-descent-data-sequential-colimit P))
+--   pr1 mediating-cocone n =
+--     map-Σ
+--       ( family-cocone-family-with-descent-data-sequential-colimit P)
+--       ( map-cocone-sequential-diagram c n)
+--       ( λ a → map-equiv-descent-data-family-with-descent-data-sequential-colimit P n a)
+--   pr2 mediating-cocone n (a , p) =
+--     eq-pair-Σ
+--       ( coherence-cocone-sequential-diagram c n a)
+--       ( inv
+--         ( coherence-square-equiv-descent-data-family-with-descent-data-sequential-colimit P n a p))
+
+--   totι' : Y → Σ X (family-cocone-family-with-descent-data-sequential-colimit P)
+--   totι' =
+--     map-universal-property-sequential-colimit up-c' mediating-cocone
+--   triangle-pr1∞-pr1 :
+--     pr1-sequential-colimit-total-sequential-diagram
+--       ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)
+--       ( up-c')
+--       ( c) ~
+--     pr1 ∘ totι'
+--   triangle-pr1∞-pr1 =
+--     htpy-htpy-out-of-sequential-colimit up-c'
+--       ( concat-htpy-cocone-sequential-diagram
+--         ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c' c
+--           ( pr1-total-sequential-diagram
+--             ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)))
+--         ( ( λ n →
+--             inv-htpy (pr1 ·l (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n))) ,
+--           ( λ n x →
+--             ap (_∙ inv (ap pr1 (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))) right-unit ∙
+--             horizontal-inv-coherence-square-identifications _
+--               ( ap (pr1 ∘ totι') (coherence-cocone-sequential-diagram c' n x))
+--               ( coherence-cocone-sequential-diagram c n (pr1 x))
+--               _
+--               ( ( ap
+--                   ( _∙ ap pr1
+--                     ( pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))
+--                   ( ap-comp pr1
+--                     ( totι')
+--                     ( coherence-cocone-sequential-diagram c' n x))) ∙
+--                 ( inv
+--                   ( ap-concat pr1
+--                     ( ap
+--                       ( totι')
+--                       ( coherence-cocone-sequential-diagram c' n x)) _)) ∙
+--                 ( ap (ap pr1) (pr2 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n x)) ∙
+--                 ( ap-concat pr1
+--                   ( pr1
+--                     ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
+--                     n x)
+--                   ( coherence-cocone-sequential-diagram mediating-cocone n x)) ∙
+--                 ( ap
+--                   ( ap pr1
+--                     ( pr1
+--                       ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
+--                       n x) ∙_)
+--                   ( ap-pr1-eq-pair-Σ
+--                     ( coherence-cocone-sequential-diagram c n (pr1 x))
+--                     ( _)))))))
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : sequential-diagram l1} {X : UU l2}
+--   {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   {B : sequential-diagram l3} {Y : UU l4}
+--   {c' : cocone-sequential-diagram B Y}
+--   (up-c' : universal-property-sequential-colimit c')
+--   (P : X → UU l5) (Q : Y → UU l6)
+--   (f : hom-sequential-diagram A B)
+--   (f' :
+--     (x : X) → P x →
+--     Q (map-sequential-colimit-hom-sequential-diagram up-c c' f x))
+--   where
+
+--   open import synthetic-homotopy-theory.flattening-lemma-sequential-colimits
+
+--   ΣAP : sequential-diagram (l1 ⊔ l5)
+--   ΣAP =
+--     total-sequential-diagram (dependent-sequential-diagram-family-cocone c P)
+
+--   ΣBQ : sequential-diagram (l3 ⊔ l6)
+--   ΣBQ =
+--     total-sequential-diagram (dependent-sequential-diagram-family-cocone c' Q)
+
+--   private
+--     finf : X → Y
+--     finf = (map-sequential-colimit-hom-sequential-diagram up-c c' f)
+
+--   totff' : hom-sequential-diagram ΣAP ΣBQ
+--   pr1 totff' n =
+--     map-Σ _
+--       ( map-hom-sequential-diagram B f n)
+--       ( λ a →
+--         tr Q
+--           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--             up-c c' f n a) ∘
+--         f' (map-cocone-sequential-diagram c n a))
+--   pr2 totff' n (a , p) =
+--     eq-pair-Σ
+--       ( naturality-map-hom-sequential-diagram B f n a)
+--       ((pasting-vertical-coherence-square-maps
+--       ( tr P (coherence-cocone-sequential-diagram c n a))
+--       ( f' _)
+--       ( f' _)
+--       ( tr Q (ap finf (coherence-cocone-sequential-diagram c n a)))
+--       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
+--       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
+--       ( ( tr
+--           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--           ( naturality-map-hom-sequential-diagram B f n a)) ∘
+--         ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
+--       ( λ q →
+--         substitution-law-tr Q finf (coherence-cocone-sequential-diagram c n a) ∙
+--         inv (preserves-tr f' (coherence-cocone-sequential-diagram c n a) q))
+--       ( ( inv-htpy
+--           ( λ q →
+--             ( tr-concat
+--               ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                 up-c c' f n a)
+--               ( _)
+--               ( q)) ∙
+--             ( tr-concat
+--               ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+--               ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
+--               ( tr Q
+--                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                   up-c c' f n a)
+--                 ( q))) ∙
+--             ( substitution-law-tr Q
+--               ( map-cocone-sequential-diagram c' (succ-ℕ n))
+--               ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
+--         ( λ q →
+--           ap
+--             ( λ p → tr Q p q)
+--             ( inv
+--               ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
+--         ( tr-concat
+--           ( ap finf (coherence-cocone-sequential-diagram c n a))
+--           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--             up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))) p)
+
+
+--   totff'∞ : Σ X P → Σ Y Q
+--   totff'∞ =
+--     map-sequential-colimit-hom-sequential-diagram
+--       ( flattening-lemma-sequential-colimit _ P up-c)
+--       ( total-cocone-family-cocone-sequential-diagram c' Q)
+--       ( totff')
+
+--   pr1A∙ : hom-sequential-diagram ΣAP A
+--   pr1A∙ =
+--     pr1-total-sequential-diagram
+--       ( dependent-sequential-diagram-family-cocone c P)
+--   pr1B∙ : hom-sequential-diagram ΣBQ B
+--   pr1B∙ =
+--     pr1-total-sequential-diagram
+--       ( dependent-sequential-diagram-family-cocone c' Q)
+
+--   pr1∘totff' : hom-sequential-diagram ΣAP B
+--   pr1∘totff' = comp-hom-sequential-diagram ΣAP ΣBQ B pr1B∙ totff'
+--   f∘pr1 : hom-sequential-diagram ΣAP B
+--   f∘pr1 = comp-hom-sequential-diagram ΣAP A B f pr1A∙
+
+--   pr1coh∙ : htpy-hom-sequential-diagram B f∘pr1 pr1∘totff'
+--   pr1 pr1coh∙ n =
+--     refl-htpy
+--   pr2 pr1coh∙ n =
+--     right-unit-htpy ∙h
+--     right-unit-htpy ∙h
+--     ( λ x →
+--       inv
+--         ( ap-pr1-eq-pair-Σ
+--           ( naturality-map-hom-sequential-diagram B f n (pr1 x))
+--           ( _)))
+
+--   module _
+--     (sA :
+--       section-descent-data-sequential-colimit
+--         ( descent-data-family-cocone-sequential-diagram c P))
+--     (sB :
+--       section-descent-data-sequential-colimit
+--         ( descent-data-family-cocone-sequential-diagram c' Q))
+--     where
+--     open import foundation.sections
+
+--     -- vertical maps, the "sides" of the cubes
+--     sA∙ : hom-sequential-diagram A ΣAP
+--     pr1 sA∙ n = map-section-family (pr1 sA n)
+--     pr2 sA∙ n a = eq-pair-eq-fiber (pr2 sA n a)
+--     sB∙ : hom-sequential-diagram B ΣBQ
+--     pr1 sB∙ n = map-section-family (pr1 sB n)
+--     pr2 sB∙ n b = eq-pair-eq-fiber (pr2 sB n b)
+--     totff'∘sA∙ : hom-sequential-diagram A ΣBQ
+--     totff'∘sA∙ = comp-hom-sequential-diagram A ΣAP ΣBQ totff' sA∙
+--     sB∙∘f : hom-sequential-diagram A ΣBQ
+--     sB∙∘f = comp-hom-sequential-diagram A B ΣBQ sB∙ f
+--     -- the unaligned cubes
+--     H∙ :
+--       htpy-hom-sequential-diagram ΣBQ totff'∘sA∙ sB∙∘f
+--     pr1 H∙ n a = eq-pair-eq-fiber {!!}
+--     pr2 H∙ = {!!}
+
+--     pr1∙∘sA∙ : hom-sequential-diagram A A
+--     pr1∙∘sA∙ = comp-hom-sequential-diagram A ΣAP A pr1A∙ sA∙
+
+--     idA∙ : hom-sequential-diagram A A
+--     idA∙ = id-hom-sequential-diagram A
+--     idB∙ : hom-sequential-diagram B B
+--     idB∙ = id-hom-sequential-diagram B
+--     f∘idA∙ : hom-sequential-diagram A B
+--     f∘idA∙ = comp-hom-sequential-diagram A A B f idA∙
+--     idB∙∘f : hom-sequential-diagram A B
+--     idB∙∘f = comp-hom-sequential-diagram A B B idB∙ f
+--     refl∙ : htpy-hom-sequential-diagram B f∘idA∙ idB∙∘f
+--     pr1 refl∙ = ev-pair refl-htpy
+--     pr2 refl∙ n a =
+--       right-unit ∙
+--       right-unit ∙
+--       inv (ap-id (naturality-map-hom-sequential-diagram B f n a))
+--     -- the alignment: postcomposing H∙ with pr1coh∙ is homotopic with id
+--     ℋ :
+--       {!htpy²-hom-sequential-diagram!}
+--     ℋ = {!!}
+
+--   _ :
+--     totι' up-c
+--       ( family-with-descent-data-family-cocone-sequential-diagram c P)
+--       ( flattening-lemma-sequential-colimit c P up-c) ~
+--     id
+--   _ =
+--     compute-map-universal-property-sequential-colimit-id
+--       ( flattening-lemma-sequential-colimit _ P up-c)
+
+--   _ :
+--     coherence-square-maps
+--       ( totι' up-c
+--         ( family-with-descent-data-family-cocone-sequential-diagram c P)
+--         ( flattening-lemma-sequential-colimit c P up-c))
+--       ( totff'∞)
+--       ( map-Σ Q
+--         ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--         f')
+--       ( totι' up-c'
+--         ( family-with-descent-data-family-cocone-sequential-diagram c' Q)
+--         ( flattening-lemma-sequential-colimit c' Q up-c'))
+--   _ =
+--     ( compute-map-universal-property-sequential-colimit-id
+--       ( flattening-lemma-sequential-colimit c' Q up-c') ·r _) ∙h
+--     ( htpy-htpy-out-of-sequential-colimit
+--       ( flattening-lemma-sequential-colimit c P up-c)
+--       ( concat-htpy-cocone-sequential-diagram
+--         ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--           ( flattening-lemma-sequential-colimit c P up-c)
+--           ( total-cocone-family-cocone-sequential-diagram c' Q)
+--           ( totff'))
+--         ( ( λ n (a , p) →
+--             inv
+--               ( eq-pair-Σ
+--                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
+--                   ( f)
+--                   ( n)
+--                   ( a))
+--                 refl)) ,
+--           {!!}))) ∙h
+--     ( _ ·l
+--       ( inv-htpy
+--         (compute-map-universal-property-sequential-colimit-id
+--           ( flattening-lemma-sequential-colimit c P up-c))))
+
+--     -- htpy-htpy-out-of-sequential-colimit
+--     --   ( flattening-lemma-sequential-colimit c P up-c)
+--     --   ( {!!})
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : sequential-diagram l1} {X : UU l2}
+--   {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   {B : sequential-diagram l3} {Y : UU l4}
+--   {c' : cocone-sequential-diagram B Y}
+--   (up-c' : universal-property-sequential-colimit c')
+--   (f : hom-sequential-diagram A B)
+--   where
+--   open import foundation.homotopies-morphisms-arrows
+
+--   interm :
+--     coherence-square-maps
+--       ( id)
+--       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--       ( id)
+--   interm =
+--     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-c c'
+--       ( refl-htpy-hom-sequential-diagram A B f)
+
+--   preserves-refl-htpy-sequential-colimit :
+--     htpy-hom-arrow
+--       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
+--       ( id , id , interm)
+--       ( id , id , refl-htpy)
+--   pr1 preserves-refl-htpy-sequential-colimit = refl-htpy
+--   pr1 (pr2 preserves-refl-htpy-sequential-colimit) = refl-htpy
+--   pr2 (pr2 preserves-refl-htpy-sequential-colimit) =
+--     right-unit-htpy ∙h
+--     htpy-eq
+--       ( ap
+--         ( htpy-eq ∘ ap (map-sequential-colimit-hom-sequential-diagram up-c c'))
+--         ( is-retraction-map-inv-equiv
+--           ( extensionality-hom-sequential-diagram A B f f)
+--           ( refl)))
+-- ```
+
+-- ```agda
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : sequential-diagram l1}
+--   (B : sequential-diagram l2)
+--   (f : hom-sequential-diagram A B)
+--   (P : descent-data-sequential-colimit A l3)
+--   (Q : descent-data-sequential-colimit B l4)
+--   where
+
+--   hom-over-hom : UU (l1 ⊔ l3 ⊔ l4)
+--   hom-over-hom =
+--     Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
+--         family-descent-data-sequential-colimit P n a →
+--         family-descent-data-sequential-colimit Q n
+--           ( map-hom-sequential-diagram B f n a))
+--       ( λ f'n →
+--         (n : ℕ) →
+--         square-over
+--           { Q4 = family-descent-data-sequential-colimit Q (succ-ℕ n)}
+--           ( map-sequential-diagram A n)
+--           ( map-hom-sequential-diagram B f n)
+--           ( map-hom-sequential-diagram B f (succ-ℕ n))
+--           ( map-sequential-diagram B n)
+--           ( λ {a} → map-family-descent-data-sequential-colimit P n a)
+--           ( λ {a} → f'n n a)
+--           ( λ {a} → f'n (succ-ℕ n) a)
+--           ( λ {a} → map-family-descent-data-sequential-colimit Q n a)
+--           ( naturality-map-hom-sequential-diagram B f n))
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : sequential-diagram l1} {X : UU l2}
+--   {c : cocone-sequential-diagram A X}
+--   (up-c : universal-property-sequential-colimit c)
+--   {B : sequential-diagram l3} {Y : UU l4}
+--   {c' : cocone-sequential-diagram B Y}
+--   (up-c' : universal-property-sequential-colimit c')
+--   (f : hom-sequential-diagram A B)
+--   (P : X → UU l5) (Q : Y → UU l6)
+--   where
+
+--   private
+--     f∞ : X → Y
+--     f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f
+--     DDMO : descent-data-sequential-colimit A (l5 ⊔ l6)
+--     pr1 DDMO n a =
+--       P (map-cocone-sequential-diagram c n a) →
+--       Q (map-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+--     pr2 DDMO n a =
+--       ( equiv-postcomp _
+--         ( ( equiv-tr
+--             ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--             ( naturality-map-hom-sequential-diagram B f n a)) ∘e
+--           ( equiv-tr Q (coherence-cocone-sequential-diagram c' n _)))) ∘e
+--       ( equiv-precomp
+--         ( inv-equiv (equiv-tr P (coherence-cocone-sequential-diagram c n a)))
+--         ( _))
+
+--   sect-over-DDMO-map-over :
+--     ((a : X) → P a → Q (f∞ a)) →
+--     section-descent-data-sequential-colimit DDMO
+--   pr1 (sect-over-DDMO-map-over f∞') n a =
+--     ( tr Q
+--       ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
+--     ( f∞' (map-cocone-sequential-diagram c n a))
+--   pr2 (sect-over-DDMO-map-over f∞') n a =
+--     eq-htpy
+--       ( λ p →
+--         {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a!})
+
+--   sect-over-DDMO-map-over' :
+--     ((a : X) → P a → Q (f∞ a)) →
+--     section-descent-data-sequential-colimit DDMO
+--   sect-over-DDMO-map-over' =
+--     {!sect-family-sect-dd-sequential-colimit!}
+
+--   map-over-sect-DDMO :
+--     section-descent-data-sequential-colimit DDMO →
+--     hom-over-hom B f
+--       ( descent-data-family-cocone-sequential-diagram c P)
+--       ( descent-data-family-cocone-sequential-diagram c' Q)
+--   map-over-sect-DDMO =
+--     tot
+--       ( λ s →
+--         map-Π
+--           ( λ n →
+--             ( map-implicit-Π
+--               ( λ a →
+--                 ( concat-htpy
+--                   ( inv-htpy
+--                     ( ( ( tr
+--                           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--                           ( naturality-map-hom-sequential-diagram B f n a)) ∘
+--                         ( tr Q
+--                           ( coherence-cocone-sequential-diagram c' n
+--                             (map-hom-sequential-diagram B f n a))) ∘
+--                         ( s n a)) ·l
+--                       ( is-retraction-inv-tr P
+--                         ( coherence-cocone-sequential-diagram c n a))))
+--                   ( _)) ∘
+--                 ( map-equiv
+--                   ( equiv-htpy-precomp-htpy-Π _ _
+--                     ( equiv-tr P
+--                       ( coherence-cocone-sequential-diagram c n a)))) ∘
+--                 ( htpy-eq
+--                   {f =
+--                     ( tr
+--                       ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--                       ( naturality-map-hom-sequential-diagram B f n a)) ∘
+--                     ( tr Q
+--                       ( coherence-cocone-sequential-diagram c' n
+--                         ( map-hom-sequential-diagram B f n a))) ∘
+--                     ( s n a) ∘
+--                     ( tr P (inv (coherence-cocone-sequential-diagram c n a)))}
+--                   { s (succ-ℕ n) (map-sequential-diagram A n a)}))) ∘
+--             ( implicit-explicit-Π)))
+
+--   map-over-diagram-map-over-colimit :
+--     ((a : X) → P a → Q (f∞ a)) →
+--     hom-over-hom B f
+--       ( descent-data-family-cocone-sequential-diagram c P)
+--       ( descent-data-family-cocone-sequential-diagram c' Q)
+--   pr1 (map-over-diagram-map-over-colimit f∞') n a =
+--     ( tr Q
+--       ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
+--     ( f∞' (map-cocone-sequential-diagram c n a))
+--   pr2 (map-over-diagram-map-over-colimit f∞') n {a} =
+--     pasting-vertical-coherence-square-maps
+--       ( tr P (coherence-cocone-sequential-diagram c n a))
+--       ( f∞' _)
+--       ( f∞' _)
+--       ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
+--       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
+--       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
+--       ( ( tr
+--           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+--           ( naturality-map-hom-sequential-diagram B f n a)) ∘
+--         ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
+--       ( λ q →
+--         substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
+--         inv (preserves-tr f∞' (coherence-cocone-sequential-diagram c n a) q))
+--       ( ( inv-htpy
+--           ( λ q →
+--             ( tr-concat
+--               ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                 up-c c' f n a)
+--               ( _)
+--               ( q)) ∙
+--             ( tr-concat
+--               ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+--               ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
+--               ( tr Q
+--                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--                   up-c c' f n a)
+--                 ( q))) ∙
+--             ( substitution-law-tr Q
+--               ( map-cocone-sequential-diagram c' (succ-ℕ n))
+--               ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
+--         ( λ q →
+--           ap
+--             ( λ p → tr Q p q)
+--             ( inv
+--               ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
+--         ( tr-concat
+--           ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+--           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+--             up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))
+
+--   abstract
+--     triangle-map-over-sect-DDMO :
+--       coherence-triangle-maps
+--         ( map-over-diagram-map-over-colimit)
+--         ( map-over-sect-DDMO)
+--         ( sect-over-DDMO-map-over)
+--     triangle-map-over-sect-DDMO f∞' =
+--       eq-pair-eq-fiber
+--         ( eq-htpy
+--           ( λ n →
+--             eq-htpy-implicit
+--               ( λ a →
+--                 eq-htpy
+--                   ( λ p →
+--                     {!!}))))
+
+--     is-equiv-map-over-sect-DDMO :
+--       is-equiv map-over-sect-DDMO
+--     is-equiv-map-over-sect-DDMO =
+--       is-equiv-tot-is-fiberwise-equiv
+--         ( λ s →
+--           is-equiv-map-Π-is-fiberwise-equiv
+--             ( λ n →
+--               is-equiv-comp _ _
+--                 ( is-equiv-implicit-explicit-Π)
+--                 ( is-equiv-map-implicit-Π-is-fiberwise-equiv
+--                   ( λ a →
+--                     is-equiv-comp _ _
+--                       ( funext _ _)
+--                       ( is-equiv-comp _ _
+--                         ( is-equiv-map-equiv (equiv-htpy-precomp-htpy-Π _ _ _))
+--                         ( is-equiv-concat-htpy _ _))))))
+
+--     is-equiv-map-over-diagram-map-over-colimit :
+--       is-equiv map-over-diagram-map-over-colimit
+--     is-equiv-map-over-diagram-map-over-colimit =
+--       {!is-equiv-left-map-triangle
+--         ( map-over-diagram-map-over-colimit)
+--         ( map-over-sect-DDMO)
+--         ( sect-over-DDMO-map-over)
+--         ( triangle-map-over-sect-DDMO)
+--         ( is-equiv) !}
+-- ```
+
+NB: apd sB∞ (Cn n a) ≠ apd sB∞ (κ n a)!!!
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : UU l2}
+  (e : A ≃ B)
+  where
+
+  unap-square' :
+    {x y : A} (p : x ＝ y) →
+    (is-retraction-map-inv-equiv e x) ∙ map-equiv (inv-equiv-ap-emb (emb-equiv e)) (ap (map-equiv e) p) ＝
+    ap (map-inv-equiv e) (ap (map-equiv e) p) ∙ is-retraction-map-inv-equiv e y
+  unap-square' {x} {y} p =
+    ap
+      ( is-retraction-map-inv-equiv e x ∙_)
+      ( is-retraction-map-inv-equiv (equiv-ap e x y) p ∙ inv (ap-id p)) ∙
+    nat-htpy
+      ( is-retraction-map-inv-equiv e)
+      ( p) ∙
+    ap
+      ( _∙ is-retraction-map-inv-equiv e y)
+      ( ap-comp (map-inv-equiv e) (map-equiv e) p)
+
+  unap-square :
+    {x y : A} (p : map-equiv e x ＝ map-equiv e y) →
+    is-retraction-map-inv-equiv e x ∙ map-equiv (inv-equiv-ap-emb (emb-equiv e)) p ＝
+    ap (map-inv-equiv e) p ∙ is-retraction-map-inv-equiv e y
+  unap-square {x} {y} p =
+    ap
+      ( λ p →
+        is-retraction-map-inv-equiv e x ∙
+        map-equiv (inv-equiv-ap-emb (emb-equiv e)) p)
+      ( inv (is-section-map-inv-equiv (equiv-ap e x y) p)) ∙
+    unap-square'
+      ( map-equiv (inv-equiv-ap-emb (emb-equiv e)) p) ∙
+    ap
+      ( λ p →
+        ap (map-inv-equiv e) p ∙
+        is-retraction-map-inv-equiv e y)
+      ( is-section-map-inv-equiv (equiv-ap e x y) p)
+```

From 00dc1731bc836d6007adfd28dc81e01de47155bc Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 5 Mar 2025 20:24:13 +0100
Subject: [PATCH 24/33] Flipping homs of vertical arrows

---
 .../functoriality-stuff.lagda.md              | 461 ++++++++++++++++--
 1 file changed, 408 insertions(+), 53 deletions(-)

diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index 56975dc874..1d25dbd245 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -426,6 +426,281 @@ module _
     map-equiv (equiv-htpy-section-out-of-sequential-colimit s t)
 ```
 
+```agda
+module _
+  {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
+  (s : (a : A) → B a) (t : (a : A) → C a)
+  (e : (a : A) → B a ≃ C a)
+  (H : (a : A) → map-equiv (e a) (s a) ＝ t a)
+  where
+  open import foundation.action-on-identifications-binary-functions
+
+  invert-fiberwise-triangle : (a : A) → s a ＝ map-inv-equiv (e a) (t a)
+  invert-fiberwise-triangle a =
+    inv (is-retraction-map-inv-equiv (e a) (s a)) ∙
+    ap (map-inv-equiv (e a)) (H a)
+
+  invert-fiberwise-triangle' : (a : A) → map-inv-equiv (e a) (t a) ＝ s a
+  invert-fiberwise-triangle' a =
+    ap (map-inv-equiv (e a)) (inv (H a)) ∙
+    is-retraction-map-inv-equiv (e a) (s a)
+
+  compute-inv-invert-fiberwise-triangle :
+    (a : A) →
+    inv (invert-fiberwise-triangle a) ＝
+    invert-fiberwise-triangle' a
+  compute-inv-invert-fiberwise-triangle a =
+    distributive-inv-concat
+      ( inv (is-retraction-map-inv-equiv (e a) (s a)))
+      ( ap (map-inv-equiv (e a)) (H a)) ∙
+    ap-binary (_∙_)
+      ( inv (ap-inv (map-inv-equiv (e a)) (H a)))
+      ( inv-inv (is-retraction-map-inv-equiv (e a) (s a)))
+
+  compute-inv-invert-fiberwise-triangle' :
+    (a : A) →
+    inv (invert-fiberwise-triangle' a) ＝
+    invert-fiberwise-triangle a
+  compute-inv-invert-fiberwise-triangle' a =
+    distributive-inv-concat
+      ( ap (map-inv-equiv (e a)) (inv (H a)))
+      ( is-retraction-map-inv-equiv (e a) (s a)) ∙
+    ap
+      ( inv (is-retraction-map-inv-equiv (e a) (s a)) ∙_)
+      ( ap inv (ap-inv (map-inv-equiv (e a)) (H a)) ∙ inv-inv _)
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2}
+  {P : A → UU l3} {Q : B → UU l4} {P' : A → UU l5} {Q' : B → UU l6}
+  (f : A → B)
+  (s : (a : A) → P a) (t : (b : B) → Q b)
+  (s' : (a : A) → P' a) (t' : (b : B) → Q' b)
+  (f' : {a : A} → P a → Q (f a))
+  (f'' : {a : A} → P' a → Q' (f a))
+  (e : {a : A} → P a ≃ P' a)
+  (let g = λ {a} → map-equiv (e {a}))
+  (let inv-g = λ {a} → map-inv-equiv (e {a}))
+  (j : {b : B} → Q b ≃ Q' b)
+  (let h = λ {b} → map-equiv (j {b}))
+  (let inv-h = λ {b} → map-inv-equiv (j {b}))
+  (T : (a : A) → f' (s a) ＝ t (f a))
+  (G : {a : A} (p : P a) → f'' (g p) ＝ h (f' p))
+  (let
+    inv-G =
+      λ {a} (p : P' a) →
+        vertical-inv-equiv-coherence-square-maps f' e j f'' G p)
+  (F : (b : B) → h (t b) ＝ t' b)
+  (let inv-F = invert-fiberwise-triangle t t' (λ b → j {b}) F)
+  (let inv-F' = invert-fiberwise-triangle' t t' (λ b → j {b}) F)
+  (H : (a : A) → g (s a) ＝ s' a)
+  (let inv-H = invert-fiberwise-triangle s s' (λ a → e {a}) H)
+  -- (X : (a : A) → f'' (g (s a)) ＝ t' (f a))
+  (X : (a : A) → f'' (s' a) ＝ t' (f a))
+  -- (α : (a : A) → G (s a) ∙ (ap h (T a) ∙ F (f a)) ＝ X a)
+  (α : (a : A) → G (s a) ∙ (ap h (T a) ∙ F (f a)) ＝ ap f'' (H a) ∙ X a)
+  where
+
+  opaque
+    transpose-sq :
+      (a : A) →
+      T a ∙ inv-F (f a) ＝
+      ap f' (inv-H a) ∙
+      ( inv-G (s' a) ∙
+        ap inv-h (X a))
+    transpose-sq a =
+      ap
+        ( T a ∙_)
+        ( inv (compute-inv-invert-fiberwise-triangle' t t' (λ b → j {b}) F (f a))) ∙
+      right-transpose-eq-concat'
+        ( T a)
+        ( _)
+        ( inv-F' (f a))
+        ( [g])
+      where
+      [i] :
+        ap f' (is-retraction-map-inv-equiv e (s a)) ＝
+        ( pasting-vertical-coherence-square-maps f' g h f'' inv-g inv-h f'
+            G inv-G (s a) ∙
+          is-retraction-map-inv-equiv j (f' (s a)))
+      [i] =
+        inv right-unit ∙
+        left-inverse-law-pasting-vertical-coherence-square-maps f' e j f'' G (s a)
+      [a] :
+        ap inv-h (G (s a) ∙ (ap h (T a) ∙ F (f a))) ＝
+        ap inv-h (ap f'' (H a) ∙ X a)
+      [a] = ap (ap inv-h) (α a)
+      [b] : ap inv-h (G (s a)) ∙
+            ap inv-h (ap h (T a) ∙ F (f a)) ＝
+            ap inv-h (ap f'' (H a) ∙ X a)
+      [b] = inv (ap-concat inv-h (G (s a)) (ap h (T a) ∙ F (f a))) ∙ [a]
+      [c] :
+        ap inv-h (G (s a)) ∙
+        ( ap (inv-h ∘ h) (T a) ∙ ap inv-h (F (f a))) ＝
+        ap inv-h (ap f'' (H a) ∙ X a)
+      [c] =
+        ap
+          ( ap inv-h (G (s a)) ∙_)
+          ( ap (_∙ ap inv-h (F (f a))) (ap-comp inv-h h (T a)) ∙
+            inv (ap-concat inv-h (ap h (T a)) (F (f a)))) ∙
+        [b]
+      [d] :
+        pasting-vertical-coherence-square-maps f' g h f'' inv-g inv-h f' G inv-G (s a) ∙
+        ( ap (inv-h ∘ h) (T a) ∙ ap inv-h (F (f a))) ＝
+        inv-G (g (s a)) ∙ ap inv-h (ap f'' (H a) ∙ X a)
+      [d] = assoc _ _ _ ∙ ap (inv-G (g (s a)) ∙_) [c]
+      [f'] :
+        inv-G (g (s a)) ∙
+        ap inv-h (ap f'' (H a)) ＝
+        ap f' (ap inv-g (H a)) ∙
+        inv-G (s' a)
+      [f'] =
+        nat-coherence-square-maps f'' inv-g inv-h f' inv-G (H a)
+      [e] :
+        ap f' (is-retraction-map-inv-equiv e (s a)) ＝
+        ap f' (ap inv-g (H a)) ∙
+        inv-G (s' a) ∙
+        ap inv-h (X a) ∙
+        ap inv-h (inv (F (f a))) ∙
+        inv (ap (inv-h ∘ h) (T a)) ∙
+        is-retraction-map-inv-equiv j (f' (s a))
+      [e] =
+        [i] ∙
+        ap
+          ( _∙ is-retraction-map-inv-equiv j (f' (s a)))
+          ( right-transpose-eq-concat _ _ _ [d] ∙
+            ( ( ap
+                ( _ ∙_)
+                ( ( distributive-inv-concat
+                    ( ap (inv-h ∘ h) (T a))
+                    ( ap inv-h (F (f a)))) ∙
+                  ( ap (_∙ _) (inv (ap-inv inv-h (F (f a))))))) ∙
+              ( inv (assoc _ _ _)) ∙
+              ( ap
+                ( λ p → p ∙ _ ∙ _)
+                ( ap (_ ∙_) (ap-concat inv-h (ap f'' (H a)) (X a)) ∙
+                  inv (assoc _ _ _) ∙
+                  ap (_∙ ap inv-h (X a)) [f']))))
+      [f] :
+        inv (ap (inv-h ∘ h) (T a)) ∙
+        is-retraction-map-inv-equiv j (f' (s a)) ＝
+        is-retraction-map-inv-equiv j (t (f a)) ∙ inv (T a)
+      [f] =
+        inv
+          ( nat-htpy (is-retraction-map-inv-equiv j) (inv (T a)) ∙
+            ap (_∙ is-retraction-map-inv-equiv j (f' (s a))) (ap-inv (inv-h ∘ h) (T a))) ∙
+        ap
+          ( is-retraction-map-inv-equiv j (t (f a)) ∙_)
+          ( ap-id (inv (T a)))
+      open import foundation.commuting-squares-of-identifications
+      open import foundation.commuting-triangles-of-identifications
+      [g] :
+        T a ＝
+        ap f' (inv-H a) ∙
+        ( inv-G (s' a) ∙
+          ap inv-h (X a)) ∙
+        inv-F' (f a)
+      [g] =
+        left-transpose-eq-concat _ _ _
+          ( inv-right-transpose-eq-concat _ _ _
+            ( [e] ∙
+            left-whisker-concat-coherence-square-identifications
+              ( ap f' (ap inv-g (H a)) ∙ inv-G (s' a) ∙ ap inv-h (X a) ∙ ap inv-h (inv (F (f a))))
+              ( is-retraction-map-inv-equiv j (t (f a)))
+              ( inv (ap (inv-h ∘ h) (T a)))
+              ( inv (T a))
+              ( is-retraction-map-inv-equiv j (f' (s a)))
+              ( [f]))) ∙
+        ap
+          ( _∙ (ap f' (ap inv-g (H a)) ∙ _ ∙ _ ∙ _ ∙ _))
+          ( inv (ap-inv f' (is-retraction-map-inv-equiv e (s a)))) ∙
+        inv (assoc _ _ _) ∙
+        ap
+          (_∙ is-retraction-map-inv-equiv j (t (f a)))
+          ( inv (assoc _ _ _)) ∙
+        assoc _ _ _ ∙
+        ap
+          ( _∙ inv-F' (f a))
+          ( inv (assoc _ _ _) ∙
+            ap
+              ( _∙ ap inv-h (X a))
+              ( right-whisker-concat-coherence-triangle-identifications'
+                ( ap f' (inv-H a))
+                ( ap f' (ap inv-g (H a)))
+                ( ap f' (inv (is-retraction-map-inv-equiv e (s a))))
+                ( inv-G (s' a))
+                ( inv (ap-concat f' _ _))) ∙
+            assoc _ _ _)
+
+module _
+  {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+  {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
+  {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
+  (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
+  (g1' : {p : P1} → Q1 p → Q3 (g1 p))
+  (e1' : (p : P1) → Q1 p ≃ Q2 (f1 p))
+  (let f1' = λ {p} → map-equiv (e1' p))
+  (let inv-f1' = λ {p} → map-inv-equiv (e1' p))
+  (e2' : (p : P3) → Q3 p ≃ Q4 (f2 p))
+  (let f2' = λ {p} → map-equiv (e2' p))
+  (let inv-f2' = λ {p} → map-inv-equiv (e2' p))
+  (g2' : {p : P2} → Q2 p → Q4 (g2 p))
+  (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p) (s3 : (p : P3) → Q3 p)
+  (s4 : (p : P4) → Q4 p)
+  (G1 : (p : P1) → g1' (s1 p) ＝ s3 (g1 p))
+  (F1 : (p : P1) → f1' (s1 p) ＝ s2 (f1 p))
+  (F2 : (p : P3) → f2' (s3 p) ＝ s4 (f2 p))
+  (G2 : (p : P2) → g2' (s2 p) ＝ s4 (g2 p))
+  (H : coherence-square-maps g1 f1 f2 g2)
+  (H' : square-over {Q4 = Q4} _ _ _ _ g1' f1' f2' g2' H)
+  where
+
+  opaque
+    -- good luck if you ever need to unfold this...
+    flop-section :
+      section-square-over {Q4 = Q4}
+        _ _ _ _ g1' f1' f2' g2'
+        _ _ _ s4 G1 F1 F2 G2
+        H H' →
+      (p : P1) →
+      G1 p ∙ invert-fiberwise-triangle s3 (s4 ∘ f2) e2' F2 (g1 p) ＝
+      ap g1' (invert-fiberwise-triangle s1 (s2 ∘ f1) e1' F1 p) ∙
+      vertical-inv-equiv-coherence-square-maps g1' (e1' p) (e2' (g1 p)) (tr Q4 (H p) ∘ g2') H' (s2 (f1 p)) ∙
+      ap (inv-f2' ∘ tr Q4 (H p)) (G2 (f1 p)) ∙
+      ap inv-f2' (apd s4 (H p))
+    flop-section α p =
+      [i] p ∙
+      left-whisker-concat-coherence-triangle-identifications
+        ( _)
+        ( ap inv-f2' (ap (tr Q4 (H p)) (G2 (f1 p)) ∙ apd s4 (H p)))
+        ( ap inv-f2' (apd s4 (H p)))
+        ( ap (inv-f2' ∘ tr Q4 (H p)) (G2 (f1 p)))
+        ( ap-concat inv-f2' _ (apd s4 (H p)) ∙
+          ap (_∙ _) (inv (ap-comp inv-f2' (tr Q4 (H p)) (G2 (f1 p)))))
+      where
+      open import foundation.commuting-triangles-of-identifications
+      [i] : (a : P1) →
+            G1 a ∙
+            invert-fiberwise-triangle s3 (s4 ∘ f2) (λ b → e2' b) F2 (g1 a)
+            ＝
+            ap g1'
+            (invert-fiberwise-triangle s1 (s2 ∘ f1) (λ a₁ → e1' a₁) F1 a)
+            ∙
+            vertical-inv-equiv-coherence-square-maps g1' (e1' a) (e2' (g1 a))
+              (tr Q4 (H a) ∘ g2') H' ((s2 ∘ f1) a)
+              ∙
+              ap (map-inv-equiv (e2' (g1 a)))
+              (ap (tr Q4 (H a)) (G2 (f1 a)) ∙ apd s4 (H a))
+      [i] =
+        transpose-sq g1 s1 s3 (s2 ∘ f1) (s4 ∘ f2) g1' (λ {a} → tr Q4 (H a) ∘ g2')
+          ( e1' _) (e2' _) G1 H' F2 F1
+          (λ p → ap (tr Q4 (H p)) (G2 (f1 p)) ∙ apd s4 (H p))
+          (inv-htpy-assoc-htpy _ _ _ ∙h α ∙h assoc-htpy _ _ _) ∙h
+        inv-htpy-assoc-htpy _ _ _
+```
+
 ```agda
 module _
   {l1 l2 l3 l4 l5 : Level}
@@ -442,50 +717,49 @@ module _
   (let P = Q ∘ f∞)
   (let P' = descent-data-family-cocone-sequential-diagram c P)
   (let C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (let f∞n = λ n a → tr Q (C n a))
   (s : section-descent-data-sequential-colimit Q')
   (let s∞ = sect-family-sect-dd-sequential-colimit up-c' Q s)
-  -- remove later
-  (t : section-descent-data-sequential-colimit P')
-  (let t∞ = sect-family-sect-dd-sequential-colimit up-c P t)
   where
 
   private
-    γ :
-      (n : ℕ) (a : family-sequential-diagram A n) →
-      coherence-square-maps
-        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
-        ( tr Q (C n a))
-        ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
-        ( ( tr
-            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-            ( naturality-map-hom-sequential-diagram B f n a)) ∘
-          ( tr Q
-            ( coherence-cocone-sequential-diagram c' n
-              ( map-hom-sequential-diagram B f n a))))
-    γ n a q =
-      inv
-        ( ( tr-concat
-            ( C n a)
-            ( _)
-            ( q)) ∙
-          ( tr-concat
-            ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
-            ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) _)
-            ( _)) ∙
-          ( substitution-law-tr Q
-            ( map-cocone-sequential-diagram c' (succ-ℕ n))
-            ( naturality-map-hom-sequential-diagram B f n a))) ∙
-      ap
-        ( λ p → tr Q p q)
-        ( inv
-          ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∙
-      tr-concat
-        ( ap f∞ (coherence-cocone-sequential-diagram c n a))
-        ( C (succ-ℕ n) (map-sequential-diagram A n a))
-        ( q) ∙
-      ap
-        ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
-        ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a))
+    abstract
+      γ :
+        (n : ℕ) (a : family-sequential-diagram A n) →
+        coherence-square-maps
+          ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+          ( f∞n n a)
+          ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
+          ( ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)) ∘
+            ( tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a))))
+      γ n a q =
+        inv
+          ( ( tr-concat
+              ( C n a)
+              ( _)
+              ( q)) ∙
+            ( tr-concat
+              ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
+              ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) _)
+              ( _)) ∙
+            ( substitution-law-tr Q
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a))) ∙
+        ap
+          ( λ p → tr Q p q)
+          ( inv
+            ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∙
+        tr-concat
+          ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+          ( C (succ-ℕ n) (map-sequential-diagram A n a))
+          ( q) ∙
+        ap
+          ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+          ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a))
 
     γ-flip :
       (n : ℕ) (a : family-sequential-diagram A n) →
@@ -515,11 +789,10 @@ module _
   comp-over-diagram :
     section-descent-data-sequential-colimit
       ( descent-data-family-cocone-sequential-diagram c (Q ∘ f∞))
-  pr1 comp-over-diagram n a =
-    tr Q
-      ( inv (C n a))
-      ( map-section-dependent-sequential-diagram _ _ s n
-        (map-hom-sequential-diagram B f n a))
+  pr1 comp-over-diagram n =
+    tr Q (inv (C n _)) ∘
+    map-section-dependent-sequential-diagram _ _ s n ∘
+    map-hom-sequential-diagram B f n
   pr2 comp-over-diagram n a =
     ( γ-flip n a
       ( map-section-dependent-sequential-diagram _ _ s n
@@ -563,14 +836,96 @@ module _
         ( lemma-1-2)
         ( inv-htpy-dependent-cocone-sequential-diagram P lemma-1-1))
 
-  -- needs work, needs another input
-  lemma-2 : htpy-section-dependent-sequential-diagram t comp-over-diagram
-  pr1 lemma-2 = {!!}
-  pr2 lemma-2 = {!!}
-
-  theorem : t∞ ~ s∞ ∘ f∞
-  theorem =
-    htpy-colimit-htpy-diagram-section up-c P t comp-over-diagram lemma-2 ∙h
-    inv-htpy lemma-1
+  module _
+    (t : section-descent-data-sequential-colimit P')
+    (let t∞ = sect-family-sect-dd-sequential-colimit up-c P t)
+    (F :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      f∞n n a (map-section-dependent-sequential-diagram _ _ t n a) ＝
+      map-section-dependent-sequential-diagram _ _ s n
+        ( map-hom-sequential-diagram B f n a))
+    (cubes :
+      (n : ℕ) →
+      section-square-over
+        ( map-sequential-diagram A n)
+        ( map-hom-sequential-diagram B f n)
+        ( map-hom-sequential-diagram B f (succ-ℕ n))
+        ( map-sequential-diagram B n)
+        ( λ {a} → tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+        ( λ {a} → f∞n n a)
+        ( λ {a} → f∞n (succ-ℕ n) a)
+        ( λ {b} → tr Q (coherence-cocone-sequential-diagram c' n b))
+        ( map-section-dependent-sequential-diagram _ _ t n)
+        ( map-section-dependent-sequential-diagram _ _ s n)
+        ( map-section-dependent-sequential-diagram _ _ t (succ-ℕ n))
+        ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+        ( naturality-map-section-dependent-sequential-diagram _ _ t n)
+        ( F n)
+        ( F (succ-ℕ n))
+        ( naturality-map-section-dependent-sequential-diagram _ _ s n)
+        ( naturality-map-hom-sequential-diagram B f n)
+        ( λ {a} → γ n a))
+    where
+
+    lemma-2 : htpy-section-dependent-sequential-diagram t comp-over-diagram
+    pr1 lemma-2 n =
+      invert-fiberwise-triangle
+        ( map-section-dependent-sequential-diagram _ _ t n)
+        ( map-section-dependent-sequential-diagram _ _ s n ∘ map-hom-sequential-diagram B f n)
+        ( λ a → equiv-tr Q (C n a))
+        ( F n)
+    pr2 lemma-2 n a =
+      flop-section
+        ( map-sequential-diagram A n)
+        ( map-hom-sequential-diagram B f n)
+        ( map-hom-sequential-diagram B f (succ-ℕ n))
+        ( map-sequential-diagram B n)
+        ( λ {a} → tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+        ( λ a → equiv-tr Q (C n a))
+        ( λ a → equiv-tr Q (C (succ-ℕ n) a))
+        ( λ {b} → tr Q (coherence-cocone-sequential-diagram c' n b))
+        ( map-section-dependent-sequential-diagram _ _ t n)
+        ( map-section-dependent-sequential-diagram _ _ s n)
+        ( map-section-dependent-sequential-diagram _ _ t (succ-ℕ n))
+        ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+        ( naturality-map-section-dependent-sequential-diagram _ _ t n)
+        ( F n)
+        ( F (succ-ℕ n))
+        ( naturality-map-section-dependent-sequential-diagram _ _ s n)
+        ( naturality-map-hom-sequential-diagram B f n)
+        ( λ {a} → γ n a)
+        ( cubes n)
+        ( a) ∙
+      assoc _ _ _ ∙
+      ap
+        ( ap
+          ( tr P (coherence-cocone-sequential-diagram c n a))
+          ( pr1 lemma-2 n a) ∙
+          γ-flip n a (map-section-dependent-sequential-diagram _ _ s n (map-hom-sequential-diagram B f n a)) ∙_)
+        ( ( ap
+            ( _∙
+              ap
+                ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+                ( apd
+                  ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+                  ( naturality-map-hom-sequential-diagram B f n a)))
+            ( ap-comp
+              ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+              ( tr
+                ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+                ( naturality-map-hom-sequential-diagram B f n a))
+              ( naturality-map-section-dependent-sequential-diagram _ _ s n
+                ( map-hom-sequential-diagram B f n a)))) ∙
+          inv
+          ( ( ap-concat
+              ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+              ( _)
+              ( _)))) ∙
+      assoc _ _ _
+
+    theorem : t∞ ~ s∞ ∘ f∞
+    theorem =
+      htpy-colimit-htpy-diagram-section up-c P t comp-over-diagram lemma-2 ∙h
+      inv-htpy lemma-1
 ```
 

From 8ae8d7bd2502154fbc0c99c7fb5500445075e3da Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Thu, 6 Mar 2025 18:15:49 +0100
Subject: [PATCH 25/33] One goal down, another to go

---
 .../functoriality-stuff.lagda.md              | 240 +++++++++++-------
 1 file changed, 155 insertions(+), 85 deletions(-)

diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index 1d25dbd245..fe2296c1b6 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -55,6 +55,7 @@ open import foundation.fundamental-theorem-of-identity-types
 open import foundation.homotopy-induction
 open import foundation.structure-identity-principle
 open import foundation.torsorial-type-families
+open import foundation.transposition-identifications-along-equivalences
 ```
 
 </details>
@@ -701,6 +702,45 @@ module _
         inv-htpy-assoc-htpy _ _ _
 ```
 
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  (f : (a : A) → B a)
+  where
+
+  lemma :
+    {x y : A} (p : x ＝ y) →
+    apd f (inv p) ＝ inv (map-eq-transpose-equiv (equiv-tr B p) (apd f p))
+  lemma refl = inv (ap inv (compute-refl-eq-transpose-equiv (equiv-tr B refl)))
+```
+
+```agda
+module _
+  {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : B → UU l3}
+  (f : A → B) (s : (b : B) → C b)
+  where
+
+  apd-left :
+    {x y : A} (p : x ＝ y) →
+    apd (s ∘ f) p ＝ inv (substitution-law-tr C f p) ∙ apd s (ap f p)
+  apd-left refl = refl
+
+  apd-left' :
+    {x y : A} (p : x ＝ y) →
+    substitution-law-tr C f p ∙ apd (s ∘ f) p ＝ apd s (ap f p)
+  apd-left' refl = refl
+
+module _
+  {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : A → UU l3}
+  (s : (a : A) → B a) (f : {a : A} → B a → C a)
+  where
+
+  apd-right :
+    {x y : A} (p : x ＝ y) →
+    apd (f ∘ s) p ＝ inv (preserves-tr (λ a → f {a}) p (s x)) ∙ ap f (apd s p)
+  apd-right refl = refl
+```
+
 ```agda
 module _
   {l1 l2 l3 l4 l5 : Level}
@@ -710,6 +750,9 @@ module _
   {B : sequential-diagram l3} {Y : UU l4}
   {c' : cocone-sequential-diagram B Y}
   (up-c' : universal-property-sequential-colimit c')
+  (let
+    dup-c' =
+      dependent-universal-property-universal-property-sequential-colimit _ up-c')
   (Q : Y → UU l5)
   (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
   (f : hom-sequential-diagram A B)
@@ -720,14 +763,20 @@ module _
   (let f∞n = λ n a → tr Q (C n a))
   (s : section-descent-data-sequential-colimit Q')
   (let s∞ = sect-family-sect-dd-sequential-colimit up-c' Q s)
+  (let
+    𝒞 =
+      htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+        ( dup-c')
+        ( s))
+  (let C' = htpy-htpy-dependent-cocone-sequential-diagram Q 𝒞)
   where
 
   private
-    abstract
-      γ :
+    opaque
+      γ-base :
         (n : ℕ) (a : family-sequential-diagram A n) →
         coherence-square-maps
-          ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+          ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
           ( f∞n n a)
           ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
           ( ( tr
@@ -736,7 +785,7 @@ module _
             ( tr Q
               ( coherence-cocone-sequential-diagram c' n
                 ( map-hom-sequential-diagram B f n a))))
-      γ n a q =
+      γ-base n a q =
         inv
           ( ( tr-concat
               ( C n a)
@@ -756,35 +805,50 @@ module _
         tr-concat
           ( ap f∞ (coherence-cocone-sequential-diagram c n a))
           ( C (succ-ℕ n) (map-sequential-diagram A n a))
-          ( q) ∙
+          ( q)
+
+      γ :
+        (n : ℕ) (a : family-sequential-diagram A n) →
+        coherence-square-maps
+          ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+          ( f∞n n a)
+          ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
+          ( ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)) ∘
+            ( tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a))))
+      γ n a q =
+        γ-base n a q ∙
         ap
           ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
           ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a))
 
-    γ-flip :
-      (n : ℕ) (a : family-sequential-diagram A n) →
-      coherence-square-maps
-        ( ( tr
-            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-            ( naturality-map-hom-sequential-diagram B f n a)) ∘
-          ( tr Q
-            ( coherence-cocone-sequential-diagram c' n
-              ( map-hom-sequential-diagram B f n a))))
-        ( tr Q (inv (C n a)))
-        ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
-        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
-    γ-flip n a =
-      vertical-inv-equiv-coherence-square-maps
-        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
-        ( equiv-tr Q (C n a))
-        ( equiv-tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
-        ( ( tr
-            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-            ( naturality-map-hom-sequential-diagram B f n a)) ∘
-          ( tr Q
-            ( coherence-cocone-sequential-diagram c' n
-              ( map-hom-sequential-diagram B f n a))))
-        ( γ n a)
+      γ-flip :
+        (n : ℕ) (a : family-sequential-diagram A n) →
+        coherence-square-maps
+          ( ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)) ∘
+            ( tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a))))
+          ( tr Q (inv (C n a)))
+          ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+          ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+      γ-flip n a =
+        vertical-inv-equiv-coherence-square-maps
+          ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+          ( equiv-tr Q (C n a))
+          ( equiv-tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+          ( ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)) ∘
+            ( tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a))))
+          ( γ n a)
 
   comp-over-diagram :
     section-descent-data-sequential-colimit
@@ -825,8 +889,11 @@ module _
       ( section-descent-data-section-family-cocone-sequential-colimit c P
         ( s∞ ∘ f∞))
       ( comp-over-diagram)
-  pr1 lemma-1-2 n a = {!!}
-  pr2 lemma-1-2 = {!!}
+  pr1 lemma-1-2 n a =
+    map-eq-transpose-equiv
+      ( equiv-tr Q (C n a))
+      ( apd s∞ (C n a) ∙ C' n (map-hom-sequential-diagram B f n a))
+  pr2 lemma-1-2 n a = {!!}
 
   lemma-1 :
     s∞ ∘ f∞ ~ sect-family-sect-dd-sequential-colimit up-c P comp-over-diagram
@@ -867,61 +934,64 @@ module _
         ( λ {a} → γ n a))
     where
 
-    lemma-2 : htpy-section-dependent-sequential-diagram t comp-over-diagram
-    pr1 lemma-2 n =
-      invert-fiberwise-triangle
-        ( map-section-dependent-sequential-diagram _ _ t n)
-        ( map-section-dependent-sequential-diagram _ _ s n ∘ map-hom-sequential-diagram B f n)
-        ( λ a → equiv-tr Q (C n a))
-        ( F n)
-    pr2 lemma-2 n a =
-      flop-section
-        ( map-sequential-diagram A n)
-        ( map-hom-sequential-diagram B f n)
-        ( map-hom-sequential-diagram B f (succ-ℕ n))
-        ( map-sequential-diagram B n)
-        ( λ {a} → tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
-        ( λ a → equiv-tr Q (C n a))
-        ( λ a → equiv-tr Q (C (succ-ℕ n) a))
-        ( λ {b} → tr Q (coherence-cocone-sequential-diagram c' n b))
-        ( map-section-dependent-sequential-diagram _ _ t n)
-        ( map-section-dependent-sequential-diagram _ _ s n)
-        ( map-section-dependent-sequential-diagram _ _ t (succ-ℕ n))
-        ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
-        ( naturality-map-section-dependent-sequential-diagram _ _ t n)
-        ( F n)
-        ( F (succ-ℕ n))
-        ( naturality-map-section-dependent-sequential-diagram _ _ s n)
-        ( naturality-map-hom-sequential-diagram B f n)
-        ( λ {a} → γ n a)
-        ( cubes n)
-        ( a) ∙
-      assoc _ _ _ ∙
-      ap
-        ( ap
-          ( tr P (coherence-cocone-sequential-diagram c n a))
-          ( pr1 lemma-2 n a) ∙
-          γ-flip n a (map-section-dependent-sequential-diagram _ _ s n (map-hom-sequential-diagram B f n a)) ∙_)
-        ( ( ap
-            ( _∙
-              ap
+    opaque
+      unfolding γ-flip
+
+      lemma-2 : htpy-section-dependent-sequential-diagram t comp-over-diagram
+      pr1 lemma-2 n =
+        invert-fiberwise-triangle
+          ( map-section-dependent-sequential-diagram _ _ t n)
+          ( map-section-dependent-sequential-diagram _ _ s n ∘ map-hom-sequential-diagram B f n)
+          ( λ a → equiv-tr Q (C n a))
+          ( F n)
+      pr2 lemma-2 n a =
+        flop-section
+          ( map-sequential-diagram A n)
+          ( map-hom-sequential-diagram B f n)
+          ( map-hom-sequential-diagram B f (succ-ℕ n))
+          ( map-sequential-diagram B n)
+          ( λ {a} → tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+          ( λ a → equiv-tr Q (C n a))
+          ( λ a → equiv-tr Q (C (succ-ℕ n) a))
+          ( λ {b} → tr Q (coherence-cocone-sequential-diagram c' n b))
+          ( map-section-dependent-sequential-diagram _ _ t n)
+          ( map-section-dependent-sequential-diagram _ _ s n)
+          ( map-section-dependent-sequential-diagram _ _ t (succ-ℕ n))
+          ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+          ( naturality-map-section-dependent-sequential-diagram _ _ t n)
+          ( F n)
+          ( F (succ-ℕ n))
+          ( naturality-map-section-dependent-sequential-diagram _ _ s n)
+          ( naturality-map-hom-sequential-diagram B f n)
+          ( λ {a} → γ n a)
+          ( cubes n)
+          ( a) ∙
+        assoc _ _ _ ∙
+        ap
+          ( ap
+            ( tr P (coherence-cocone-sequential-diagram c n a))
+            ( pr1 lemma-2 n a) ∙
+            γ-flip n a (map-section-dependent-sequential-diagram _ _ s n (map-hom-sequential-diagram B f n a)) ∙_)
+          ( ( ap
+              ( _∙
+                ap
+                  ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+                  ( apd
+                    ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+                    ( naturality-map-hom-sequential-diagram B f n a)))
+              ( ap-comp
                 ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
-                ( apd
-                  ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
-                  ( naturality-map-hom-sequential-diagram B f n a)))
-            ( ap-comp
-              ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
-              ( tr
-                ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-                ( naturality-map-hom-sequential-diagram B f n a))
-              ( naturality-map-section-dependent-sequential-diagram _ _ s n
-                ( map-hom-sequential-diagram B f n a)))) ∙
-          inv
-          ( ( ap-concat
-              ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
-              ( _)
-              ( _)))) ∙
-      assoc _ _ _
+                ( tr
+                  ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+                  ( naturality-map-hom-sequential-diagram B f n a))
+                ( naturality-map-section-dependent-sequential-diagram _ _ s n
+                  ( map-hom-sequential-diagram B f n a)))) ∙
+            inv
+            ( ( ap-concat
+                ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+                ( _)
+                ( _)))) ∙
+        assoc _ _ _
 
     theorem : t∞ ~ s∞ ∘ f∞
     theorem =

From cef8863eeb5742c964fd85f56f8bb6a2b4f346a3 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 12 Mar 2025 22:19:23 +0100
Subject: [PATCH 26/33] Functoriality lemma

---
 .../transport-along-identifications.lagda.md  |    9 +
 .../families-of-equivalences.lagda.md         |   32 +
 ...functoriality-sequential-colimits.lagda.md |  155 +--
 .../functoriality-stuff.lagda.md              | 1008 +++++++++++++++--
 4 files changed, 1026 insertions(+), 178 deletions(-)

diff --git a/src/foundation-core/transport-along-identifications.lagda.md b/src/foundation-core/transport-along-identifications.lagda.md
index 49b511e7e0..1dda4c800f 100644
--- a/src/foundation-core/transport-along-identifications.lagda.md
+++ b/src/foundation-core/transport-along-identifications.lagda.md
@@ -68,6 +68,15 @@ module _
     preserves-tr p x ＝
     inv (tr-ap id f p x) ∙ ap (λ q → tr B q (f i x)) (ap-id p)
   compute-preserves-tr refl x = refl
+
+module _
+  {l1 l2 : Level} {I : UU l1} {A : I → UU l2}
+  where
+
+  compute-preserves-tr-id :
+    {i j : I} (p : i ＝ j) (x : A i) →
+    preserves-tr (λ i → id {A = A i}) p x ＝ refl
+  compute-preserves-tr-id refl x = refl
 ```
 
 ### Substitution law for transport
diff --git a/src/foundation/families-of-equivalences.lagda.md b/src/foundation/families-of-equivalences.lagda.md
index 3cfded46ff..f9b864e830 100644
--- a/src/foundation/families-of-equivalences.lagda.md
+++ b/src/foundation/families-of-equivalences.lagda.md
@@ -9,10 +9,13 @@ open import foundation-core.families-of-equivalences public
 <details><summary>Imports</summary>
 
 ```agda
+open import foundation.equality-dependent-function-types
 open import foundation.equivalences
+open import foundation.univalence
 open import foundation.universe-levels
 
 open import foundation-core.propositions
+open import foundation-core.torsorial-type-families
 ```
 
 </details>
@@ -28,6 +31,19 @@ A **family of equivalences** is a family
 of [equivalences](foundation-core.equivalences.md). Families of equivalences are
 also called **fiberwise equivalences**.
 
+## Definitions
+
+### The family of identity equivalences
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+
+  id-fam-equiv : fam-equiv B B
+  id-fam-equiv a = id-equiv
+```
+
 ## Properties
 
 ### Being a fiberwise equivalence is a proposition
@@ -43,6 +59,22 @@ module _
     is-prop-Π (λ a → is-property-is-equiv (f a))
 ```
 
+### TODO
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+
+  is-torsorial-fam-equiv : is-torsorial (fam-equiv B)
+  is-torsorial-fam-equiv =
+    is-torsorial-Eq-Π (λ a → is-torsorial-equiv (B a))
+
+  is-torsorial-fam-equiv' : is-torsorial (λ C → fam-equiv C B)
+  is-torsorial-fam-equiv' =
+    is-torsorial-Eq-Π (λ a → is-torsorial-equiv' (B a))
+```
+
 ## See also
 
 - In
diff --git a/src/synthetic-homotopy-theory/functoriality-sequential-colimits.lagda.md b/src/synthetic-homotopy-theory/functoriality-sequential-colimits.lagda.md
index 1279c6f21d..32812f6747 100644
--- a/src/synthetic-homotopy-theory/functoriality-sequential-colimits.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-sequential-colimits.lagda.md
@@ -146,87 +146,88 @@ module _
   ( f : hom-sequential-diagram A B)
   where
 
-  map-sequential-colimit-hom-sequential-diagram : X → Y
-  map-sequential-colimit-hom-sequential-diagram =
-    map-universal-property-sequential-colimit up-c
-      ( map-cocone-hom-sequential-diagram f c')
-
-  htpy-cocone-map-sequential-colimit-hom-sequential-diagram :
-    htpy-cocone-sequential-diagram
-      ( cocone-map-sequential-diagram c
-        ( map-sequential-colimit-hom-sequential-diagram))
-      ( map-cocone-hom-sequential-diagram f c')
-  htpy-cocone-map-sequential-colimit-hom-sequential-diagram =
-    htpy-cocone-universal-property-sequential-colimit up-c
-      ( map-cocone-hom-sequential-diagram f c')
-
-  htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram :
-    ( n : ℕ) →
-    coherence-square-maps
-      ( map-hom-sequential-diagram B f n)
-      ( map-cocone-sequential-diagram c n)
-      ( map-cocone-sequential-diagram c' n)
-      ( map-sequential-colimit-hom-sequential-diagram)
-  htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram =
-    htpy-htpy-cocone-sequential-diagram
-      ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram)
+  opaque
+    map-sequential-colimit-hom-sequential-diagram : X → Y
+    map-sequential-colimit-hom-sequential-diagram =
+      map-universal-property-sequential-colimit up-c
+        ( map-cocone-hom-sequential-diagram f c')
 
-  coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram :
-    ( n : ℕ) →
-    coherence-square-homotopies
-      ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram n)
-      ( ( map-sequential-colimit-hom-sequential-diagram) ·l
-        ( coherence-cocone-sequential-diagram c n))
-      ( coherence-cocone-sequential-diagram
+    htpy-cocone-map-sequential-colimit-hom-sequential-diagram :
+      htpy-cocone-sequential-diagram
+        ( cocone-map-sequential-diagram c
+          ( map-sequential-colimit-hom-sequential-diagram))
+        ( map-cocone-hom-sequential-diagram f c')
+    htpy-cocone-map-sequential-colimit-hom-sequential-diagram =
+      htpy-cocone-universal-property-sequential-colimit up-c
         ( map-cocone-hom-sequential-diagram f c')
-        ( n))
-      ( ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-          ( succ-ℕ n)) ·r
-        ( map-sequential-diagram A n))
-  coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram =
-    coherence-htpy-htpy-cocone-sequential-diagram
-      htpy-cocone-map-sequential-colimit-hom-sequential-diagram
 
-  prism-htpy-cocone-map-sequential-colimit-hom-sequential-diagram :
-    ( n : ℕ) →
-    vertical-coherence-prism-maps
-      ( map-cocone-sequential-diagram c n)
-      ( map-cocone-sequential-diagram c (succ-ℕ n))
-      ( map-sequential-diagram A n)
-      ( map-cocone-sequential-diagram c' n)
-      ( map-cocone-sequential-diagram c' (succ-ℕ n))
-      ( map-sequential-diagram B n)
-      ( map-hom-sequential-diagram B f n)
-      ( map-hom-sequential-diagram B f (succ-ℕ n))
-      ( map-sequential-colimit-hom-sequential-diagram)
-      ( coherence-cocone-sequential-diagram c n)
-      ( inv-htpy
-        ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram n))
-      ( inv-htpy
+    htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram :
+      ( n : ℕ) →
+      coherence-square-maps
+        ( map-hom-sequential-diagram B f n)
+        ( map-cocone-sequential-diagram c n)
+        ( map-cocone-sequential-diagram c' n)
+        ( map-sequential-colimit-hom-sequential-diagram)
+    htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram =
+      htpy-htpy-cocone-sequential-diagram
+        ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram)
+
+    coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram :
+      ( n : ℕ) →
+      coherence-square-homotopies
+        ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram n)
+        ( ( map-sequential-colimit-hom-sequential-diagram) ·l
+          ( coherence-cocone-sequential-diagram c n))
+        ( coherence-cocone-sequential-diagram
+          ( map-cocone-hom-sequential-diagram f c')
+          ( n))
+        ( ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+            ( succ-ℕ n)) ·r
+          ( map-sequential-diagram A n))
+    coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram =
+      coherence-htpy-htpy-cocone-sequential-diagram
+        htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+
+    prism-htpy-cocone-map-sequential-colimit-hom-sequential-diagram :
+      ( n : ℕ) →
+      vertical-coherence-prism-maps
+        ( map-cocone-sequential-diagram c n)
+        ( map-cocone-sequential-diagram c (succ-ℕ n))
+        ( map-sequential-diagram A n)
+        ( map-cocone-sequential-diagram c' n)
+        ( map-cocone-sequential-diagram c' (succ-ℕ n))
+        ( map-sequential-diagram B n)
+        ( map-hom-sequential-diagram B f n)
+        ( map-hom-sequential-diagram B f (succ-ℕ n))
+        ( map-sequential-colimit-hom-sequential-diagram)
+        ( coherence-cocone-sequential-diagram c n)
+        ( inv-htpy
+          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram n))
+        ( inv-htpy
+          ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+            ( succ-ℕ n)))
+        ( naturality-map-hom-sequential-diagram B f n)
+        ( coherence-cocone-sequential-diagram c' n)
+    prism-htpy-cocone-map-sequential-colimit-hom-sequential-diagram n =
+      rotate-vertical-coherence-prism-maps
+        ( map-cocone-sequential-diagram c n)
+        ( map-cocone-sequential-diagram c (succ-ℕ n))
+        ( map-sequential-diagram A n)
+        ( map-cocone-sequential-diagram c' n)
+        ( map-cocone-sequential-diagram c' (succ-ℕ n))
+        ( map-sequential-diagram B n)
+        ( map-hom-sequential-diagram B f n)
+        ( map-hom-sequential-diagram B f (succ-ℕ n))
+        ( map-sequential-colimit-hom-sequential-diagram)
+        ( coherence-cocone-sequential-diagram c n)
+        ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram n)
         ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-          ( succ-ℕ n)))
-      ( naturality-map-hom-sequential-diagram B f n)
-      ( coherence-cocone-sequential-diagram c' n)
-  prism-htpy-cocone-map-sequential-colimit-hom-sequential-diagram n =
-    rotate-vertical-coherence-prism-maps
-      ( map-cocone-sequential-diagram c n)
-      ( map-cocone-sequential-diagram c (succ-ℕ n))
-      ( map-sequential-diagram A n)
-      ( map-cocone-sequential-diagram c' n)
-      ( map-cocone-sequential-diagram c' (succ-ℕ n))
-      ( map-sequential-diagram B n)
-      ( map-hom-sequential-diagram B f n)
-      ( map-hom-sequential-diagram B f (succ-ℕ n))
-      ( map-sequential-colimit-hom-sequential-diagram)
-      ( coherence-cocone-sequential-diagram c n)
-      ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram n)
-      ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-        ( succ-ℕ n))
-      ( naturality-map-hom-sequential-diagram B f n)
-      ( coherence-cocone-sequential-diagram c' n)
-      ( inv-htpy
-        ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-          ( n)))
+          ( succ-ℕ n))
+        ( naturality-map-hom-sequential-diagram B f n)
+        ( coherence-cocone-sequential-diagram c' n)
+        ( inv-htpy
+          ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+            ( n)))
 ```
 
 ### Homotopies between morphisms of sequential diagrams induce homotopies of corresponding maps between sequential colimits
diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index fe2296c1b6..30e5bf3280 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -1,7 +1,7 @@
 # Functoriality stuff
 
 ```agda
-{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
+{-# OPTIONS --lossy-unification #-}
 
 module synthetic-homotopy-theory.functoriality-stuff where
 ```
@@ -11,16 +11,21 @@ module synthetic-homotopy-theory.functoriality-stuff where
 ```agda
 open import elementary-number-theory.natural-numbers
 
+open import foundation.action-on-identifications-binary-functions
 open import foundation.action-on-identifications-dependent-functions
 open import foundation.action-on-identifications-functions
 -- open import foundation.binary-homotopies
+open import foundation.commuting-squares-of-identifications
 open import foundation.commuting-squares-of-maps
+open import foundation.commuting-triangles-of-identifications
 open import foundation.commuting-triangles-of-maps
 -- open import foundation.dependent-identifications
 open import foundation.dependent-pair-types
 open import foundation.embeddings
 open import foundation.equality-dependent-pair-types
 open import foundation.equivalences
+open import foundation.families-of-equivalences
+open import foundation.fiberwise-equivalence-induction
 open import foundation.function-extensionality
 open import foundation.function-types
 open import foundation.functoriality-dependent-function-types
@@ -62,7 +67,7 @@ open import foundation.transposition-identifications-along-equivalences
 
 ## Theorem
 
--- ```agda
+```agda
 module _
   {l1 l2 : Level}
   {A : sequential-diagram l1}
@@ -96,7 +101,6 @@ module _
   (c : cocone-sequential-diagram A X)
   (P : X → UU l3)
   where
-  open import synthetic-homotopy-theory.dependent-cocones-under-sequential-diagrams
 
   section-descent-data-section-family-cocone-sequential-colimit :
     ((x : X) → P x) →
@@ -434,7 +438,6 @@ module _
   (e : (a : A) → B a ≃ C a)
   (H : (a : A) → map-equiv (e a) (s a) ＝ t a)
   where
-  open import foundation.action-on-identifications-binary-functions
 
   invert-fiberwise-triangle : (a : A) → s a ＝ map-inv-equiv (e a) (t a)
   invert-fiberwise-triangle a =
@@ -595,8 +598,6 @@ module _
         ap
           ( is-retraction-map-inv-equiv j (t (f a)) ∙_)
           ( ap-id (inv (T a)))
-      open import foundation.commuting-squares-of-identifications
-      open import foundation.commuting-triangles-of-identifications
       [g] :
         T a ＝
         ap f' (inv-H a) ∙
@@ -681,7 +682,6 @@ module _
         ( ap-concat inv-f2' _ (apd s4 (H p)) ∙
           ap (_∙ _) (inv (ap-comp inv-f2' (tr Q4 (H p)) (G2 (f1 p)))))
       where
-      open import foundation.commuting-triangles-of-identifications
       [i] : (a : P1) →
             G1 a ∙
             invert-fiberwise-triangle s3 (s4 ∘ f2) (λ b → e2' b) F2 (g1 a)
@@ -702,18 +702,6 @@ module _
         inv-htpy-assoc-htpy _ _ _
 ```
 
-```agda
-module _
-  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
-  (f : (a : A) → B a)
-  where
-
-  lemma :
-    {x y : A} (p : x ＝ y) →
-    apd f (inv p) ＝ inv (map-eq-transpose-equiv (equiv-tr B p) (apd f p))
-  lemma refl = inv (ap inv (compute-refl-eq-transpose-equiv (equiv-tr B refl)))
-```
-
 ```agda
 module _
   {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : B → UU l3}
@@ -741,6 +729,141 @@ module _
   apd-right refl = refl
 ```
 
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  (s : (a : A) → B a)
+  where
+
+  apd-concat :
+    {x y z : A} (p : x ＝ y) (q : y ＝ z) →
+    ap (tr B q) (apd s p) ∙ apd s q ＝ inv (tr-concat p q (s x)) ∙ apd s (p ∙ q)
+  apd-concat refl q = refl
+
+  apd-concat' :
+    {x y z : A} (p : x ＝ y) (q : y ＝ z) →
+    apd s (p ∙ q) ＝ tr-concat p q (s x) ∙ ap (tr B q) (apd s p) ∙ apd s q
+  apd-concat' refl q = refl
+```
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  (s : (a : A) → B a)
+  where
+
+  apd-apd :
+    {x y : A} (p q : x ＝ y) (α : p ＝ q) →
+    ap (λ r → tr B r (s x)) (inv α) ∙ apd s p ＝ apd s q
+  apd-apd p q refl = refl
+
+  apd-apd' :
+    {x y : A} (p q : x ＝ y) (α : p ＝ q) →
+    apd s p ＝ ap (λ r → tr B r (s x)) α ∙ apd s q
+  apd-apd' p q refl = refl
+```
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  {f g : (a : A) → B a} (H : f ~ g)
+  where
+
+  inv-dep-nat-htpy :
+    {x y : A} (p : x ＝ y) →
+    apd f p ∙ H y ＝
+    ap (tr B p) (H x) ∙ apd g p
+  inv-dep-nat-htpy {x = x} {y = y} p =
+    map-inv-compute-dependent-identification-eq-value f g p (H x) (H y)
+      ( apd H p)
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : UU l2}
+  {P : A → UU l3} {Q : B → UU l4}
+  (f : A → B) (sA : (a : A) → P a) (sB : (b : B) → Q b)
+  (f' : {a : A} → P a → Q (f a))
+  where
+
+  convenient-square : UU (l1 ⊔ l4)
+  convenient-square = sB ∘ f ~ f' ∘ sA
+
+  convenient-square' : UU (l1 ⊔ l4)
+  convenient-square' = f' ∘ sA ~ sB ∘ f
+
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+  {P : C → UU l5} {Q : D → UU l6}
+  (f : A → B) (hA : A → C) (hB : B → D) (g : C → D)
+  (sA : (c : C) → P c) (sB : (d : D) → Q d) (f' : {c : C} → P c → Q (g c))
+  where
+
+  pasting-squares :
+    (H : coherence-square-maps hA f g hB) →
+    convenient-square g sA sB f' →
+    (a : A) → tr Q (H a) (sB (hB (f a))) ＝ f' (sA (hA a))
+  pasting-squares H K a =
+    apd sB (H a) ∙ K (hA a)
+
+  pasting-squares' :
+    (H : coherence-square-maps' hA f g hB) →
+    convenient-square' g sA sB f' →
+    (a : A) → tr Q (H a) (f' (sA (hA a))) ＝ sB (hB (f a))
+  pasting-squares' H K a =
+    ap (tr Q (H a)) (K (hA a)) ∙ apd sB (H a)
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3}
+  {A' : UU l4} {B' : UU l5} {C' : UU l6}
+  (f : A → C) (g : B → C) (h : A → B)
+  (f' : A' → C') (g' : B' → C') (h' : A' → B')
+  (hA : A → A') (hB : B → B') (hC : C → C')
+  (left : hC ∘ f ~ f' ∘ hA)
+  (right : hC ∘ g ~ g' ∘ hB)
+  (back : h' ∘ hA ~ hB ∘ h)
+  (bottom : f ~ g ∘ h)
+  (top : f' ~ g' ∘ h')
+  where
+
+  convenient-prism : UU (l1 ⊔ l6)
+  convenient-prism =
+    left ∙h (top ·r hA) ∙h (g' ·l back) ~
+    (hC ·l bottom) ∙h (right ·r h)
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3}
+  {P : A → UU l4} {Q : B → UU l5} {R : C → UU l6}
+  (f : A → C) (g : B → C) (h : A → B)
+  (f' : {a : A} → P a → R (f a))
+  (g' : {b : B} → Q b → R (g b))
+  (h' : {a : A} → P a → Q (h a))
+  (sA : (a : A) → P a) (sB : (b : B) → Q b) (sC : (c : C) → R c)
+  (left : sC ∘ f ~ f' ∘ sA)
+  (right : sC ∘ g ~ g' ∘ sB)
+  (back : h' ∘ sA ~ sB ∘ h)
+  (bottom : f ~ g ∘ h)
+  (top : htpy-over R bottom f' (g' ∘ h'))
+  where
+
+  fiberwise-prism : UU (l1 ⊔ l6)
+  fiberwise-prism =
+    (a : A) →
+    ( ap (tr R (bottom a)) (left a) ∙
+      top (sA a) ∙
+      ap g' (back a)) ＝
+    ( apd sC (bottom a) ∙
+      right (h a))
+```
+
 ```agda
 module _
   {l1 l2 l3 l4 l5 : Level}
@@ -771,84 +894,88 @@ module _
   (let C' = htpy-htpy-dependent-cocone-sequential-diagram Q 𝒞)
   where
 
-  private
-    opaque
-      γ-base :
-        (n : ℕ) (a : family-sequential-diagram A n) →
-        coherence-square-maps
-          ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
-          ( f∞n n a)
-          ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
-          ( ( tr
-              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-              ( naturality-map-hom-sequential-diagram B f n a)) ∘
-            ( tr Q
-              ( coherence-cocone-sequential-diagram c' n
-                ( map-hom-sequential-diagram B f n a))))
-      γ-base n a q =
-        inv
-          ( ( tr-concat
-              ( C n a)
-              ( _)
-              ( q)) ∙
-            ( tr-concat
-              ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
-              ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) _)
-              ( _)) ∙
-            ( substitution-law-tr Q
-              ( map-cocone-sequential-diagram c' (succ-ℕ n))
-              ( naturality-map-hom-sequential-diagram B f n a))) ∙
-        ap
-          ( λ p → tr Q p q)
-          ( inv
-            ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∙
-        tr-concat
-          ( ap f∞ (coherence-cocone-sequential-diagram c n a))
-          ( C (succ-ℕ n) (map-sequential-diagram A n a))
-          ( q)
-
-      γ :
-        (n : ℕ) (a : family-sequential-diagram A n) →
-        coherence-square-maps
-          ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
-          ( f∞n n a)
-          ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
-          ( ( tr
-              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-              ( naturality-map-hom-sequential-diagram B f n a)) ∘
-            ( tr Q
-              ( coherence-cocone-sequential-diagram c' n
-                ( map-hom-sequential-diagram B f n a))))
-      γ n a q =
-        γ-base n a q ∙
-        ap
-          ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
-          ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a))
+  -- private
+  opaque
+    γ-base :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      coherence-square-maps
+        ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
+        ( f∞n n a)
+        ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+    γ-base n a q =
+      inv
+        ( substitution-law-tr Q
+          ( map-cocone-sequential-diagram c' (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B f n a)) ∙
+      inv
+        ( tr-concat
+          ( coherence-cocone-sequential-diagram c' n
+            ( map-hom-sequential-diagram B f n a))
+          ( ap
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( tr Q (C n a) q)) ∙
+      inv
+        ( tr-concat (C n a) _ q) ∙
+      ap
+        ( λ p → tr Q p q)
+        ( inv
+          ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∙
+      tr-concat
+        ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+        ( C (succ-ℕ n) (map-sequential-diagram A n a))
+        ( q)
 
-      γ-flip :
-        (n : ℕ) (a : family-sequential-diagram A n) →
-        coherence-square-maps
-          ( ( tr
-              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-              ( naturality-map-hom-sequential-diagram B f n a)) ∘
-            ( tr Q
-              ( coherence-cocone-sequential-diagram c' n
-                ( map-hom-sequential-diagram B f n a))))
-          ( tr Q (inv (C n a)))
-          ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
-          ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
-      γ-flip n a =
-        vertical-inv-equiv-coherence-square-maps
-          ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
-          ( equiv-tr Q (C n a))
-          ( equiv-tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
-          ( ( tr
-              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
-              ( naturality-map-hom-sequential-diagram B f n a)) ∘
-            ( tr Q
-              ( coherence-cocone-sequential-diagram c' n
-                ( map-hom-sequential-diagram B f n a))))
-          ( γ n a)
+  opaque
+    γ :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      coherence-square-maps
+        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+        ( f∞n n a)
+        ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+    γ n a q =
+      γ-base n a q ∙
+      ap
+        ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+        ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a))
+
+  opaque
+    γ-flip :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      coherence-square-maps
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+        ( tr Q (inv (C n a)))
+        ( tr Q (inv (C (succ-ℕ n) (map-sequential-diagram A n a))))
+        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+    γ-flip n a =
+      vertical-inv-equiv-coherence-square-maps
+        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+        ( equiv-tr Q (C n a))
+        ( equiv-tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+        ( γ n a)
 
   comp-over-diagram :
     section-descent-data-sequential-colimit
@@ -889,11 +1016,528 @@ module _
       ( section-descent-data-section-family-cocone-sequential-colimit c P
         ( s∞ ∘ f∞))
       ( comp-over-diagram)
-  pr1 lemma-1-2 n a =
-    map-eq-transpose-equiv
-      ( equiv-tr Q (C n a))
-      ( apd s∞ (C n a) ∙ C' n (map-hom-sequential-diagram B f n a))
-  pr2 lemma-1-2 n a = {!!}
+  pr1 lemma-1-2 n =
+    invert-fiberwise-triangle
+      ( s∞ ∘ f∞ ∘ map-cocone-sequential-diagram c n)
+      ( map-section-dependent-sequential-diagram _ _ s n ∘ map-hom-sequential-diagram B f n)
+      ( λ a → equiv-tr Q (C n a))
+      ( λ a → apd s∞ (C n a) ∙ C' n (map-hom-sequential-diagram B f n a))
+  pr2 lemma-1-2 n = [i]
+    where
+    goal =
+      (pr2
+       (section-descent-data-section-family-cocone-sequential-colimit c P
+        (s∞ ∘ f∞))
+       n
+       ∙h
+       invert-fiberwise-triangle
+       (s∞ ∘ f∞ ∘ pr1 c (succ-ℕ n))
+       (pr1 s (succ-ℕ n) ∘ pr1 f (succ-ℕ n))
+       (λ a₁ →
+          equiv-tr Q
+          (C (succ-ℕ n) a₁))
+       (λ a₁ →
+          apd s∞ (C (succ-ℕ n) a₁) ∙
+          C' (succ-ℕ n) (pr1 f (succ-ℕ n) a₁))
+       ·r pr2 A n)
+      ~
+      ((λ {v} v₁ →
+          pr2 (dependent-sequential-diagram-descent-data P') n v v₁) ·l
+       invert-fiberwise-triangle
+       (s∞ ∘ f∞ ∘ pr1 c n)
+       (pr1 s n ∘ pr1 f n)
+       (λ a₁ →
+          equiv-tr Q
+          (C n a₁))
+       (λ a₁ →
+          apd s∞
+          (C n a₁) ∙
+          C' n (pr1 f n a₁))
+       ∙h
+       (λ a₁ →
+          γ-flip n a₁ (pr1 s n (pr1 f n a₁)) ∙
+          ap
+          (tr Q
+           (inv
+            (C (succ-ℕ n) (pr2 A n a₁))))
+          (ap (tr (Q ∘ pr1 c' (succ-ℕ n)) (pr2 f n a₁))
+           (pr2 s n (pr1 f n a₁))
+           ∙ apd (pr1 s (succ-ℕ n)) (pr2 f n a₁))))
+
+    opaque
+      [step-1] :
+        (a : family-sequential-diagram A n) →
+        ap
+          ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+          ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a)) ∙
+        ap
+          ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+          ( apd (s∞ ∘ f∞) (coherence-cocone-sequential-diagram c n a)) ＝
+        ap
+          ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+          ( apd s∞ (ap f∞ (coherence-cocone-sequential-diagram c n a)))
+      [step-1] a =
+        inv
+          ( ap-concat
+            ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+            ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a))
+            ( apd (s∞ ∘ f∞) (coherence-cocone-sequential-diagram c n a))) ∙
+        ap
+          ( ap (tr Q (C (succ-ℕ n) (map-sequential-diagram A n a))))
+          ( apd-left' f∞ s∞ (coherence-cocone-sequential-diagram c n a))
+      [step-2] :
+        (a : family-sequential-diagram A n) →
+        tr-concat
+          ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+          ( C (succ-ℕ n) (map-sequential-diagram A n a))
+          ( s∞ (f∞ (map-cocone-sequential-diagram c n a))) ∙
+        ap
+          ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+          ( apd s∞ (ap f∞ (coherence-cocone-sequential-diagram c n a))) ∙
+        apd s∞ (C (succ-ℕ n) (map-sequential-diagram A n a)) ＝
+        apd s∞
+          ( ap f∞ (coherence-cocone-sequential-diagram c n a) ∙
+            C (succ-ℕ n) (map-sequential-diagram A n a))
+      [step-2] a =
+        inv
+          ( apd-concat' s∞
+            ( ap f∞ (coherence-cocone-sequential-diagram c n a))
+            ( C (succ-ℕ n) (map-sequential-diagram A n a)))
+      [step-3] :
+        (a : family-sequential-diagram A n) →
+        ap
+          ( λ p → tr Q p (s∞ (f∞ (map-cocone-sequential-diagram c n a))))
+          ( inv
+            ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∙
+        apd s∞
+          ( ap f∞ (coherence-cocone-sequential-diagram c n a) ∙
+            C (succ-ℕ n) (map-sequential-diagram A n a)) ＝
+        apd s∞
+          ( C n a ∙
+            ( ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a)) ∙
+              ( ap
+                ( map-cocone-sequential-diagram c' (succ-ℕ n))
+                ( naturality-map-hom-sequential-diagram B f n a))))
+      [step-3] a =
+        apd-apd s∞ _ _
+          ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)
+      [step-4] :
+        (a : family-sequential-diagram A n) →
+        inv
+          ( tr-concat (C n a) _ (s∞ (f∞ (map-cocone-sequential-diagram c n a)))) ∙
+        apd s∞
+          ( C n a ∙
+            ( ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a)) ∙
+              ( ap
+                ( map-cocone-sequential-diagram c' (succ-ℕ n))
+                ( naturality-map-hom-sequential-diagram B f n a)))) ＝
+        ap
+          ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a) ∙ ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a)))
+          ( apd s∞ (C n a)) ∙
+        apd s∞ (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a) ∙ ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
+      [step-4] a =
+        inv
+          ( apd-concat s∞
+            ( C n a)
+            ( _))
+      [step-5] :
+        (a : family-sequential-diagram A n) →
+        inv
+          ( tr-concat
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))
+            ( ap
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a))
+            ( tr Q (C n a) (s∞ (f∞ (map-cocone-sequential-diagram c n a))))) ∙
+        ap
+          ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a) ∙ ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a)))
+          ( apd s∞ (C n a)) ＝
+        ap
+          ( tr Q
+            ( ap
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)) ∘
+            tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a)))
+          ( apd s∞ (C n a)) ∙
+        inv
+          ( tr-concat
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))
+            ( ap
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a))
+            ( s∞ (map-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
+      [step-5] a =
+        nat-htpy
+          ( inv-htpy
+            ( tr-concat
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a))
+              ( ap
+                ( map-cocone-sequential-diagram c' (succ-ℕ n))
+                ( naturality-map-hom-sequential-diagram B f n a))))
+          ( apd s∞ (C n a))
+      [step-6] :
+        (a : family-sequential-diagram A n) →
+        inv
+          ( tr-concat
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))
+            ( ap
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a))
+            ( s∞ (map-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a)))) ∙
+        apd s∞
+          ( ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a)) ∙
+            ( ap
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a))) ＝
+        ap
+          ( tr Q
+            ( ap
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)))
+          ( apd s∞
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))) ∙
+        apd s∞
+          ( ap
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+      [step-6] a = inv (apd-concat s∞ _ _)
+      [step-7] :
+        (a : family-sequential-diagram A n) →
+        inv
+          ( substitution-law-tr Q
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∙
+        ap
+          ( tr Q
+            ( ap
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)) ∘
+            tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a)))
+          ( apd s∞ (C n a)) ＝
+        ap
+          ( tr (Q ∘ pr1 c' (succ-ℕ n)) (pr2 f n a) ∘
+            tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a)))
+          ( apd s∞ (C n a)) ∙
+        inv
+        ( substitution-law-tr Q
+          ( map-cocone-sequential-diagram c' (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B f n a))
+      [step-7] a =
+        nat-htpy
+          ( inv-htpy
+            ( λ q →
+              substitution-law-tr Q
+                ( map-cocone-sequential-diagram c' (succ-ℕ n))
+                ( naturality-map-hom-sequential-diagram B f n a)
+                ))
+          ( apd s∞ (C n a))
+      [step-8] :
+        (a : family-sequential-diagram A n) →
+        inv
+          ( substitution-law-tr Q
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∙
+        ap
+          ( tr Q
+            ( ap
+              ( map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)))
+          ( apd s∞
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))) ＝
+        ap
+          ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( apd s∞
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))) ∙
+        inv
+          ( substitution-law-tr Q
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+      [step-8] a =
+        nat-htpy
+          ( inv-htpy
+            ( λ _ →
+              substitution-law-tr Q
+                ( map-cocone-sequential-diagram c' (succ-ℕ n))
+                ( naturality-map-hom-sequential-diagram B f n a)))
+          ( apd s∞
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a)))
+      [step-9] :
+        (a : family-sequential-diagram A n) →
+        inv
+          ( substitution-law-tr Q
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∙
+        apd s∞
+          ( ap
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ＝
+        apd
+          ( s∞ ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B f n a)
+      [step-9] a =
+        inv
+          ( apd-left
+            ( map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( s∞)
+            ( naturality-map-hom-sequential-diagram B f n a))
+      [step-10] :
+        (a : family-sequential-diagram A n) →
+        apd
+          ( s∞ ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B f n a) ∙
+        C'
+          ( succ-ℕ n)
+          ( map-hom-sequential-diagram B f
+            ( succ-ℕ n)
+            ( map-sequential-diagram A n a)) ＝
+        ap
+          ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( C'
+            ( succ-ℕ n)
+            ( map-sequential-diagram B n
+              ( map-hom-sequential-diagram B f n a))) ∙
+        apd
+          ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B f n a)
+      [step-10] a =
+        inv-dep-nat-htpy
+          ( C' (succ-ℕ n))
+          ( naturality-map-hom-sequential-diagram B f n a)
+      [step-11] :
+        (a : family-sequential-diagram A n) →
+        ap
+          ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( apd s∞
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))) ∙
+        ap
+          ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( C'
+            ( succ-ℕ n)
+            ( map-sequential-diagram B n
+              ( map-hom-sequential-diagram B f n a))) ＝
+        ap
+          ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( ap
+              ( tr Q
+                ( coherence-cocone-sequential-diagram c' n
+                  ( map-hom-sequential-diagram B f n a)))
+              ( C' n (map-hom-sequential-diagram B f n a)) ∙
+            naturality-map-section-dependent-sequential-diagram _ _ s n
+              ( map-hom-sequential-diagram B f n a))
+      [step-11] a =
+        inv
+          ( ap-concat
+            ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a))
+            ( apd s∞
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a)))
+            ( C'
+              ( succ-ℕ n)
+              ( map-sequential-diagram B n
+                ( map-hom-sequential-diagram B f n a)))) ∙
+        ap
+          ( ap
+            ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a)))
+          ( pr2 𝒞 n (map-hom-sequential-diagram B f n a))
+      [step-12] :
+        (a : family-sequential-diagram A n) →
+        ap
+          ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a) ∘
+            tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a)))
+          ( apd s∞ (C n a)) ∙
+        ap
+          ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( ap
+              ( tr Q
+                ( coherence-cocone-sequential-diagram c' n
+                  ( map-hom-sequential-diagram B f n a)))
+              ( C' n (map-hom-sequential-diagram B f n a)) ∙
+            naturality-map-section-dependent-sequential-diagram _ _ s n
+              ( map-hom-sequential-diagram B f n a)) ＝
+        ap
+          ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a) ∘
+            tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n a)))
+          ( apd s∞ (C n a) ∙
+            C' n (map-hom-sequential-diagram B f n a)) ∙
+        ap
+          ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a))
+          ( naturality-map-section-dependent-sequential-diagram _ _ s n
+            ( map-hom-sequential-diagram B f n a))
+      open import foundation.whiskering-identifications-concatenation
+      [step-12] a =
+        left-whisker-concat-coherence-triangle-identifications
+          ( ap _ (apd s∞ (C n a)))
+          _ _ _
+          ( ap-concat
+            ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n a))
+            ( ap
+              ( tr Q
+                ( coherence-cocone-sequential-diagram c' n
+                  ( map-hom-sequential-diagram B f n a)))
+              ( C' n (map-hom-sequential-diagram B f n a)))
+            ( naturality-map-section-dependent-sequential-diagram _ _ s n
+              ( map-hom-sequential-diagram B f n a)) ∙
+            right-whisker-concat
+              ( inv
+                ( ap-comp
+                  ( tr
+                    ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+                    ( naturality-map-hom-sequential-diagram B f n a))
+                  ( tr Q
+                    ( coherence-cocone-sequential-diagram c' n
+                      ( map-hom-sequential-diagram B f n a)))
+                  ( C' n (map-hom-sequential-diagram B f n a))))
+              ( _)) ∙
+        right-whisker-concat
+          ( inv
+            (ap-concat
+              ( tr
+                  ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+                  ( naturality-map-hom-sequential-diagram B f n a) ∘
+                tr Q
+                  ( coherence-cocone-sequential-diagram c' n
+                    ( map-hom-sequential-diagram B f n a)))
+              ( apd s∞ (C n a))
+              ( C' n (map-hom-sequential-diagram B f n a))))
+          ( _)
+
+    opaque
+      unfolding γ γ-base γ-flip
+
+      [i] : goal
+      [i] =
+        transpose-sq
+          ( map-sequential-diagram A n)
+          ( s∞ ∘ f∞ ∘ map-cocone-sequential-diagram c n)
+          ( s∞ ∘ f∞ ∘ map-cocone-sequential-diagram c (succ-ℕ n))
+          ( map-section-dependent-sequential-diagram _ _ s n ∘ map-hom-sequential-diagram B f n)
+          ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n) ∘ map-hom-sequential-diagram B f (succ-ℕ n))
+          ( λ q → tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n _) q)
+          ( ( tr
+              ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+              ( naturality-map-hom-sequential-diagram B f n _)) ∘
+            ( tr Q
+              ( coherence-cocone-sequential-diagram c' n
+                ( map-hom-sequential-diagram B f n _))))
+          ( λ {a} → equiv-tr Q (C n a))
+          ( λ {a} → equiv-tr Q (C (succ-ℕ n) a))
+          ( λ a → apd (s∞ ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+          ( γ n _)
+          ( λ a → apd s∞ (C (succ-ℕ n) a) ∙ C' (succ-ℕ n) (map-hom-sequential-diagram B f (succ-ℕ n) a))
+          ( λ a → apd s∞ (C n a) ∙ C' n (map-hom-sequential-diagram B f n a))
+          ( λ a →
+            ap
+              ( tr (Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
+              ( naturality-map-section-dependent-sequential-diagram _ _ s n (map-hom-sequential-diagram B f n a)) ∙
+            apd (map-section-dependent-sequential-diagram _ _ s (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
+          ( λ a →
+            ( left-whisker-concat
+              ( γ n a (s∞ (f∞ (map-cocone-sequential-diagram c n a))))
+              ( inv (assoc _ _ _))) ∙
+            ( inv (assoc _ _ _)) ∙
+            ( right-whisker-concat
+              ( ( right-whisker-concat-coherence-triangle-identifications' _ _ _
+                  ( apd s∞ (C (succ-ℕ n) (map-sequential-diagram A n a)))
+                  ( assoc _ _ _ ∙
+                    left-whisker-concat
+                      ( γ-base n a (s∞ (f∞ (map-cocone-sequential-diagram c n a))))
+                      ( [step-1] a) ∙
+                    assoc _ _ _)) ∙
+                ( assoc _ _ _) ∙
+                ( left-whisker-concat
+                  ( _)
+                  ( [step-2] a)) ∙
+                ( left-whisker-concat-coherence-triangle-identifications' _ _ _ _
+                  ( [step-3] a)) ∙
+                ( left-whisker-concat-coherence-triangle-identifications' _ _ _ _
+                  ( [step-4] a)) ∙
+                ( left-whisker-concat-coherence-triangle-identifications' _ _ _ _
+                  ( ( right-whisker-concat-coherence-triangle-identifications' _ _ _
+                      ( apd s∞ _)
+                      ( [step-5] a)) ∙
+                  ( ( left-whisker-concat-coherence-triangle-identifications' _ _ _ _
+                      ( [step-6] a)))) ∙
+                ( right-whisker-concat-coherence-square-identifications _ _ _ _
+                  ( [step-7] a)
+                  ( _)) ∙
+                ( left-whisker-concat _
+                  ( ( right-whisker-concat-coherence-square-identifications _ _ _ _
+                      ( [step-8] a)
+                      ( _)) ∙
+                    ( left-whisker-concat _
+                      ( [step-9] a))))))
+              ( C'
+                ( succ-ℕ n)
+                ( map-hom-sequential-diagram B f (succ-ℕ n)
+                  ( map-sequential-diagram A n a)))) ∙
+            ( assoc _ _ _) ∙
+            ( left-whisker-concat-coherence-triangle-identifications
+              ( ap
+                ( tr
+                    ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+                    ( naturality-map-hom-sequential-diagram B f n a) ∘
+                  tr Q
+                    ( coherence-cocone-sequential-diagram c' n
+                      ( map-hom-sequential-diagram B f n a)))
+                ( apd s∞ (C n a)))
+              _ _ _
+              ( ( left-whisker-concat-coherence-square-identifications _ _ _ _ _
+                  ( [step-10] a)) ∙
+                ( right-whisker-concat
+                  ( [step-11] a)
+                  ( _)))) ∙
+            ( right-whisker-concat
+              ( [step-12] a)
+              ( apd
+                ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+                ( naturality-map-hom-sequential-diagram B f n a))) ∙
+            ( assoc _ _ _))
 
   lemma-1 :
     s∞ ∘ f∞ ~ sect-family-sect-dd-sequential-colimit up-c P comp-over-diagram
@@ -999,3 +1643,165 @@ module _
       inv-htpy lemma-1
 ```
 
+```agda
+module _
+  {l1 l2 l3 l4 l5 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (f : hom-sequential-diagram A B)
+  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (Q : Y → UU l5)
+  (let Q' = descent-data-family-cocone-sequential-diagram c (Q ∘ f∞))
+  where
+
+  comp-over-diagram' :
+  -- For now restricted to l5
+    (P : X → UU l5)
+    (let P' = descent-data-family-cocone-sequential-diagram c P)
+    (e' : fam-equiv P (Q ∘ f∞))
+    (s : section-descent-data-sequential-colimit P')
+    (let s∞ = sect-family-sect-dd-sequential-colimit up-c P s) →
+    section-descent-data-sequential-colimit Q'
+  pr1 (comp-over-diagram' P e' s) n a =
+    map-fam-equiv e'
+      ( map-cocone-sequential-diagram c n a)
+      ( map-section-dependent-sequential-diagram _ _ s n a)
+  pr2 (comp-over-diagram' P e' s) n a =
+    inv
+      ( preserves-tr
+        ( map-fam-equiv e')
+        ( coherence-cocone-sequential-diagram c n a)
+        ( map-section-dependent-sequential-diagram _ _ s n a)) ∙
+    ap
+      ( map-fam-equiv e'
+        ( map-cocone-sequential-diagram c (succ-ℕ n)
+        ( map-sequential-diagram A n a)))
+      ( naturality-map-section-dependent-sequential-diagram _ _ s n a)
+
+  compute-comp-over-diagram' :
+    (s : section-descent-data-sequential-colimit Q') →
+    htpy-section-dependent-sequential-diagram
+      ( comp-over-diagram' (Q ∘ f∞) id-fam-equiv s)
+      ( s)
+  pr1 (compute-comp-over-diagram' s) n = refl-htpy
+  pr2 (compute-comp-over-diagram' s) n a =
+    right-unit ∙
+    ap-binary
+      ( _∙_)
+      ( ap
+        ( inv)
+        ( compute-preserves-tr-id
+          ( coherence-cocone-sequential-diagram c n a)
+          ( map-section-dependent-sequential-diagram _ _ s n a)))
+      ( ap-id (naturality-map-section-dependent-sequential-diagram _ _ s n a))
+
+  theorem' :
+    (P : X → UU l5)
+    (let P' = descent-data-family-cocone-sequential-diagram c P)
+    (e' : fam-equiv P (Q ∘ f∞))
+    (s : section-descent-data-sequential-colimit P')
+    (let s∞ = sect-family-sect-dd-sequential-colimit up-c P s) →
+    sect-family-sect-dd-sequential-colimit up-c (Q ∘ f∞)
+      ( comp-over-diagram' P e' s) ~
+    (map-fam-equiv e' _ ∘ s∞)
+  theorem' P =
+    ind-fam-equiv'
+      ( λ P e' →
+        let P' = descent-data-family-cocone-sequential-diagram c P in
+        (s : section-descent-data-sequential-colimit P') →
+        sect-family-sect-dd-sequential-colimit up-c (Q ∘ f∞)
+          ( comp-over-diagram' P e' s) ~
+        map-fam-equiv e' _ ∘ sect-family-sect-dd-sequential-colimit up-c P s)
+      ( λ s →
+        htpy-colimit-htpy-diagram-section up-c (Q ∘ f∞) _ _
+          ( compute-comp-over-diagram' s))
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (f : hom-sequential-diagram A B)
+  {P : X → UU l5} {Q : Y → UU l5}
+  (let
+    P' = descent-data-family-cocone-sequential-diagram c P
+    Q' = descent-data-family-cocone-sequential-diagram c' Q
+    f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (s : section-descent-data-sequential-colimit P')
+  (t : section-descent-data-sequential-colimit Q')
+  (let
+    s∞ = sect-family-sect-dd-sequential-colimit up-c P s
+    t∞ = sect-family-sect-dd-sequential-colimit up-c' Q t)
+  (e : fam-equiv P (Q ∘ f∞))
+  (let C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (let
+    f∞n =
+      λ n a →
+      tr Q (C n a) ∘ map-fam-equiv e (map-cocone-sequential-diagram c n a))
+  where
+
+
+  -- TODO: cleanup
+  -- - make γ into a proper definition
+  -- - pasting of squares
+  -- - find the right lemmas
+  square-colimit-cube-diagram :
+    (F :
+      (n : ℕ) →
+      f∞n n _ ∘ map-section-dependent-sequential-diagram _ _ s n ~
+      map-section-dependent-sequential-diagram _ _ t n ∘
+      map-hom-sequential-diagram B f n) →
+    ((n : ℕ) →
+      section-square-over
+        ( map-sequential-diagram A n)
+        ( map-hom-sequential-diagram B f n)
+        ( map-hom-sequential-diagram B f (succ-ℕ n))
+        ( map-sequential-diagram B n)
+        ( λ {a} → map-family-descent-data-sequential-colimit P' n a)
+        ( λ {a} → f∞n n a)
+        ( λ {a} → f∞n (succ-ℕ n) a)
+        ( λ {b} → map-family-descent-data-sequential-colimit Q' n b)
+        ( map-section-dependent-sequential-diagram _ _ s n)
+        ( map-section-dependent-sequential-diagram _ _ t n)
+        ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+        ( map-section-dependent-sequential-diagram _ _ t (succ-ℕ n))
+        ( naturality-map-section-dependent-sequential-diagram _ _ s n)
+        ( F n)
+        ( F (succ-ℕ n))
+        ( naturality-map-section-dependent-sequential-diagram _ _ t n)
+        ( naturality-map-hom-sequential-diagram B f n)
+        ( λ p →
+          γ up-c up-c' Q f t n _ (map-fam-equiv e _ p) ∙
+          ap
+            ( tr Q (C (succ-ℕ n) _))
+            ( inv
+              ( preserves-tr
+                ( map-fam-equiv e)
+                ( coherence-cocone-sequential-diagram c n _) p)))) →
+    map-fam-equiv e _ ∘ s∞ ~ t∞ ∘ f∞
+  square-colimit-cube-diagram F cubes =
+    inv-htpy (theorem' up-c up-c' f Q P e s) ∙h
+    theorem up-c up-c' Q f t _ F
+      (λ n a →
+        assoc _ _ _ ∙
+        ap
+          ( γ up-c up-c' Q f t n a (map-fam-equiv e (map-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a)) ∙_)
+          ( ap
+            ( _∙ F (succ-ℕ n) (map-sequential-diagram A n a))
+            ( ap-concat (tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+              ( inv (preserves-tr (map-fam-equiv e) (coherence-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a)))
+              ( ap (map-fam-equiv e (map-cocone-sequential-diagram c (succ-ℕ n) (map-sequential-diagram A n a))) (naturality-map-section-dependent-sequential-diagram _ _ s n a)) ∙
+              ap
+                ( ap (tr Q (C (succ-ℕ n) (map-sequential-diagram A n a))) (inv (preserves-tr (map-fam-equiv e) (coherence-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a))) ∙_)
+                ( inv (ap-comp (tr Q (C (succ-ℕ n) _)) (map-fam-equiv e _) (naturality-map-section-dependent-sequential-diagram _ _ s n a)))) ∙
+          assoc _ _ _) ∙ inv (assoc _ _ _) ∙ inv (assoc _ _ _) ∙ cubes n a)
+```

From d55fd6c755a7379c3e268eec2419fcd9fa8246c2 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Tue, 18 Mar 2025 00:28:24 +0100
Subject: [PATCH 27/33] Down to a single easy coherence

---
 .../families-of-equivalences.lagda.md         |   18 +
 .../dependent-identifications.lagda.md        |    8 +
 ...dentifications-along-equivalences.lagda.md |   11 +
 .../functoriality-stuff.lagda.md              | 1034 ++++++++----
 .../shifts-sequential-diagrams.lagda.md       |   25 +-
 .../stuff-over.lagda.md                       | 1387 +++++++++--------
 ...nstruction-identity-type-pushouts.lagda.md |  906 ++++++-----
 7 files changed, 2015 insertions(+), 1374 deletions(-)

diff --git a/src/foundation-core/families-of-equivalences.lagda.md b/src/foundation-core/families-of-equivalences.lagda.md
index a3578dcaaa..713a875d28 100644
--- a/src/foundation-core/families-of-equivalences.lagda.md
+++ b/src/foundation-core/families-of-equivalences.lagda.md
@@ -84,6 +84,24 @@ module _
   is-equiv-map-fam-equiv x = is-equiv-map-equiv (e x)
 ```
 
+### Inverses of families of equivalences
+
+```agda
+module _
+  {l1 l2 l3 : Level} {A : UU l1} {P : A → UU l2} {Q : A → UU l3}
+  (e : fam-equiv P Q)
+  where
+
+  inv-fam-equiv : fam-equiv Q P
+  inv-fam-equiv a = inv-equiv (e a)
+
+  map-inv-fam-equiv : (a : A) → Q a → P a
+  map-inv-fam-equiv = map-fam-equiv inv-fam-equiv
+
+  is-equiv-map-inv-fam-equiv : is-fiberwise-equiv map-inv-fam-equiv
+  is-equiv-map-inv-fam-equiv = is-equiv-map-fam-equiv inv-fam-equiv
+```
+
 ## Properties
 
 ### Families of equivalences are equivalent to fiberwise equivalences
diff --git a/src/foundation/dependent-identifications.lagda.md b/src/foundation/dependent-identifications.lagda.md
index 77743467f5..7267f431ab 100644
--- a/src/foundation/dependent-identifications.lagda.md
+++ b/src/foundation/dependent-identifications.lagda.md
@@ -124,6 +124,14 @@ module _
     ( q' : dependent-identification B q y' z') →
     concat-dependent-identification refl q p' q' ＝ ap (tr B q) p' ∙ q'
   compute-concat-dependent-identification-left-base-refl q p' q' = refl
+
+  compute-concat-dependent-identification :
+    {x y z : A} (p : x ＝ y) (q : y ＝ z) →
+    {x' : B x} {y' : B y} {z' : B z} →
+    (p' : dependent-identification B p x' y') →
+    (q' : dependent-identification B q y' z') →
+    concat-dependent-identification p q p' q' ＝ tr-concat p q x' ∙ ap (tr B q) p' ∙ q'
+  compute-concat-dependent-identification refl q p' q' = refl
 ```
 
 #### Strictly right unital concatenation of dependent identifications
diff --git a/src/foundation/transposition-identifications-along-equivalences.lagda.md b/src/foundation/transposition-identifications-along-equivalences.lagda.md
index ef7e0b1cc7..b7bd10a460 100644
--- a/src/foundation/transposition-identifications-along-equivalences.lagda.md
+++ b/src/foundation/transposition-identifications-along-equivalences.lagda.md
@@ -127,6 +127,11 @@ module _
     {a : A} {b : B} → map-inv-equiv e b ＝ a → b ＝ map-equiv e a
   map-inv-eq-transpose-equiv-inv {a} {b} =
     map-inv-equiv (eq-transpose-equiv-inv a b)
+
+  map-eq-transpose-equiv-inv' :
+    {a : A} {b : B} → b ＝ map-equiv e a → map-inv-equiv e b ＝ a
+  map-eq-transpose-equiv-inv' {a} {b} p =
+    ap (map-inv-equiv e) p ∙ is-retraction-map-inv-equiv e a
 ```
 
 ## Properties
@@ -155,6 +160,12 @@ module _
       ( equiv-ap e _ _)
       ( ( right-unit) ∙
         ( coherence-map-inv-equiv e _))
+
+  compute-refl-eq-transpose-equiv-inv' :
+    {x : A} →
+    map-eq-transpose-equiv-inv' e refl ＝ is-retraction-map-inv-equiv e x
+  compute-refl-eq-transpose-equiv-inv' =
+    refl
 ```
 
 ### The two definitions of transposing identifications along equivalences are homotopic
diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index 30e5bf3280..6164d0acb0 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -1,7 +1,7 @@
 # Functoriality stuff
 
 ```agda
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
 
 module synthetic-homotopy-theory.functoriality-stuff where
 ```
@@ -110,183 +110,6 @@ module _
     dependent-cocone-map-sequential-diagram c P
 ```
 
--- ```agda
--- module big-thm
---   {l1 l2 l3 l4 l5 l6 : Level}
---   {A : sequential-diagram l1}
---   {B : sequential-diagram l2}
---   {X : UU l3} {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   {Y : UU l4} {c' : cocone-sequential-diagram B Y}
---   (up-c' : universal-property-sequential-colimit c')
---   (H : hom-sequential-diagram A B)
---   where
-
---   -- the squares induce a map
-
---   f∞ : X → Y
---   f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' H
-
---   Cn : (n : ℕ) →
---     f∞ ∘ map-cocone-sequential-diagram c n ~
---     map-cocone-sequential-diagram c' n ∘ map-hom-sequential-diagram B H n
---   Cn =
---     htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H
-
---   module _
---     (P : X → UU l5) (Q : Y → UU l6)
---     (f'∞ : {x : X} → P x → Q (f∞ x))
---     where
-
---     An : ℕ → UU l1
---     An = family-sequential-diagram A
---     Bn : ℕ → UU l2
---     Bn = family-sequential-diagram B
---     an : {n : ℕ} → An n → An (succ-ℕ n)
---     an = map-sequential-diagram A _
---     bn : {n : ℕ} → Bn n → Bn (succ-ℕ n)
---     bn = map-sequential-diagram B _
---     fn : {n : ℕ} → An n → Bn n
---     fn = map-hom-sequential-diagram B H _
---     Hn : {n : ℕ} → bn {n} ∘ fn ~ fn ∘ an
---     Hn = naturality-map-hom-sequential-diagram B H _
-
---     -- a map-over induces squares-over
-
---     -- first, the sequences-over:
---     𝒟P : descent-data-sequential-colimit A l5
---     𝒟P = descent-data-family-cocone-sequential-diagram c P
---     𝒫 = dependent-sequential-diagram-descent-data 𝒟P
---     𝒟Q : descent-data-sequential-colimit B l6
---     𝒟Q = descent-data-family-cocone-sequential-diagram c' Q
---     𝒬 = dependent-sequential-diagram-descent-data 𝒟Q
-
---     Pn : {n : ℕ} → An n → UU l5
---     Pn = family-descent-data-sequential-colimit 𝒟P _
---     Qn : {n : ℕ} → Bn n → UU l6
---     Qn = family-descent-data-sequential-colimit 𝒟Q _
-
---     pn : {n : ℕ} (a : An n) → Pn a → Pn (an a)
---     pn = map-family-descent-data-sequential-colimit 𝒟P _
---     qn : {n : ℕ} (b : Bn n) → Qn b → Qn (bn b)
---     qn = map-family-descent-data-sequential-colimit 𝒟Q _
-
---     -- then, the maps over homs
---     f'∞n : {n : ℕ} (a : An n) → Pn a → Qn (fn a)
---     f'∞n a =
---       ( tr Q
---         ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
---           ( H)
---           ( _)
---           ( a))) ∘
---       ( f'∞)
-
---     -- then, the squares-over
---     f'∞n-square-over :
---       {n : ℕ} →
---       square-over {Q4 = Qn} (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _) Hn
---     f'∞n-square-over {n} {a} =
---       pasting-vertical-coherence-square-maps
---         ( tr P (coherence-cocone-sequential-diagram c n a))
---         ( f'∞)
---         ( f'∞)
---         ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
---         ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H _ a))
---         ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H _ (an a)))
---         ( ( tr
---             ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---             ( Hn a)) ∘
---           ( tr Q (coherence-cocone-sequential-diagram c' n (fn a))))
---         ( λ q →
---           substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
---           inv (preserves-tr (λ p → f'∞ {p}) (coherence-cocone-sequential-diagram c n a) q))
---         ( ( inv-htpy
---             ( λ q →
---               ( tr-concat
---                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                   up-c c' H n a)
---                 ( _)
---                 ( q)) ∙
---               ( tr-concat
---                 ( coherence-cocone-sequential-diagram c' n (fn a))
---                 ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (Hn a))
---                 ( tr Q
---                   ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                     up-c c' H n a)
---                   ( q))) ∙
---               ( substitution-law-tr Q
---                 ( map-cocone-sequential-diagram c' (succ-ℕ n))
---                 ( Hn a)))) ∙h
---           ( λ q →
---             ap
---               ( λ p → tr Q p q)
---               ( inv
---                 ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' H n a))) ∙h
---           ( tr-concat
---             ( ap f∞ (coherence-cocone-sequential-diagram c n a))
---             ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---               up-c c' H (succ-ℕ n) (an a))))
-
---     thm :
---       (sA : section-dependent-sequential-diagram A 𝒫) →
---       (sB : section-dependent-sequential-diagram B 𝒬) →
---       (S : (n : ℕ) →
---         section-map-over (fn {n}) (f'∞n _)
---           ( map-section-dependent-sequential-diagram A 𝒫 sA n)
---           ( map-section-dependent-sequential-diagram B 𝒬 sB n)) →
---       ((n : ℕ) →
---         section-square-over (an {n}) fn fn bn (pn _) (f'∞n _) (f'∞n _) (qn _)
---           ( map-section-dependent-sequential-diagram A 𝒫 sA n)
---           ( map-section-dependent-sequential-diagram B 𝒬 sB n)
---           ( map-section-dependent-sequential-diagram A 𝒫 sA (succ-ℕ n))
---           ( map-section-dependent-sequential-diagram B 𝒬 sB (succ-ℕ n))
---           ( naturality-map-section-dependent-sequential-diagram A 𝒫 sA n)
---           ( S n)
---           ( S (succ-ℕ n))
---           ( naturality-map-section-dependent-sequential-diagram B 𝒬 sB n)
---           ( Hn)
---           ( f'∞n-square-over)) →
---       section-map-over f∞ f'∞
---         ( sect-family-sect-dd-sequential-colimit up-c P sA)
---         ( sect-family-sect-dd-sequential-colimit up-c' Q sB)
---     thm sA sB S α =
---       map-dependent-universal-property-sequential-colimit
---         ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
---         ( tS ,
---           ( λ n a →
---             map-compute-dependent-identification-eq-value
---               ( f'∞ ∘ sA∞)
---               ( sB∞ ∘ f∞)
---               ( coherence-cocone-sequential-diagram c n a)
---               ( tS n a)
---               ( tS (succ-ℕ n) (an a))
---               ( {!f'∞n-square-over!})))
---       where
---         sA∞ : (x : X) → P x
---         sA∞ = sect-family-sect-dd-sequential-colimit up-c P sA
---         sB∞ : (y : Y) → Q y
---         sB∞ = sect-family-sect-dd-sequential-colimit up-c' Q sB
---         tS :
---           (n : ℕ) →
---           (f'∞ ∘ sA∞ ∘ (map-cocone-sequential-diagram c n)) ~
---           (sB∞ ∘ f∞ ∘ map-cocone-sequential-diagram c n)
---         tS n a =
---           ap f'∞
---             ( pr1
---               ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
---                 ( dependent-universal-property-universal-property-sequential-colimit _ up-c)
---                 ( sA)) n a) ∙
---           map-equiv
---             ( inv-equiv-ap-emb (emb-equiv (equiv-tr Q (Cn n a))))
---             ( S n a ∙
---               inv
---                 ( apd sB∞ (Cn n a) ∙
---                   pr1
---                     ( htpy-dependent-cocone-dependent-universal-property-sequential-colimit
---                       ( dependent-universal-property-universal-property-sequential-colimit _ up-c')
---                       ( sB)) n (fn a)))
-```
-
 ```agda
 module _
   {l1 l2 : Level} {A : sequential-diagram l1}
@@ -439,10 +262,10 @@ module _
   (H : (a : A) → map-equiv (e a) (s a) ＝ t a)
   where
 
+  -- the rest of the proof relies on the implementation of
+  -- map-eq-transpose-equiv', which is probably not the best idea
   invert-fiberwise-triangle : (a : A) → s a ＝ map-inv-equiv (e a) (t a)
-  invert-fiberwise-triangle a =
-    inv (is-retraction-map-inv-equiv (e a) (s a)) ∙
-    ap (map-inv-equiv (e a)) (H a)
+  invert-fiberwise-triangle a = map-eq-transpose-equiv' (e a) (H a)
 
   invert-fiberwise-triangle' : (a : A) → map-inv-equiv (e a) (t a) ＝ s a
   invert-fiberwise-triangle' a =
@@ -501,9 +324,7 @@ module _
   (let inv-F' = invert-fiberwise-triangle' t t' (λ b → j {b}) F)
   (H : (a : A) → g (s a) ＝ s' a)
   (let inv-H = invert-fiberwise-triangle s s' (λ a → e {a}) H)
-  -- (X : (a : A) → f'' (g (s a)) ＝ t' (f a))
   (X : (a : A) → f'' (s' a) ＝ t' (f a))
-  -- (α : (a : A) → G (s a) ∙ (ap h (T a) ∙ F (f a)) ＝ X a)
   (α : (a : A) → G (s a) ∙ (ap h (T a) ∙ F (f a)) ＝ ap f'' (H a) ∙ X a)
   where
 
@@ -864,51 +685,58 @@ module _
       right (h a))
 ```
 
+TODO: this should be parameterized by a fiberwise map, not equivalence
+
 ```agda
 module _
-  {l1 l2 l3 l4 l5 : Level}
+  {l1 l2 l3 l4 l5 l6 : Level}
   {A : sequential-diagram l1} {X : UU l2}
   {c : cocone-sequential-diagram A X}
   (up-c : universal-property-sequential-colimit c)
   {B : sequential-diagram l3} {Y : UU l4}
-  {c' : cocone-sequential-diagram B Y}
-  (up-c' : universal-property-sequential-colimit c')
-  (let
-    dup-c' =
-      dependent-universal-property-universal-property-sequential-colimit _ up-c')
-  (Q : Y → UU l5)
-  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
+  (c' : cocone-sequential-diagram B Y)
   (f : hom-sequential-diagram A B)
   (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
-  (let P = Q ∘ f∞)
-  (let P' = descent-data-family-cocone-sequential-diagram c P)
-  (let C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
-  (let f∞n = λ n a → tr Q (C n a))
-  (s : section-descent-data-sequential-colimit Q')
-  (let s∞ = sect-family-sect-dd-sequential-colimit up-c' Q s)
   (let
-    𝒞 =
-      htpy-dependent-cocone-dependent-universal-property-sequential-colimit
-        ( dup-c')
-        ( s))
-  (let C' = htpy-htpy-dependent-cocone-sequential-diagram Q 𝒞)
+    C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (P : X → UU l5)
+  (let P' = descent-data-family-cocone-sequential-diagram c P)
+  (Q : Y → UU l6)
+  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
+  (e : fam-equiv P (Q ∘ f∞))
   where
 
-  -- private
+  equiv-over-diagram-equiv-over-colimit :
+    (n : ℕ) (a : family-sequential-diagram A n) →
+    family-descent-data-sequential-colimit P' n a ≃
+    family-descent-data-sequential-colimit Q' n
+      ( map-hom-sequential-diagram B f n a)
+  equiv-over-diagram-equiv-over-colimit n a =
+    equiv-tr Q (C n a) ∘e
+    e (map-cocone-sequential-diagram c n a)
+
+  map-over-diagram-equiv-over-colimit :
+    (n : ℕ) (a : family-sequential-diagram A n) →
+    family-descent-data-sequential-colimit P' n a →
+    family-descent-data-sequential-colimit Q' n
+      ( map-hom-sequential-diagram B f n a)
+  map-over-diagram-equiv-over-colimit n a =
+    map-equiv (equiv-over-diagram-equiv-over-colimit n a)
+
   opaque
-    γ-base :
+    γ-base' :
       (n : ℕ) (a : family-sequential-diagram A n) →
       coherence-square-maps
         ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
-        ( f∞n n a)
-        ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
+        ( tr Q (C n a))
+        ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
         ( ( tr
             ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
             ( naturality-map-hom-sequential-diagram B f n a)) ∘
           ( tr Q
             ( coherence-cocone-sequential-diagram c' n
               ( map-hom-sequential-diagram B f n a))))
-    γ-base n a q =
+    γ-base' n a q =
       inv
         ( substitution-law-tr Q
           ( map-cocone-sequential-diagram c' (succ-ℕ n))
@@ -933,24 +761,706 @@ module _
         ( q)
 
   opaque
-    γ :
+    γ' :
       (n : ℕ) (a : family-sequential-diagram A n) →
       coherence-square-maps
         ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
-        ( f∞n n a)
-        ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
+        ( tr Q (C n a))
+        ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
         ( ( tr
             ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
             ( naturality-map-hom-sequential-diagram B f n a)) ∘
           ( tr Q
             ( coherence-cocone-sequential-diagram c' n
               ( map-hom-sequential-diagram B f n a))))
-    γ n a q =
-      γ-base n a q ∙
+    γ' n a q =
+      γ-base' n a q ∙
       ap
         ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
         ( substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a))
 
+  opaque
+    square-over-diagram-square-over-colimit :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      coherence-square-maps
+        ( tr P (coherence-cocone-sequential-diagram c n a))
+        ( map-over-diagram-equiv-over-colimit n a)
+        ( map-over-diagram-equiv-over-colimit
+          ( succ-ℕ n)
+          ( map-sequential-diagram A n a))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+    square-over-diagram-square-over-colimit n a =
+      pasting-vertical-coherence-square-maps
+        ( tr P (coherence-cocone-sequential-diagram c n a))
+        ( map-fam-equiv e (map-cocone-sequential-diagram c n a))
+        ( map-fam-equiv e (map-cocone-sequential-diagram c (succ-ℕ n) (map-sequential-diagram A n a)))
+        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+        ( tr Q (C n a))
+        ( tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+        ( inv-htpy
+          ( preserves-tr
+            ( map-fam-equiv e)
+            ( coherence-cocone-sequential-diagram c n a)))
+        ( γ' n a)
+
+module _
+  {l1 l2 l3 l4 l5 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  (c' : cocone-sequential-diagram B Y)
+  (f : hom-sequential-diagram A B)
+  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (Q : Y → UU l5)
+  where
+
+  opaque
+    unfolding square-over-diagram-square-over-colimit
+
+    compute-square-over-diagram-id :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      square-over-diagram-square-over-colimit up-c c' f (Q ∘ f∞) Q id-fam-equiv n a ~
+      γ' up-c c' f (Q ∘ f∞) Q id-fam-equiv n a
+    compute-square-over-diagram-id n a q =
+      ap
+        ( λ r →
+          γ' up-c c' f (Q ∘ f∞) Q id-fam-equiv n a q ∙
+          ap (tr Q _) (inv r))
+        ( compute-preserves-tr-id (coherence-cocone-sequential-diagram c n a) q) ∙
+      right-unit
+```
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+  open import foundation.dependent-identifications
+
+  compute-inv-dependent-identification-inv :
+    {x y : A} (p : x ＝ y) {x' : B x} {y' : B y}
+    (q : y' ＝ tr B p x') →
+    inv-dependent-identification B p (inv q) ＝
+    map-eq-transpose-equiv-inv' (equiv-tr B p) q
+  compute-inv-dependent-identification-inv refl q = inv-inv q ∙ inv (right-unit ∙ ap-id q)
+
+module _
+  {l1 l2 : Level} {A : UU l1} {B : UU l2}
+  (e : A ≃ B)
+  where
+
+  compute-eq-transpose-equiv-inv-concat' :
+    {x : A} {b c : B} (p : b ＝ c) (q : c ＝ map-equiv e x) →
+    map-eq-transpose-equiv-inv' e (p ∙ q) ＝
+    ap (map-inv-equiv e) p ∙ map-eq-transpose-equiv-inv' e q
+  compute-eq-transpose-equiv-inv-concat' refl q = refl
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 l6 l7 : Level}
+  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l7}
+  {P : A → UU l4} {P' : B → UU l5} {Q' : C → UU l6}
+  {h : A → B} (h' : (a : A) → P a → P' (h a))
+  {l : A → D} (j : D → C) (l' : (a : A) → P a → Q' (j (l a)))
+  (s : (a : A) → P' (h a) → Q' (j (l a)))
+  {k : D → B} (t : (a : A) → Q' (j (l a)) → P' (k (l a)))
+  (U : h ~ k ∘ l)
+  (H : (a : A) (p : P a) → l' a p ＝ s a (h' a p))
+  (K : (a : A) (p : P' (h a)) → t a (s a p) ＝ tr P' (U a) p)
+  where
+  open import foundation.dependent-identifications
+
+  compute-lemma :
+    (a : A) (p : P a) →
+    inv-dependent-identification P' (U a)
+      ( inv
+        ( ap (t a) (H a p) ∙
+          K a (h' a p))) ＝
+    ap
+      ( tr P' (inv (U a)) ∘ t a)
+      ( H a p) ∙
+    inv-dependent-identification P' (U a)
+      ( inv (K a (h' a p)))
+  compute-lemma a p =
+    compute-inv-dependent-identification (U a) _ ∙
+    ap
+      ( map-eq-transpose-equiv-inv' (equiv-tr P' (U a)))
+      ( inv-inv _) ∙
+    ap
+      ( _∙ is-retraction-map-inv-equiv (equiv-tr P' (U a)) _)
+      ( ap-concat (tr P' (inv (U a))) _ _) ∙
+    assoc _ _ _ ∙
+    ap
+      (_∙ map-eq-transpose-equiv-inv' (equiv-tr P' (U a)) (K a (h' a p)))
+      ( inv (ap-comp (tr P' (inv (U a))) (t a) (H a p))) ∙
+    ap
+      ( ap (tr P' (inv (U a)) ∘ t a) (H a p) ∙_)
+      ( inv
+        ( compute-inv-dependent-identification (U a) _ ∙
+          ap (map-eq-transpose-equiv-inv' (equiv-tr P' (U a))) (inv-inv _)))
+```
+
+```agda
+open import synthetic-homotopy-theory.zigzags-sequential-diagrams
+module _
+  {l1 l2 l3 l4 l5 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  (c' : cocone-sequential-diagram B Y)
+  (z : zigzag-sequential-diagram A B)
+  (let f = hom-diagram-zigzag-sequential-diagram z)
+  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (let
+    C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (P : X → UU l5)
+  (let P' = descent-data-family-cocone-sequential-diagram c P)
+  (Q : Y → UU l5)
+  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
+  (e : fam-equiv P (Q ∘ f∞))
+  where
+
+  inv-map-over-diagram-equiv-zigzag' :
+    (n : ℕ) (a : family-sequential-diagram A n) →
+    family-descent-data-sequential-colimit Q' n
+      ( map-zigzag-sequential-diagram z n a) →
+    family-descent-data-sequential-colimit P' n a
+  inv-map-over-diagram-equiv-zigzag' n a =
+    map-inv-fam-equiv e
+      ( map-cocone-sequential-diagram c n a) ∘
+    tr Q (inv (C n a))
+
+
+  inv-map-over-diagram-equiv-zigzag :
+    (n : ℕ) (b : family-sequential-diagram B n) →
+    family-descent-data-sequential-colimit Q' n b →
+    family-descent-data-sequential-colimit P' (succ-ℕ n)
+      ( inv-map-zigzag-sequential-diagram z n b)
+  inv-map-over-diagram-equiv-zigzag n b =
+    inv-map-over-diagram-equiv-zigzag' (succ-ℕ n)
+      ( inv-map-zigzag-sequential-diagram z n b) ∘
+    tr
+      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+      ( lower-triangle-zigzag-sequential-diagram z n b) ∘
+    tr Q
+      ( coherence-cocone-sequential-diagram c' n b)
+
+  opaque
+    inv-upper-triangle-over' :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)) ∘
+      tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a)) ∘
+      map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) ~
+      map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (inv-map-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)) ∘
+      tr
+        ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+        ( upper-triangle-zigzag-sequential-diagram z n a)
+    inv-upper-triangle-over' n a =
+      {!!}
+
+  opaque
+    upper-triangle-over' :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      map-inv-fam-equiv e _ ∘
+      tr Q (inv (C (succ-ℕ n) _)) ∘
+      tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)) ∘
+      tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a)) ∘
+      map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) ~
+      tr
+        ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+        ( upper-triangle-zigzag-sequential-diagram z n a)
+    upper-triangle-over' n a p =
+      map-eq-transpose-equiv-inv'
+        ( e _)
+        ( map-eq-transpose-equiv-inv'
+          ( equiv-tr Q (C (succ-ℕ n) _))
+          ( inv-upper-triangle-over' n a p))
+
+  inv-upper-triangle-over :
+    (n : ℕ) (a : family-sequential-diagram A n) →
+    coherence-square-maps
+      ( map-family-descent-data-sequential-colimit P' n a)
+      ( map-over-diagram-equiv-over-colimit up-c c' f P Q e n a)
+      ( tr
+        ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+        ( upper-triangle-zigzag-sequential-diagram z n a))
+      ( inv-map-over-diagram-equiv-zigzag n (map-zigzag-sequential-diagram z n a))
+  inv-upper-triangle-over n a p =
+    ap
+      ( map-inv-fam-equiv e _ ∘
+        tr Q (inv (C (succ-ℕ n) _)) ∘
+        tr
+          ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+          ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)))
+      ( inv
+        ( is-retraction-map-inv-equiv
+          ( equiv-tr
+            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+            ( naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
+          ( _)) ∙
+        ap
+          ( tr
+            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+            ( inv
+              ( naturality-map-hom-diagram-zigzag-sequential-diagram z n a)))
+          ( square-over-diagram-square-over-colimit up-c c' f P Q e n a p)) ∙
+    upper-triangle-over' n a (map-family-descent-data-sequential-colimit P' n a p)
+
+  upper-triangle-over :
+    (n : ℕ) →
+    htpy-over
+      ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+      ( upper-triangle-zigzag-sequential-diagram z n)
+      ( map-family-descent-data-sequential-colimit P' n _)
+      ( inv-map-over-diagram-equiv-zigzag n _ ∘
+        map-over-diagram-equiv-over-colimit up-c c' f P Q e n _)
+  upper-triangle-over n {a} p =
+    inv (inv-upper-triangle-over n a p)
+
+  opaque
+    lower-triangle-over' :
+      (n : ℕ) (a : family-sequential-diagram A n)
+      (q :
+        family-descent-data-sequential-colimit Q' n
+          ( map-zigzag-sequential-diagram z n a)) →
+      q ＝
+      map-over-diagram-equiv-over-colimit up-c c' f P Q e n a
+        ( inv-map-over-diagram-equiv-zigzag' n a q)
+    lower-triangle-over' n a q =
+      inv
+        ( is-section-map-inv-equiv
+          ( equiv-tr Q (C n a))
+          ( q)) ∙
+      ap
+        ( tr Q (C n a))
+        ( inv
+          ( is-section-map-inv-equiv
+            ( e (map-cocone-sequential-diagram c n a))
+            ( tr Q (inv (C n a)) q)))
+
+  lower-triangle-over :
+    (n : ℕ) →
+    htpy-over
+      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+      ( lower-triangle-zigzag-sequential-diagram z n)
+      ( map-family-descent-data-sequential-colimit Q' n _)
+      ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ ∘
+        inv-map-over-diagram-equiv-zigzag n _)
+  lower-triangle-over n {b} q =
+    -- this could change to alternatives
+    -- map-inv-eq-transpose-equiv-inv doesn't compute well
+    lower-triangle-over'
+      ( succ-ℕ n)
+      ( inv-map-zigzag-sequential-diagram z n b)
+      ( tr
+         ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+         ( lower-triangle-zigzag-sequential-diagram z n b)
+         ( map-family-descent-data-sequential-colimit Q' n b q))
+```
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : UU l2}
+  (e : A ≃ B)
+  where
+
+  inv-coherence-map-inv-is-equiv :
+    (a : A) →
+    ap (map-equiv e) (inv (is-retraction-map-inv-equiv e a)) ＝
+    inv (is-section-map-inv-equiv e (map-equiv e a))
+  inv-coherence-map-inv-is-equiv a =
+    ap-inv (map-equiv e) (is-retraction-map-inv-equiv e a) ∙
+    ap inv (inv (coherence-map-inv-equiv e a))
+
+  left-inv-is-retraction-map-inv-equiv :
+    (a : A) →
+    inv (is-section-map-inv-equiv e (map-equiv e a)) ∙
+    ap (map-equiv e) (is-retraction-map-inv-equiv e a) ＝
+    refl
+  left-inv-is-retraction-map-inv-equiv a =
+    ap
+      ( inv (is-section-map-inv-equiv e (map-equiv e a)) ∙_)
+      ( inv (coherence-map-inv-equiv e a)) ∙
+    left-inv (is-section-map-inv-equiv e (map-equiv e a))
+
+module _
+  {l1 l2 : Level} {A : UU l1} {B : UU l2}
+  (e : A ≃ B)
+  where
+  concat-inv-coherence-map-inv-is-equiv :
+    {x : A} {y : B} (p : map-equiv e x ＝ y) →
+    ap (map-equiv e) (inv (is-retraction-map-inv-equiv e x) ∙ ap (map-inv-equiv e) p) ＝
+    p ∙ inv (is-section-map-inv-equiv e y)
+  concat-inv-coherence-map-inv-is-equiv refl =
+    ap (ap (map-equiv e)) right-unit ∙ inv-coherence-map-inv-is-equiv e _
+
+module _
+  {l1 l2 l3 l4 l5 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  (c' : cocone-sequential-diagram B Y)
+  (z : zigzag-sequential-diagram A B)
+  (let f = hom-diagram-zigzag-sequential-diagram z)
+  (let g = inv-hom-diagram-zigzag-sequential-diagram z)
+  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (let
+    C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (Q : Y → UU l5)
+  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
+  (let P = Q ∘ f∞)
+  (let P' = descent-data-family-cocone-sequential-diagram c P)
+  where
+
+  open import foundation.dependent-identifications
+
+  opaque
+    -- TODO: Maybe this goes through for general equivalences immediately?
+    -- I haven't tried
+    compute-square-over-zigzag-square-over-colimit-id :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      pasting-triangles-over
+        ( map-sequential-diagram A n)
+        ( map-hom-sequential-diagram B f n)
+        ( map-hom-sequential-diagram B f (succ-ℕ n))
+        ( map-sequential-diagram B n)
+        ( map-family-descent-data-sequential-colimit P' n _)
+        ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv n _)
+        ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) _)
+        ( map-family-descent-data-sequential-colimit Q' n _)
+        ( map-hom-sequential-diagram _ g n)
+        ( inv-map-over-diagram-equiv-zigzag up-c c' z P Q id-fam-equiv n _)
+        ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
+        ( lower-triangle-zigzag-sequential-diagram z n)
+        ( inv-htpy-over
+          ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+          ( upper-triangle-zigzag-sequential-diagram z n)
+          _ _
+          ( upper-triangle-over up-c c' z P Q id-fam-equiv n))
+        ( lower-triangle-over up-c c' z P Q id-fam-equiv n)
+        { a} ~
+      square-over-diagram-square-over-colimit up-c c' f P Q id-fam-equiv n a
+    compute-square-over-zigzag-square-over-colimit-id n a p =
+      compute-concat-dependent-identification
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        _ _ _ _ ∙
+      ( ap
+        ( ( ( tr-concat
+              ( lower-triangle-zigzag-sequential-diagram z n _)
+              ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
+              ( _)) ∙
+            ( ap
+              ( tr (family-descent-data-sequential-colimit Q' (succ-ℕ n)) _)
+              ( lower-triangle-over up-c c' z (Q ∘ f∞) Q id-fam-equiv n _))) ∙_)
+        ( ( compute-left-whisk-dependent-identification
+            ( map-over-diagram-equiv-over-colimit up-c c' (hom-diagram-zigzag-sequential-diagram z) (Q ∘ f∞) Q id-fam-equiv (succ-ℕ n) _)
+            ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+            ( _)) ∙
+          ap
+            ( λ r →
+              substitution-law-tr
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                ( inv (upper-triangle-zigzag-sequential-diagram z n a)) ∙
+              inv
+                ( preserves-tr
+                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n))
+                  ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+                  ( _)) ∙
+              ap
+                ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
+                ( r))
+            ( ( compute-inv-dependent-identification-inv
+                ( upper-triangle-zigzag-sequential-diagram z n a)
+                ( inv-upper-triangle-over up-c c' z (Q ∘ f∞) Q id-fam-equiv n a p)) ∙
+              ( compute-eq-transpose-equiv-inv-concat'
+                ( equiv-tr
+                  ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                  ( upper-triangle-zigzag-sequential-diagram z n a))
+                ( _)
+                ( _))))) ∙
+      inv (assoc _ _ _) ∙
+      ap
+        ( ( tr-concat
+            ( lower-triangle-zigzag-sequential-diagram z n _)
+            ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
+            ( map-family-descent-data-sequential-colimit Q' n
+              ( map-zigzag-sequential-diagram z n a)
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv n a p)) ∙
+            ap
+              ( tr
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                ( ap _ (inv (upper-triangle-zigzag-sequential-diagram z n a))))
+              ( lower-triangle-over up-c c' z P Q id-fam-equiv n _) ∙
+            ( substitution-law-tr
+              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+              ( map-zigzag-sequential-diagram z (succ-ℕ n))
+              ( inv (upper-triangle-zigzag-sequential-diagram z n a)) ∙
+              inv
+                ( preserves-tr
+                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n))
+                  ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+                  ( _)))) ∙_)
+        ( ap-concat
+          ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
+          ( _)
+          ( _) ∙
+          ap
+            (_∙
+              ap
+                ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
+                ( map-eq-transpose-equiv-inv'
+                  ( equiv-tr
+                    ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                    ( upper-triangle-zigzag-sequential-diagram z n a))
+                  ( upper-triangle-over' up-c c' z P Q id-fam-equiv n a _)))
+            ( inv
+              ( ap-comp
+                ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
+                ( tr
+                  ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                  ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
+                ( _)) ∙
+              inv
+                ( ap-comp
+                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a) ∘
+                    tr (family-descent-data-sequential-colimit P' (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
+                  ( tr Q
+                      ( inv (C (succ-ℕ n) _)) ∘
+                    tr
+                      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                      ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)))
+                  ( _)))) ∙
+      inv (assoc _ _ _) ∙
+      ap
+        ( _∙
+          ap
+            ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
+            ( map-eq-transpose-equiv-inv'
+              ( equiv-tr
+                ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                ( upper-triangle-zigzag-sequential-diagram z n a))
+              ( upper-triangle-over' up-c c' z P Q id-fam-equiv n a _)))
+        ( nat-htpy
+            ( λ (q : family-descent-data-sequential-colimit Q' (succ-ℕ n) (map-sequential-diagram B n (map-zigzag-sequential-diagram z n a))) →
+              tr-concat
+                ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+                ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
+                ( q) ∙
+              ap
+                ( tr
+                  ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                  ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a))))
+                ( lower-triangle-over' up-c c' z P Q id-fam-equiv (succ-ℕ n) _
+                  ( tr
+                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                    ( lower-triangle-zigzag-sequential-diagram z n
+                      ( map-zigzag-sequential-diagram z n a))
+                    ( q))) ∙
+              ( substitution-law-tr
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                ( inv (upper-triangle-zigzag-sequential-diagram z n a)) ∙
+                inv
+                  ( preserves-tr
+                    ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n))
+                    ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+                    ( inv-map-over-diagram-equiv-zigzag' up-c c' z P Q id-fam-equiv (succ-ℕ n)
+                      ( inv-map-zigzag-sequential-diagram z n
+                        ( map-zigzag-sequential-diagram z n a))
+                      ( tr
+                        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                        ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+                        ( q))))))
+            ( _) ∙
+            ap
+              ( _∙
+                ( tr-concat _ _ _ ∙
+                  ap
+                    ( tr
+                      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                      ( ap
+                        ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                        ( inv (upper-triangle-zigzag-sequential-diagram z n a))))
+                    ( lower-triangle-over' up-c c' z P Q id-fam-equiv (succ-ℕ n) _ _)∙
+                  ( substitution-law-tr
+                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                    ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                    ( inv (upper-triangle-zigzag-sequential-diagram z n a)) ∙
+                    inv
+                      ( preserves-tr
+                        ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n))
+                        ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+                        ( inv-map-over-diagram-equiv-zigzag' up-c c' z P Q id-fam-equiv (succ-ℕ n)
+                          ( inv-map-zigzag-sequential-diagram z n
+                            ( map-zigzag-sequential-diagram z n a))
+                          ( _))))))
+              ( concat-inv-coherence-map-inv-is-equiv
+                ( equiv-tr
+                  ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                  ( naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
+                ( square-over-diagram-square-over-colimit up-c c' f P Q id-fam-equiv n a p))) ∙
+      assoc _ _ _ ∙
+      assoc _ _ _ ∙
+      ap
+        ( square-over-diagram-square-over-colimit up-c c' f P Q id-fam-equiv n a p ∙_)
+        ( {!!}) ∙
+      right-unit
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  (c' : cocone-sequential-diagram B Y)
+  (z : zigzag-sequential-diagram A B)
+  (let f = hom-diagram-zigzag-sequential-diagram z)
+  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (let
+    C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (P : X → UU l5)
+  (let P' = descent-data-family-cocone-sequential-diagram c P)
+  (Q : Y → UU l5)
+  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
+  (e : fam-equiv P (Q ∘ f∞))
+  where
+
+  opaque
+    compute-square-over-zigzag-square-over-colimit :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      pasting-triangles-over
+        ( map-sequential-diagram A n)
+        ( map-hom-sequential-diagram B f n)
+        ( map-hom-sequential-diagram B f (succ-ℕ n))
+        ( map-sequential-diagram B n)
+        ( map-family-descent-data-sequential-colimit P' n _)
+        ( map-over-diagram-equiv-over-colimit up-c c' f P Q e n _)
+        ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+        ( map-family-descent-data-sequential-colimit Q' n _)
+        ( inv-map-zigzag-sequential-diagram z n)
+        ( inv-map-over-diagram-equiv-zigzag up-c c' z P Q e n _)
+        ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
+        ( lower-triangle-zigzag-sequential-diagram z n)
+        ( inv-htpy-over
+          ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+          ( upper-triangle-zigzag-sequential-diagram z n)
+          _ _
+          ( upper-triangle-over up-c c' z P Q e n))
+        ( lower-triangle-over up-c c' z P Q e n)
+        { a} ~
+      square-over-diagram-square-over-colimit up-c c' f P Q e n a
+    compute-square-over-zigzag-square-over-colimit =
+      ind-fam-equiv'
+        ( λ P e →
+          let P' = descent-data-family-cocone-sequential-diagram c P in
+          (n : ℕ) (a : family-sequential-diagram A n) →
+          pasting-triangles-over
+            ( map-sequential-diagram A n)
+            ( map-hom-sequential-diagram B f n)
+            ( map-hom-sequential-diagram B f (succ-ℕ n))
+            ( map-sequential-diagram B n)
+            ( map-family-descent-data-sequential-colimit P' n _)
+            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e n _)
+            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+            ( map-family-descent-data-sequential-colimit Q' n _)
+            ( inv-map-zigzag-sequential-diagram z n)
+            ( inv-map-over-diagram-equiv-zigzag up-c c' z P Q e n _)
+            ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
+            ( lower-triangle-zigzag-sequential-diagram z n)
+            ( inv-htpy-over
+              ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+              ( upper-triangle-zigzag-sequential-diagram z n)
+              _ _
+              ( upper-triangle-over up-c c' z P Q e n))
+            ( lower-triangle-over up-c c' z P Q e n)
+            { a} ~
+          square-over-diagram-square-over-colimit up-c c' f P Q e n a)
+        ( compute-square-over-zigzag-square-over-colimit-id up-c c' z Q)
+      ( e)
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 l5 : Level}
+  {A : sequential-diagram l1} {X : UU l2}
+  {c : cocone-sequential-diagram A X}
+  (up-c : universal-property-sequential-colimit c)
+  {B : sequential-diagram l3} {Y : UU l4}
+  {c' : cocone-sequential-diagram B Y}
+  (up-c' : universal-property-sequential-colimit c')
+  (let
+    dup-c' =
+      dependent-universal-property-universal-property-sequential-colimit _ up-c')
+  (Q : Y → UU l5)
+  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
+  (f : hom-sequential-diagram A B)
+  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (let P = Q ∘ f∞)
+  (let P' = descent-data-family-cocone-sequential-diagram c P)
+  (let C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
+  (let f∞n = λ n a → tr Q (C n a))
+  (s : section-descent-data-sequential-colimit Q')
+  (let s∞ = sect-family-sect-dd-sequential-colimit up-c' Q s)
+  (let
+    𝒞 =
+      htpy-dependent-cocone-dependent-universal-property-sequential-colimit
+        ( dup-c')
+        ( s))
+  (let C' = htpy-htpy-dependent-cocone-sequential-diagram Q 𝒞)
+  where
+
+  opaque
+    unfolding square-over-diagram-square-over-colimit
+    γ :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      coherence-square-maps
+        ( tr (Q ∘ f∞) (coherence-cocone-sequential-diagram c n a))
+        ( f∞n n a)
+        ( f∞n (succ-ℕ n) (map-sequential-diagram A n a))
+        ( ( tr
+            ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
+            ( naturality-map-hom-sequential-diagram B f n a)) ∘
+          ( tr Q
+            ( coherence-cocone-sequential-diagram c' n
+              ( map-hom-sequential-diagram B f n a))))
+    γ = γ' up-c c' f P Q id-fam-equiv
+
+    -- compute-γ :
+    --   (n : ℕ) (a : family-sequential-diagram A n) →
+    --   square-over-diagram-square-over-colimit up-c c' f (Q ∘ f∞) Q id-fam-equiv n a ~ γ n a
+    -- compute-γ n a p =
+    --   ap
+    --     ( γ n a p ∙_)
+    --     ( ap
+    --       ( λ r → ap (tr Q (C (succ-ℕ n) (map-sequential-diagram A n a))) (inv r))
+    --       ( compute-preserves-tr-id (coherence-cocone-sequential-diagram c n a) p)) ∙
+    --   right-unit
+
   opaque
     γ-flip :
       (n : ℕ) (a : family-sequential-diagram A n) →
@@ -1448,7 +1958,7 @@ module _
           ( _)
 
     opaque
-      unfolding γ γ-base γ-flip
+      unfolding γ γ' γ-base' γ-flip
 
       [i] : goal
       [i] =
@@ -1486,7 +1996,7 @@ module _
                   ( apd s∞ (C (succ-ℕ n) (map-sequential-diagram A n a)))
                   ( assoc _ _ _ ∙
                     left-whisker-concat
-                      ( γ-base n a (s∞ (f∞ (map-cocone-sequential-diagram c n a))))
+                      ( γ-base' up-c c' f (Q ∘ f∞) Q id-fam-equiv n a (s∞ (f∞ (map-cocone-sequential-diagram c n a))))
                       ( [step-1] a) ∙
                     assoc _ _ _)) ∙
                 ( assoc _ _ _) ∙
@@ -1754,54 +2264,52 @@ module _
   -- - make γ into a proper definition
   -- - pasting of squares
   -- - find the right lemmas
-  square-colimit-cube-diagram :
-    (F :
-      (n : ℕ) →
-      f∞n n _ ∘ map-section-dependent-sequential-diagram _ _ s n ~
-      map-section-dependent-sequential-diagram _ _ t n ∘
-      map-hom-sequential-diagram B f n) →
-    ((n : ℕ) →
-      section-square-over
-        ( map-sequential-diagram A n)
-        ( map-hom-sequential-diagram B f n)
-        ( map-hom-sequential-diagram B f (succ-ℕ n))
-        ( map-sequential-diagram B n)
-        ( λ {a} → map-family-descent-data-sequential-colimit P' n a)
-        ( λ {a} → f∞n n a)
-        ( λ {a} → f∞n (succ-ℕ n) a)
-        ( λ {b} → map-family-descent-data-sequential-colimit Q' n b)
-        ( map-section-dependent-sequential-diagram _ _ s n)
-        ( map-section-dependent-sequential-diagram _ _ t n)
-        ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
-        ( map-section-dependent-sequential-diagram _ _ t (succ-ℕ n))
-        ( naturality-map-section-dependent-sequential-diagram _ _ s n)
-        ( F n)
-        ( F (succ-ℕ n))
-        ( naturality-map-section-dependent-sequential-diagram _ _ t n)
-        ( naturality-map-hom-sequential-diagram B f n)
-        ( λ p →
-          γ up-c up-c' Q f t n _ (map-fam-equiv e _ p) ∙
+  opaque
+    unfolding square-over-diagram-square-over-colimit γ γ' γ-base'
+    square-colimit-cube-diagram :
+      (F :
+        (n : ℕ) →
+        f∞n n _ ∘ map-section-dependent-sequential-diagram _ _ s n ~
+        map-section-dependent-sequential-diagram _ _ t n ∘
+        map-hom-sequential-diagram B f n) →
+      ((n : ℕ) →
+        section-square-over
+          ( map-sequential-diagram A n)
+          ( map-hom-sequential-diagram B f n)
+          ( map-hom-sequential-diagram B f (succ-ℕ n))
+          ( map-sequential-diagram B n)
+          ( λ {a} → map-family-descent-data-sequential-colimit P' n a)
+          ( λ {a} → f∞n n a)
+          ( λ {a} → f∞n (succ-ℕ n) a)
+          ( λ {b} → map-family-descent-data-sequential-colimit Q' n b)
+          ( map-section-dependent-sequential-diagram _ _ s n)
+          ( map-section-dependent-sequential-diagram _ _ t n)
+          ( map-section-dependent-sequential-diagram _ _ s (succ-ℕ n))
+          ( map-section-dependent-sequential-diagram _ _ t (succ-ℕ n))
+          ( naturality-map-section-dependent-sequential-diagram _ _ s n)
+          ( F n)
+          ( F (succ-ℕ n))
+          ( naturality-map-section-dependent-sequential-diagram _ _ t n)
+          ( naturality-map-hom-sequential-diagram B f n)
+          ( square-over-diagram-square-over-colimit up-c c' f P Q e n _)) →
+      map-fam-equiv e _ ∘ s∞ ~ t∞ ∘ f∞
+    square-colimit-cube-diagram F cubes =
+      inv-htpy (theorem' up-c up-c' f Q P e s) ∙h
+      theorem up-c up-c' Q f t _ F
+        ( λ n a →
+          assoc _ _ _ ∙
           ap
-            ( tr Q (C (succ-ℕ n) _))
-            ( inv
-              ( preserves-tr
-                ( map-fam-equiv e)
-                ( coherence-cocone-sequential-diagram c n _) p)))) →
-    map-fam-equiv e _ ∘ s∞ ~ t∞ ∘ f∞
-  square-colimit-cube-diagram F cubes =
-    inv-htpy (theorem' up-c up-c' f Q P e s) ∙h
-    theorem up-c up-c' Q f t _ F
-      (λ n a →
-        assoc _ _ _ ∙
-        ap
-          ( γ up-c up-c' Q f t n a (map-fam-equiv e (map-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a)) ∙_)
-          ( ap
-            ( _∙ F (succ-ℕ n) (map-sequential-diagram A n a))
-            ( ap-concat (tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
-              ( inv (preserves-tr (map-fam-equiv e) (coherence-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a)))
-              ( ap (map-fam-equiv e (map-cocone-sequential-diagram c (succ-ℕ n) (map-sequential-diagram A n a))) (naturality-map-section-dependent-sequential-diagram _ _ s n a)) ∙
-              ap
-                ( ap (tr Q (C (succ-ℕ n) (map-sequential-diagram A n a))) (inv (preserves-tr (map-fam-equiv e) (coherence-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a))) ∙_)
-                ( inv (ap-comp (tr Q (C (succ-ℕ n) _)) (map-fam-equiv e _) (naturality-map-section-dependent-sequential-diagram _ _ s n a)))) ∙
-          assoc _ _ _) ∙ inv (assoc _ _ _) ∙ inv (assoc _ _ _) ∙ cubes n a)
+            ( γ up-c up-c' Q f t n a (map-fam-equiv e (map-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a)) ∙_)
+            ( ( ap
+                ( _∙ F (succ-ℕ n) (map-sequential-diagram A n a))
+                ( ap-concat (tr Q (C (succ-ℕ n) (map-sequential-diagram A n a)))
+                  ( inv (preserves-tr (map-fam-equiv e) (coherence-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a)))
+                  ( ap (map-fam-equiv e (map-cocone-sequential-diagram c (succ-ℕ n) (map-sequential-diagram A n a))) (naturality-map-section-dependent-sequential-diagram _ _ s n a)) ∙
+                  ap
+                    ( ap (tr Q (C (succ-ℕ n) (map-sequential-diagram A n a))) (inv (preserves-tr (map-fam-equiv e) (coherence-cocone-sequential-diagram c n a) (map-section-dependent-sequential-diagram _ _ s n a))) ∙_)
+                    ( inv (ap-comp (tr Q (C (succ-ℕ n) _)) (map-fam-equiv e _) (naturality-map-section-dependent-sequential-diagram _ _ s n a))))) ∙
+              ( assoc _ _ _)) ∙
+          inv (assoc _ _ _) ∙
+          inv (assoc _ _ _) ∙
+          cubes n a)
 ```
diff --git a/src/synthetic-homotopy-theory/shifts-sequential-diagrams.lagda.md b/src/synthetic-homotopy-theory/shifts-sequential-diagrams.lagda.md
index c7c6e22f6f..be26604bde 100644
--- a/src/synthetic-homotopy-theory/shifts-sequential-diagrams.lagda.md
+++ b/src/synthetic-homotopy-theory/shifts-sequential-diagrams.lagda.md
@@ -934,17 +934,20 @@ module _
   (up-c : universal-property-sequential-colimit c)
   where
 
-  compute-map-colimit-hom-shift-once-sequential-diagram :
-    map-sequential-colimit-hom-sequential-diagram
-      ( up-c)
-      ( shift-once-cocone-sequential-diagram c)
-      ( hom-shift-once-sequential-diagram A) ~
-    id
-  compute-map-colimit-hom-shift-once-sequential-diagram =
-    ( htpy-map-universal-property-htpy-cocone-sequential-diagram
-      ( up-c)
-      ( compute-map-cocone-hom-shift-sequential-diagram c)) ∙h
-    ( compute-map-universal-property-sequential-colimit-id up-c)
+  opaque
+    unfolding map-sequential-colimit-hom-sequential-diagram
+
+    compute-map-colimit-hom-shift-once-sequential-diagram :
+      map-sequential-colimit-hom-sequential-diagram
+        ( up-c)
+        ( shift-once-cocone-sequential-diagram c)
+        ( hom-shift-once-sequential-diagram A) ~
+      id
+    compute-map-colimit-hom-shift-once-sequential-diagram =
+      ( htpy-map-universal-property-htpy-cocone-sequential-diagram
+        ( up-c)
+        ( compute-map-cocone-hom-shift-sequential-diagram c)) ∙h
+      ( compute-map-universal-property-sequential-colimit-id up-c)
 
 module _
   {l1 l2 : Level} {A : sequential-diagram l1}
diff --git a/src/synthetic-homotopy-theory/stuff-over.lagda.md b/src/synthetic-homotopy-theory/stuff-over.lagda.md
index 05c40956f7..e5214a52e0 100644
--- a/src/synthetic-homotopy-theory/stuff-over.lagda.md
+++ b/src/synthetic-homotopy-theory/stuff-over.lagda.md
@@ -1,7 +1,7 @@
 # Stuff over other stuff
 
 ```agda
-{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
+{-# OPTIONS --lossy-unification #-}
 module synthetic-homotopy-theory.stuff-over where
 ```
 
@@ -76,6 +76,16 @@ module _
   inv-htpy-over : htpy-over B' H f' g' → htpy-over B' (inv-htpy H) g' f'
   inv-htpy-over H' {a} a' = inv-dependent-identification B' (H a) (H' a')
 
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+
+  compute-inv-dependent-identification :
+    {x y : A} (p : x ＝ y) {x' : B x} {y' : B y} →
+    (q : dependent-identification B p x' y') →
+    inv-dependent-identification B p q ＝ map-eq-transpose-equiv-inv' (equiv-tr B p) (inv q)
+  compute-inv-dependent-identification refl q = inv (right-unit ∙ ap-id (inv q))
+
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
   {A : UU l1} {B : UU l2} {X : UU l3}
@@ -104,6 +114,13 @@ module _
     dependent-identification B' (ap s p) (s' x') (s' y')
   left-whisk-dependent-identification s' refl q = ap s' q
 
+  compute-left-whisk-dependent-identification :
+    {s : A → B} (s' : {a : A} → A' a → B' (s a))
+    {x y : A} (p : x ＝ y)
+    {x' : A' x} {y' : A' y} (q : dependent-identification A' p x' y') →
+    left-whisk-dependent-identification s' p q ＝
+      substitution-law-tr B' s p ∙ inv (preserves-tr (λ a → s' {a}) p x') ∙ ap s' q
+  compute-left-whisk-dependent-identification s' refl q = refl
 
 module _
   {l1 l2 l3 l4 l5 l6 : Level}
@@ -645,728 +662,728 @@ module _
 ```
 
 ```agda
-open import foundation.sections
-open import foundation.transport-along-homotopies
-module _
-  {l1 l2 : Level}
-  {A : UU l1} (B : A → UU l2)
-  where
-
-  sect-section :
-    section (pr1 {B = B}) →
-    ((a : A) → B a)
-  sect-section (s , H) a = tr B (H a) (pr2 (s a))
-
-  section-sect :
-    ((a : A) → B a) →
-    section (pr1 {B = B})
-  section-sect = section-dependent-function
-
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
-  (f : A → B) (f' : A' → B')
-  where
-
-  htpy-hom-map :
-    (hA : A' → A) (hB : B' → B) →
-    coherence-square-maps f' hA hB f →
-    (hA' : A' → A) (hB' : B' → B) →
-    coherence-square-maps f' hA' hB' f →
-    hA ~ hA' → hB ~ hB' →
-    UU (l2 ⊔ l3)
-  htpy-hom-map hA hB H hA' hB' H' σA σB = H ∙h (σB ·r f') ~ (f ·l σA) ∙h H'
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3}
-  {X : UU l4} {Y : UU l5} {Z : UU l6}
-  (f : A → B) (g : B → C)
-  (f' : X → Y) (g' : Y → Z)
-  (hA hA' : X → A) (hB hB' : Y → B) (hC hC' : Z → C)
-  (σA : hA ~ hA') (σB : hB ~ hB') (σC : hC ~ hC')
-  (NL : coherence-square-maps f' hA hB f)
-  (FL : coherence-square-maps f' hA' hB' f)
-  (α : htpy-hom-map f f' hA hB NL hA' hB' FL σA σB)
-  (NR : coherence-square-maps g' hB hC g)
-  (FR : coherence-square-maps g' hB' hC' g)
-  (β : htpy-hom-map g g' hB hC NR hB' hC' FR σB σC)
-  where
-  open import foundation.commuting-squares-of-homotopies
-
-  comp-htpy-hom-map :
-    htpy-hom-map (g ∘ f) (g' ∘ f')
-      hA hC
-      ( pasting-horizontal-coherence-square-maps f' g' hA hB hC f g NL NR)
-      hA' hC'
-      ( pasting-horizontal-coherence-square-maps f' g' hA' hB' hC' f g FL FR)
-      σA σC
-  comp-htpy-hom-map =
-    left-whisker-concat-coherence-square-homotopies (g ·l NL)
-      ( g ·l σB ·r f') (NR ·r f') (FR ·r f') (σC ·r (g' ∘ f'))
-      ( β ·r f') ∙h
-    right-whisker-concat-htpy
-      ( inv-htpy
-          ( distributive-left-whisker-comp-concat g NL (σB ·r f')) ∙h
-        left-whisker-comp² g α ∙h
-        distributive-left-whisker-comp-concat g (f ·l σA) FL ∙h
-        right-whisker-concat-htpy
-          ( preserves-comp-left-whisker-comp g f σA)
-          ( g ·l FL))
-      ( FR ·r f') ∙h
-    assoc-htpy ((g ∘ f) ·l σA) (g ·l FL) (FR ·r f')
+-- open import foundation.sections
+-- open import foundation.transport-along-homotopies
+-- module _
+--   {l1 l2 : Level}
+--   {A : UU l1} (B : A → UU l2)
+--   where
 
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
-  (f : A → B) (f' : A' → B')
-  (hA : A' → A) (hB : B' → B)
-  (H : coherence-square-maps f' hA hB f)
-  where
+--   sect-section :
+--     section (pr1 {B = B}) →
+--     ((a : A) → B a)
+--   sect-section (s , H) a = tr B (H a) (pr2 (s a))
 
-  section-displayed-map-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4)
-  section-displayed-map-over =
-    Σ ( section hA)
-      ( λ sA →
-        Σ ( section hB)
-          ( λ sB →
-            Σ ( coherence-square-maps
-                f (map-section hA sA) (map-section hB sB) f')
-              ( λ K →
-                htpy-hom-map f f
-                  ( hA ∘ map-section hA sA)
-                  ( hB ∘ map-section hB sB)
-                  ( pasting-vertical-coherence-square-maps f
-                    ( map-section hA sA) (map-section hB sB) f' hA hB f K H)
-                  id id refl-htpy
-                  ( is-section-map-section hA sA)
-                  ( is-section-map-section hB sB))))
+--   section-sect :
+--     ((a : A) → B a) →
+--     section (pr1 {B = B})
+--   section-sect = section-dependent-function
 
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {P : A → UU l2}
-  {B : UU l3} {Q : B → UU l4}
-  (f : A → B)
-  (f' : {a : A} → P a → Q (f a))
-  where
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
+--   (f : A → B) (f' : A' → B')
+--   where
 
-  sect-map-over-section-map-over :
-    (s :
-      section-displayed-map-over f
-        (tot-map-over f (λ a → f' {a}))
-        pr1 pr1 refl-htpy) →
-    section-map-over f
-      ( f')
-      ( sect-section P (pr1 s))
-      ( sect-section Q (pr1 (pr2 s)))
-  sect-map-over-section-map-over (sA , sB , H , α) a =
-    ( preserves-tr (λ a → f' {a}) (σA a) (sA2 a)) ∙
-    ( inv (substitution-law-tr Q f (σA a))) ∙
-    ( ap (λ p → tr Q p (f' (sA2 a))) (inv (α a ∙ right-unit))) ∙
-    ( tr-concat (H1 a) (σB (f a)) (f' (sA2 a))) ∙
-    ( ap
-      ( tr Q (σB (f a)))
-      ( substitution-law-tr Q pr1 (H a) ∙ apd pr2 (H a)))
-    where
-      sA1 : A → A
-      sA1 = pr1 ∘ map-section pr1 sA
-      σA : sA1 ~ id
-      σA = is-section-map-section pr1 sA
-      sA2 : (a : A) → P (sA1 a)
-      sA2 = pr2 ∘ map-section pr1 sA
-      sB1 : B → B
-      sB1 = pr1 ∘ map-section pr1 sB
-      σB : sB1 ~ id
-      σB = is-section-map-section pr1 sB
-      H1 : f ∘ sA1 ~ sB1 ∘ f
-      H1 = pr1 ·l H
-```
+--   htpy-hom-map :
+--     (hA : A' → A) (hB : B' → B) →
+--     coherence-square-maps f' hA hB f →
+--     (hA' : A' → A) (hB' : B' → B) →
+--     coherence-square-maps f' hA' hB' f →
+--     hA ~ hA' → hB ~ hB' →
+--     UU (l2 ⊔ l3)
+--   htpy-hom-map hA hB H hA' hB' H' σA σB = H ∙h (σB ·r f') ~ (f ·l σA) ∙h H'
 
-```agda
-module _
-  {l1 l2 : Level}
-  {A : UU l1} {B : A → UU l2}
-  (s : (a : A) → B a)
-  where
-
-  ap-map-section-family-lemma :
-    {a a' : A} (p : a ＝ a') →
-    ap (map-section-family s) p ＝ eq-pair-Σ p (apd s p)
-  ap-map-section-family-lemma refl = refl
-module _
-  {l1 l2 l3 : Level}
-  {A : UU l1} {B : UU l2} {Q : B → UU l3}
-  (s : (b : B) → Q b)
-  {f g : A → B} (H : f ~ g)
-  where
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : UU l1} {B : UU l2} {C : UU l3}
+--   {X : UU l4} {Y : UU l5} {Z : UU l6}
+--   (f : A → B) (g : B → C)
+--   (f' : X → Y) (g' : Y → Z)
+--   (hA hA' : X → A) (hB hB' : Y → B) (hC hC' : Z → C)
+--   (σA : hA ~ hA') (σB : hB ~ hB') (σC : hC ~ hC')
+--   (NL : coherence-square-maps f' hA hB f)
+--   (FL : coherence-square-maps f' hA' hB' f)
+--   (α : htpy-hom-map f f' hA hB NL hA' hB' FL σA σB)
+--   (NR : coherence-square-maps g' hB hC g)
+--   (FR : coherence-square-maps g' hB' hC' g)
+--   (β : htpy-hom-map g g' hB hC NR hB' hC' FR σB σC)
+--   where
+--   open import foundation.commuting-squares-of-homotopies
 
-  left-whisker-dependent-function-lemma :
-    (a : A) →
-    (map-section-family s ·l H) a ＝ eq-pair-Σ (H a) (apd s (H a))
-  left-whisker-dependent-function-lemma a = ap-map-section-family-lemma s (H a)
-module _
-  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
-  where
-  concat-vertical-eq-pair :
-    {x y : A} (p : x ＝ y) {x' : B x} {y' z' : B y} →
-    (q : dependent-identification B p x' y') → (r : y' ＝ z') →
-    eq-pair-Σ p (q ∙ r) ＝ eq-pair-Σ p q ∙ eq-pair-eq-fiber r
-  concat-vertical-eq-pair {x} refl q r = ap-concat (pair x) q r
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2}
-  {A' : A → UU l3} {B' : B → UU l4}
-  {f : A → B} (f' : (a : A) → A' a → B' (f a))
-  where
+--   comp-htpy-hom-map :
+--     htpy-hom-map (g ∘ f) (g' ∘ f')
+--       hA hC
+--       ( pasting-horizontal-coherence-square-maps f' g' hA hB hC f g NL NR)
+--       hA' hC'
+--       ( pasting-horizontal-coherence-square-maps f' g' hA' hB' hC' f g FL FR)
+--       σA σC
+--   comp-htpy-hom-map =
+--     left-whisker-concat-coherence-square-homotopies (g ·l NL)
+--       ( g ·l σB ·r f') (NR ·r f') (FR ·r f') (σC ·r (g' ∘ f'))
+--       ( β ·r f') ∙h
+--     right-whisker-concat-htpy
+--       ( inv-htpy
+--           ( distributive-left-whisker-comp-concat g NL (σB ·r f')) ∙h
+--         left-whisker-comp² g α ∙h
+--         distributive-left-whisker-comp-concat g (f ·l σA) FL ∙h
+--         right-whisker-concat-htpy
+--           ( preserves-comp-left-whisker-comp g f σA)
+--           ( g ·l FL))
+--       ( FR ·r f') ∙h
+--     assoc-htpy ((g ∘ f) ·l σA) (g ·l FL) (FR ·r f')
 
-  ap-map-Σ-eq-fiber :
-    {a : A} (x y : A' a) (p : x ＝ y) →
-    ap (map-Σ B' f f') (eq-pair-eq-fiber p) ＝ eq-pair-eq-fiber (ap (f' a) p)
-  ap-map-Σ-eq-fiber x .x refl = refl
-
-  -- ap-map-Σ-eq-fiber' :
-  --   {a : A} (x y : A' a) (p : x ＝ y) →
-  --   ap (map-Σ B' f f') (eq-pair-eq-fiber p) ＝ eq-pair-eq-fiber (ap (f' a) p)
-  -- ap-map-Σ-eq-fiber' {a} x y p =
-  --   compute-ap-eq-pair-Σ (map-Σ B' f f') refl p ∙
-  --   ap-comp (pair (f a)) (f' a) p
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3}
-  {A' : A → UU l4} {B' : B → UU l5} {C' : C → UU l6}
-  {f : A → B} {g : B → C}
-  (f' : (a : A) → A' a → B' (f a))
-  (g' : (b : B) → B' b → C' (g b))
-  (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sC : (c : C) → C' c)
-  (F : (a : A) → f' a (sA a) ＝ sB (f a)) (G : (b : B) → g' b (sB b) ＝ sC (g b))
-  where
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
+--   (f : A → B) (f' : A' → B')
+--   (hA : A' → A) (hB : B' → B)
+--   (H : coherence-square-maps f' hA hB f)
+--   where
 
-  pasting-horizontal-comp :
-    pasting-horizontal-coherence-square-maps f g
-      ( map-section-family sA) (map-section-family sB) (map-section-family sC)
-      ( tot-map-over f f') (tot-map-over g g')
-      ( eq-pair-eq-fiber ∘ F)
-      ( eq-pair-eq-fiber ∘ G) ~
-    eq-pair-eq-fiber ∘
-      ((g' _) ·l F ∙h G ·r f)
-  pasting-horizontal-comp a =
-    ap
-      ( _∙ eq-pair-eq-fiber (G (f a)))
-      ( inv (ap-comp (tot-map-over g g') (pair (f a)) (F a)) ∙
-        ap-comp (pair (g (f a))) (g' (f a)) (F a)) ∙
-    inv (ap-concat (pair (g (f a))) (ap (g' (f a)) (F a)) (G (f a)))
+--   section-displayed-map-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4)
+--   section-displayed-map-over =
+--     Σ ( section hA)
+--       ( λ sA →
+--         Σ ( section hB)
+--           ( λ sB →
+--             Σ ( coherence-square-maps
+--                 f (map-section hA sA) (map-section hB sB) f')
+--               ( λ K →
+--                 htpy-hom-map f f
+--                   ( hA ∘ map-section hA sA)
+--                   ( hB ∘ map-section hB sB)
+--                   ( pasting-vertical-coherence-square-maps f
+--                     ( map-section hA sA) (map-section hB sB) f' hA hB f K H)
+--                   id id refl-htpy
+--                   ( is-section-map-section hA sA)
+--                   ( is-section-map-section hB sB))))
 
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4}
-  {f g : A → B} {f' g' : X → Y}
-  (top : f' ~ g') (bottom : f ~ g)
-  {hA : X → A} {hB : Y → B}
-  (N : f ∘ hA ~ hB ∘ f') (F : g ∘ hA ~ hB ∘ g')
-  where
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : UU l1} {P : A → UU l2}
+--   {B : UU l3} {Q : B → UU l4}
+--   (f : A → B)
+--   (f' : {a : A} → P a → Q (f a))
+--   where
 
-  hom-htpy : UU (l2 ⊔ l3)
-  hom-htpy = N ∙h (hB ·l top) ~ (bottom ·r hA) ∙h F
+--   sect-map-over-section-map-over :
+--     (s :
+--       section-displayed-map-over f
+--         (tot-map-over f (λ a → f' {a}))
+--         pr1 pr1 refl-htpy) →
+--     section-map-over f
+--       ( f')
+--       ( sect-section P (pr1 s))
+--       ( sect-section Q (pr1 (pr2 s)))
+--   sect-map-over-section-map-over (sA , sB , H , α) a =
+--     ( preserves-tr (λ a → f' {a}) (σA a) (sA2 a)) ∙
+--     ( inv (substitution-law-tr Q f (σA a))) ∙
+--     ( ap (λ p → tr Q p (f' (sA2 a))) (inv (α a ∙ right-unit))) ∙
+--     ( tr-concat (H1 a) (σB (f a)) (f' (sA2 a))) ∙
+--     ( ap
+--       ( tr Q (σB (f a)))
+--       ( substitution-law-tr Q pr1 (H a) ∙ apd pr2 (H a)))
+--     where
+--       sA1 : A → A
+--       sA1 = pr1 ∘ map-section pr1 sA
+--       σA : sA1 ~ id
+--       σA = is-section-map-section pr1 sA
+--       sA2 : (a : A) → P (sA1 a)
+--       sA2 = pr2 ∘ map-section pr1 sA
+--       sB1 : B → B
+--       sB1 = pr1 ∘ map-section pr1 sB
+--       σB : sB1 ~ id
+--       σB = is-section-map-section pr1 sB
+--       H1 : f ∘ sA1 ~ sB1 ∘ f
+--       H1 = pr1 ·l H
+-- ```
 
+-- ```agda
 -- module _
+--   {l1 l2 : Level}
+--   {A : UU l1} {B : A → UU l2}
+--   (s : (a : A) → B a)
 --   where
 
---   alt-map-coherence-square-homotopies
+--   ap-map-section-family-lemma :
+--     {a a' : A} (p : a ＝ a') →
+--     ap (map-section-family s) p ＝ eq-pair-Σ p (apd s p)
+--   ap-map-section-family-lemma refl = refl
+-- module _
+--   {l1 l2 l3 : Level}
+--   {A : UU l1} {B : UU l2} {Q : B → UU l3}
+--   (s : (b : B) → Q b)
+--   {f g : A → B} (H : f ~ g)
+--   where
 
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4} {V : UU l5} {W : UU l6}
-  {f g : A → B} {f' g' : X → Y} {f'' g'' : V → W}
-  (mid : f' ~ g') (bottom : f ~ g) (top : f'' ~ g'')
-  {hA : X → A} {hB : Y → B} {hA' : V → X} {hB' : W → Y}
-  (bottom-N : f ∘ hA ~ hB ∘ f') (bottom-F : g ∘ hA ~ hB ∘ g')
-  (top-N : f' ∘ hA' ~ hB' ∘ f'') (top-F : g' ∘ hA' ~ hB' ∘ g'')
-  where
+--   left-whisker-dependent-function-lemma :
+--     (a : A) →
+--     (map-section-family s ·l H) a ＝ eq-pair-Σ (H a) (apd s (H a))
+--   left-whisker-dependent-function-lemma a = ap-map-section-family-lemma s (H a)
+-- module _
+--   {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+--   where
+--   concat-vertical-eq-pair :
+--     {x y : A} (p : x ＝ y) {x' : B x} {y' z' : B y} →
+--     (q : dependent-identification B p x' y') → (r : y' ＝ z') →
+--     eq-pair-Σ p (q ∙ r) ＝ eq-pair-Σ p q ∙ eq-pair-eq-fiber r
+--   concat-vertical-eq-pair {x} refl q r = ap-concat (pair x) q r
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : UU l1} {B : UU l2}
+--   {A' : A → UU l3} {B' : B → UU l4}
+--   {f : A → B} (f' : (a : A) → A' a → B' (f a))
+--   where
 
-  pasting-vertical-hom-htpy :
-    hom-htpy mid bottom {hB = hB} bottom-N bottom-F →
-    hom-htpy top mid {hB = hB'} top-N top-F →
-    hom-htpy top bottom {hB = hB ∘ hB'}
-      ( pasting-vertical-coherence-square-maps f'' hA' hB' f' hA hB f
-        top-N bottom-N)
-      ( pasting-vertical-coherence-square-maps g'' hA' hB' g' hA hB g
-        top-F bottom-F)
-  pasting-vertical-hom-htpy α β =
-    left-whisker-concat-coherence-square-homotopies
-      ( bottom-N ·r hA')
-      ( hB ·l mid ·r hA')
-      ( hB ·l top-N)
-      ( hB ·l top-F)
-      ( (hB ∘ hB') ·l top)
-      ( left-whisker-concat-htpy (hB ·l top-N)
-          ( inv-htpy (preserves-comp-left-whisker-comp hB hB' top)) ∙h
-        map-coherence-square-homotopies hB (mid ·r hA') top-N top-F (hB' ·l top)
-          ( β)) ∙h
-    right-whisker-concat-htpy (α ·r hA') (hB ·l top-F) ∙h
-    assoc-htpy (bottom ·r (hA ∘ hA')) (bottom-F ·r hA') (hB ·l top-F)
+--   ap-map-Σ-eq-fiber :
+--     {a : A} (x y : A' a) (p : x ＝ y) →
+--     ap (map-Σ B' f f') (eq-pair-eq-fiber p) ＝ eq-pair-eq-fiber (ap (f' a) p)
+--   ap-map-Σ-eq-fiber x .x refl = refl
+
+--   -- ap-map-Σ-eq-fiber' :
+--   --   {a : A} (x y : A' a) (p : x ＝ y) →
+--   --   ap (map-Σ B' f f') (eq-pair-eq-fiber p) ＝ eq-pair-eq-fiber (ap (f' a) p)
+--   -- ap-map-Σ-eq-fiber' {a} x y p =
+--   --   compute-ap-eq-pair-Σ (map-Σ B' f f') refl p ∙
+--   --   ap-comp (pair (f a)) (f' a) p
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : UU l1} {B : UU l2} {C : UU l3}
+--   {A' : A → UU l4} {B' : B → UU l5} {C' : C → UU l6}
+--   {f : A → B} {g : B → C}
+--   (f' : (a : A) → A' a → B' (f a))
+--   (g' : (b : B) → B' b → C' (g b))
+--   (sA : (a : A) → A' a) (sB : (b : B) → B' b) (sC : (c : C) → C' c)
+--   (F : (a : A) → f' a (sA a) ＝ sB (f a)) (G : (b : B) → g' b (sB b) ＝ sC (g b))
+--   where
 
-module _
-  {l1 l2 : Level}
-  {A : UU l1} {B : UU l2}
-  {f g : A → B} (H : f ~ g)
-  where
+--   pasting-horizontal-comp :
+--     pasting-horizontal-coherence-square-maps f g
+--       ( map-section-family sA) (map-section-family sB) (map-section-family sC)
+--       ( tot-map-over f f') (tot-map-over g g')
+--       ( eq-pair-eq-fiber ∘ F)
+--       ( eq-pair-eq-fiber ∘ G) ~
+--     eq-pair-eq-fiber ∘
+--       ((g' _) ·l F ∙h G ·r f)
+--   pasting-horizontal-comp a =
+--     ap
+--       ( _∙ eq-pair-eq-fiber (G (f a)))
+--       ( inv (ap-comp (tot-map-over g g') (pair (f a)) (F a)) ∙
+--         ap-comp (pair (g (f a))) (g' (f a)) (F a)) ∙
+--     inv (ap-concat (pair (g (f a))) (ap (g' (f a)) (F a)) (G (f a)))
 
-  id-hom-htpy : hom-htpy H H {hA = id} {hB = id} refl-htpy refl-htpy
-  id-hom-htpy = left-unit-law-left-whisker-comp H ∙h inv-htpy-right-unit-htpy
+-- module _
+--   {l1 l2 l3 l4 : Level}
+--   {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4}
+--   {f g : A → B} {f' g' : X → Y}
+--   (top : f' ~ g') (bottom : f ~ g)
+--   {hA : X → A} {hB : Y → B}
+--   (N : f ∘ hA ~ hB ∘ f') (F : g ∘ hA ~ hB ∘ g')
+--   where
 
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4}
-  (f g : A → B) (f' g' : X → Y)
-  (bottom : f ~ g) (top : f' ~ g')
-  (hA : X → A) (hB : Y → B)
-  (N : f ∘ hA ~ hB ∘ f') (F : g ∘ hA ~ hB ∘ g')
-  (α : hom-htpy top bottom N F)
-  (hA' : X → A) (hB' : Y → B)
-  (N' : f ∘ hA' ~ hB' ∘ f') (F' : g ∘ hA' ~ hB' ∘ g')
-  (β : hom-htpy top bottom N' F')
-  (σA : hA ~ hA') (σB : hB ~ hB')
-  (γN : htpy-hom-map f f' hA hB N hA' hB' N' σA σB)
-  (γF : htpy-hom-map g g' hA hB F hA' hB' F' σA σB)
-  where
+--   hom-htpy : UU (l2 ⊔ l3)
+--   hom-htpy = N ∙h (hB ·l top) ~ (bottom ·r hA) ∙h F
 
-  nudged-α nudged-β :
-    (N ∙h (hB ·l top)) ∙h (σB ·r g') ~
-    (f ·l σA) ∙h ((bottom ·r hA') ∙h F')
-  nudged-α =
-    right-whisker-concat-htpy α (σB ·r g') ∙h
-    assoc-htpy (bottom ·r hA) F (σB ·r g') ∙h
-    left-whisker-concat-htpy (bottom ·r hA) γF ∙h
-    right-whisker-concat-coherence-square-homotopies
-      ( f ·l σA)
-      ( bottom ·r hA)
-      ( bottom ·r hA')
-      ( g ·l σA)
-      ( λ x → nat-htpy bottom (σA x))
-      ( F')
-  nudged-β =
-    left-whisker-concat-coherence-square-homotopies N
-      ( σB ·r f')
-      ( hB ·l top)
-      ( hB' ·l top)
-      ( σB ·r g')
-      ( λ x → inv (nat-htpy σB (top x))) ∙h
-    right-whisker-concat-htpy γN (hB' ·l top) ∙h
-    assoc-htpy (f ·l σA) N' (hB' ·l top) ∙h
-    left-whisker-concat-htpy (f ·l σA) β
-
-  htpy-hom-htpy : UU (l2 ⊔ l3)
-  htpy-hom-htpy = nudged-α ~ nudged-β
+-- -- module _
+-- --   where
 
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
-  {f' g' : A' → B'} (top : f' ~ g')
-  {f g : A → B} (bottom : f ~ g)
-  (hA : A' → A) (hB : B' → B)
-  (N : coherence-square-maps f' hA hB f)
-  (F : coherence-square-maps g' hA hB g)
-  (α : hom-htpy top bottom {hB = hB} N F)
-  where
+-- --   alt-map-coherence-square-homotopies
 
-  coh-section-hom-htpy :
-    (sA : section hA) (sB : section hB)
-    (sN : coherence-square-maps f (map-section hA sA) (map-section hB sB) f')
-    (sF : coherence-square-maps g (map-section hA sA) (map-section hB sB) g')
-    (β : hom-htpy bottom top {hB = map-section hB sB} sN sF)
-    (γN :
-      htpy-hom-map f f
-        ( hA ∘ map-section hA sA) (hB ∘ map-section hB sB)
-        ( pasting-vertical-coherence-square-maps f
-          ( map-section hA sA) (map-section hB sB)
-          f' hA hB f sN N)
-        id id refl-htpy
-        ( is-section-map-section hA sA)
-        ( is-section-map-section hB sB))
-    (γF :
-      htpy-hom-map g g
-        ( hA ∘ pr1 sA) (hB ∘ pr1 sB)
-        ( pasting-vertical-coherence-square-maps g (pr1 sA) (pr1 sB) g' hA
-          hB g sF F)
-        id id refl-htpy (pr2 sA) (pr2 sB)) →
-    UU (l1 ⊔ l2)
-  coh-section-hom-htpy sA sB sN sF β =
-    htpy-hom-htpy f g f g bottom bottom
-      ( hA ∘ map-section hA sA)
-      ( hB ∘ map-section hB sB)
-      ( pasting-vertical-coherence-square-maps f map-sA map-sB f' hA hB f sN N)
-      ( pasting-vertical-coherence-square-maps g map-sA map-sB g' hA hB g sF F)
-      ( pasting-vertical-hom-htpy top bottom bottom N F sN sF α β)
-      id id refl-htpy refl-htpy (id-hom-htpy bottom)
-      ( is-section-map-section hA sA)
-      ( is-section-map-section hB sB)
-    where
-      map-sA : A → A'
-      map-sA = map-section hA sA
-      map-sB : B → B'
-      map-sB = map-section hB sB
+-- module _
+--   {l1 l2 l3 l4 l5 l6 : Level}
+--   {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4} {V : UU l5} {W : UU l6}
+--   {f g : A → B} {f' g' : X → Y} {f'' g'' : V → W}
+--   (mid : f' ~ g') (bottom : f ~ g) (top : f'' ~ g'')
+--   {hA : X → A} {hB : Y → B} {hA' : V → X} {hB' : W → Y}
+--   (bottom-N : f ∘ hA ~ hB ∘ f') (bottom-F : g ∘ hA ~ hB ∘ g')
+--   (top-N : f' ∘ hA' ~ hB' ∘ f'') (top-F : g' ∘ hA' ~ hB' ∘ g'')
+--   where
 
-module _
-  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
-  where
+--   pasting-vertical-hom-htpy :
+--     hom-htpy mid bottom {hB = hB} bottom-N bottom-F →
+--     hom-htpy top mid {hB = hB'} top-N top-F →
+--     hom-htpy top bottom {hB = hB ∘ hB'}
+--       ( pasting-vertical-coherence-square-maps f'' hA' hB' f' hA hB f
+--         top-N bottom-N)
+--       ( pasting-vertical-coherence-square-maps g'' hA' hB' g' hA hB g
+--         top-F bottom-F)
+--   pasting-vertical-hom-htpy α β =
+--     left-whisker-concat-coherence-square-homotopies
+--       ( bottom-N ·r hA')
+--       ( hB ·l mid ·r hA')
+--       ( hB ·l top-N)
+--       ( hB ·l top-F)
+--       ( (hB ∘ hB') ·l top)
+--       ( left-whisker-concat-htpy (hB ·l top-N)
+--           ( inv-htpy (preserves-comp-left-whisker-comp hB hB' top)) ∙h
+--         map-coherence-square-homotopies hB (mid ·r hA') top-N top-F (hB' ·l top)
+--           ( β)) ∙h
+--     right-whisker-concat-htpy (α ·r hA') (hB ·l top-F) ∙h
+--     assoc-htpy (bottom ·r (hA ∘ hA')) (bottom-F ·r hA') (hB ·l top-F)
 
-  compute-concat-dependent-identification-right-base-refl :
-    { x y : A} (p : x ＝ y) →
-    { x' : B x} {y' z' : B y} (p' : dependent-identification B p x' y') →
-    ( q' : y' ＝ z') →
-    concat-dependent-identification B p refl p' q' ＝ ap (λ r → tr B r x') right-unit ∙ p' ∙ q'
-  compute-concat-dependent-identification-right-base-refl refl p' q' = ap (_∙ q') (ap-id p')
-
-  interchange-concat-eq-pair-Σ-left :
-    {y z : A} (q : y ＝ z) {x' y' : B y} {z' : B z} →
-    (p' : x' ＝ y')
-    (q' : dependent-identification B q y' z') →
-    eq-pair-eq-fiber p' ∙ eq-pair-Σ q q' ＝
-    eq-pair-Σ q (ap (tr B q) p' ∙ q')
-  interchange-concat-eq-pair-Σ-left q refl q' = refl
-
-  interchange-concat-eq-pair-Σ-right :
-    {x y : A} (p : x ＝ y) {x' : B x} {y' z' : B y} →
-    (p' : dependent-identification B p x' y') →
-    (q' : y' ＝ z') →
-    eq-pair-Σ p p' ∙ eq-pair-eq-fiber q' ＝
-    eq-pair-Σ p (p' ∙ q')
-  interchange-concat-eq-pair-Σ-right p p' refl =
-    right-unit ∙ ap (eq-pair-Σ p) (inv right-unit)
+-- module _
+--   {l1 l2 : Level}
+--   {A : UU l1} {B : UU l2}
+--   {f g : A → B} (H : f ~ g)
+--   where
 
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2} {P : A → UU l3} {Q : B → UU l4}
-  {f g : A → B} (H : f ~ g)
-  {f' : (a : A) → P a → Q (f a)} {g' : (a : A) → P a → Q (g a)}
-  (H' : htpy-over Q H (f' _) (g' _))
-  (sA : (a : A) → P a)
-  (sB : (b : B) → Q b)
-  (F : section-map-over f (f' _) sA sB)
-  (G : section-map-over g (g' _) sA sB)
-  (α : section-htpy-over H H' sA sB F G)
-  where
-  open import foundation.embeddings
-
-  _ : coh-section-hom-htpy
-    ( λ p → eq-pair-Σ (H (pr1 p)) (H' (pr2 p)))
-    ( H)
-    pr1 pr1 refl-htpy refl-htpy
-    ( λ p → ap-pr1-eq-pair-Σ (H (pr1 p)) (H' (pr2 p)) ∙ inv right-unit)
-    ( section-dependent-function sA)
-    ( section-dependent-function sB)
-    ( eq-pair-eq-fiber ∘ F)
-    ( eq-pair-eq-fiber ∘ G)
-    -- The point is that this will be `ap pr1`'d, so the α in the fiber is
-    -- projected away. This definition should probably be defined in a nicer way
-    -- to make the proof less opaque.
-    ( λ a →
-      ap (eq-pair-eq-fiber (F a) ∙_) (ap-map-section-family-lemma sB (H a)) ∙
-      interchange-concat-eq-pair-Σ-left (H a) (F a) (apd sB (H a)) ∙
-      ap (eq-pair-Σ (H a)) (inv (α a)) ∙
-      inv (interchange-concat-eq-pair-Σ-right (H a) (H' (sA a)) (G a)))
-    ( λ a → right-unit ∙ ap-pr1-eq-pair-eq-fiber (F a))
-    ( λ a → right-unit ∙ ap-pr1-eq-pair-eq-fiber (G a))
-  _ = {!!}
+--   id-hom-htpy : hom-htpy H H {hA = id} {hB = id} refl-htpy refl-htpy
+--   id-hom-htpy = left-unit-law-left-whisker-comp H ∙h inv-htpy-right-unit-htpy
 
 -- module _
---   {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
---   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
---   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
---   {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
---   (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
---   (top : h' ∘ f' ~ k' ∘ g')
---   (bottom : h ∘ f ~ k ∘ g)
---   (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
---   (back-left : (f ∘ hA) ~ (hB ∘ f'))
---   (back-right : (g ∘ hA) ~ (hC ∘ g'))
---   (front-left : (h ∘ hB) ~ (hD ∘ h'))
---   (front-right : (k ∘ hC) ~ (hD ∘ k'))
---   (α :
---     coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
---       top back-left back-right front-left front-right bottom)
---   (hA' : A' → A) (hB' : B' → B) (hC' : C' → C) (hD' : D' → D)
---   (back-left' : (f ∘ hA') ~ (hB' ∘ f'))
---   (back-right' : (g ∘ hA') ~ (hC' ∘ g'))
---   (front-left' : (h ∘ hB') ~ (hD' ∘ h'))
---   (front-right' : (k ∘ hC') ~ (hD' ∘ k'))
---   (β :
---     coherence-cube-maps f g h k f' g' h' k' hA' hB' hC' hD'
---       top back-left' back-right' front-left' front-right' bottom)
---   (σA : hA ~ hA') (σB : hB ~ hB') (σC : hC ~ hC') (σD : hD ~ hD')
---   (back-left-H : htpy-hom-map f f' hA hB back-left hA' hB' back-left' σA σB)
---   (back-right-H : htpy-hom-map g g' hA hC back-right hA' hC' back-right' σA σC)
---   (front-left-H : htpy-hom-map h h' hB hD front-left hB' hD' front-left' σB σD)
---   (front-right-H : htpy-hom-map k k' hC hD front-right hC' hD' front-right' σC σD)
+--   {l1 l2 l3 l4 : Level}
+--   {A : UU l1} {B : UU l2} {X : UU l3} {Y : UU l4}
+--   (f g : A → B) (f' g' : X → Y)
+--   (bottom : f ~ g) (top : f' ~ g')
+--   (hA : X → A) (hB : Y → B)
+--   (N : f ∘ hA ~ hB ∘ f') (F : g ∘ hA ~ hB ∘ g')
+--   (α : hom-htpy top bottom N F)
+--   (hA' : X → A) (hB' : Y → B)
+--   (N' : f ∘ hA' ~ hB' ∘ f') (F' : g ∘ hA' ~ hB' ∘ g')
+--   (β : hom-htpy top bottom N' F')
+--   (σA : hA ~ hA') (σB : hB ~ hB')
+--   (γN : htpy-hom-map f f' hA hB N hA' hB' N' σA σB)
+--   (γF : htpy-hom-map g g' hA hB F hA' hB' F' σA σB)
 --   where
---   open import foundation.commuting-squares-of-homotopies
 
---   htpy-hom-square :
---     UU (l4 ⊔ l1')
---   htpy-hom-square =
---     htpy-hom-htpy (h ∘ f) (k ∘ g) (h' ∘ f') (k' ∘ g') bottom top hA hD
---       ( pasting-horizontal-coherence-square-maps f' h' hA hB hD f h back-left front-left)
---       ( pasting-horizontal-coherence-square-maps g' k' hA hC hD g k back-right front-right)
---       ( α)
---       hA' hD'
---       ( pasting-horizontal-coherence-square-maps f' h' hA' hB' hD' f h back-left' front-left')
---       ( pasting-horizontal-coherence-square-maps g' k' hA' hC' hD' g k back-right' front-right')
---       ( β)
---       σA σD
---       ( comp-htpy-hom-map f h f' h' hA hA' hB hB' hD hD' σA σB σD
---         back-left back-left' back-left-H
---         front-left front-left' front-left-H)
---       ( comp-htpy-hom-map g k g' k' hA hA' hC hC' hD hD' σA σC σD
---         back-right back-right' back-right-H
---         front-right front-right' front-right-H)
+--   nudged-α nudged-β :
+--     (N ∙h (hB ·l top)) ∙h (σB ·r g') ~
+--     (f ·l σA) ∙h ((bottom ·r hA') ∙h F')
+--   nudged-α =
+--     right-whisker-concat-htpy α (σB ·r g') ∙h
+--     assoc-htpy (bottom ·r hA) F (σB ·r g') ∙h
+--     left-whisker-concat-htpy (bottom ·r hA) γF ∙h
+--     right-whisker-concat-coherence-square-homotopies
+--       ( f ·l σA)
+--       ( bottom ·r hA)
+--       ( bottom ·r hA')
+--       ( g ·l σA)
+--       ( λ x → nat-htpy bottom (σA x))
+--       ( F')
+--   nudged-β =
+--     left-whisker-concat-coherence-square-homotopies N
+--       ( σB ·r f')
+--       ( hB ·l top)
+--       ( hB' ·l top)
+--       ( σB ·r g')
+--       ( λ x → inv (nat-htpy σB (top x))) ∙h
+--     right-whisker-concat-htpy γN (hB' ·l top) ∙h
+--     assoc-htpy (f ·l σA) N' (hB' ·l top) ∙h
+--     left-whisker-concat-htpy (f ·l σA) β
+
+--   htpy-hom-htpy : UU (l2 ⊔ l3)
+--   htpy-hom-htpy = nudged-α ~ nudged-β
 
 -- module _
 --   {l1 l2 l3 l4 : Level}
---   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
---   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
---   (H : coherence-square-maps g f k h)
+--   {A : UU l1} {B : UU l2} {A' : UU l3} {B' : UU l4}
+--   {f' g' : A' → B'} (top : f' ~ g')
+--   {f g : A → B} (bottom : f ~ g)
+--   (hA : A' → A) (hB : B' → B)
+--   (N : coherence-square-maps f' hA hB f)
+--   (F : coherence-square-maps g' hA hB g)
+--   (α : hom-htpy top bottom {hB = hB} N F)
 --   where
 
---   id-cube :
---     coherence-cube-maps f g h k f g h k id id id id
---       H refl-htpy refl-htpy refl-htpy refl-htpy H
---   id-cube = left-unit-law-left-whisker-comp H ∙h inv-htpy-right-unit-htpy
+--   coh-section-hom-htpy :
+--     (sA : section hA) (sB : section hB)
+--     (sN : coherence-square-maps f (map-section hA sA) (map-section hB sB) f')
+--     (sF : coherence-square-maps g (map-section hA sA) (map-section hB sB) g')
+--     (β : hom-htpy bottom top {hB = map-section hB sB} sN sF)
+--     (γN :
+--       htpy-hom-map f f
+--         ( hA ∘ map-section hA sA) (hB ∘ map-section hB sB)
+--         ( pasting-vertical-coherence-square-maps f
+--           ( map-section hA sA) (map-section hB sB)
+--           f' hA hB f sN N)
+--         id id refl-htpy
+--         ( is-section-map-section hA sA)
+--         ( is-section-map-section hB sB))
+--     (γF :
+--       htpy-hom-map g g
+--         ( hA ∘ pr1 sA) (hB ∘ pr1 sB)
+--         ( pasting-vertical-coherence-square-maps g (pr1 sA) (pr1 sB) g' hA
+--           hB g sF F)
+--         id id refl-htpy (pr2 sA) (pr2 sB)) →
+--     UU (l1 ⊔ l2)
+--   coh-section-hom-htpy sA sB sN sF β =
+--     htpy-hom-htpy f g f g bottom bottom
+--       ( hA ∘ map-section hA sA)
+--       ( hB ∘ map-section hB sB)
+--       ( pasting-vertical-coherence-square-maps f map-sA map-sB f' hA hB f sN N)
+--       ( pasting-vertical-coherence-square-maps g map-sA map-sB g' hA hB g sF F)
+--       ( pasting-vertical-hom-htpy top bottom bottom N F sN sF α β)
+--       id id refl-htpy refl-htpy (id-hom-htpy bottom)
+--       ( is-section-map-section hA sA)
+--       ( is-section-map-section hB sB)
+--     where
+--       map-sA : A → A'
+--       map-sA = map-section hA sA
+--       map-sB : B → B'
+--       map-sB = map-section hB sB
 
 -- module _
---   {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
---   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
---   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
---   {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
---   (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
---   (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
---   (top : (h' ∘ f') ~ (k' ∘ g'))
---   (back-left : (f ∘ hA) ~ (hB ∘ f'))
---   (back-right : (g ∘ hA) ~ (hC ∘ g'))
---   (front-left : (h ∘ hB) ~ (hD ∘ h'))
---   (front-right : (k ∘ hC) ~ (hD ∘ k'))
---   (bottom : (h ∘ f) ~ (k ∘ g))
---   (α :
---     coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
---       top back-left back-right front-left front-right bottom)
+--   {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
 --   where
 
---   section-displayed-cube-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4 ⊔ l1' ⊔ l2' ⊔ l3' ⊔ l4')
---   section-displayed-cube-over =
---     Σ ( section-displayed-map-over f f' hA hB back-left)
---       ( λ sF →
---         Σ ( section-displayed-map-over k k' hC hD front-right)
---           ( λ sK →
---             Σ ( coherence-square-maps g
---                 ( map-section hA (pr1 sF))
---                 ( map-section hC (pr1 sK))
---                 ( g'))
---               ( λ G →
---                 Σ ( htpy-hom-map g g
---                     ( hA ∘ map-section hA (pr1 sF))
---                     ( hC ∘ map-section hC (pr1 sK))
---                     ( pasting-vertical-coherence-square-maps g
---                       ( map-section hA (pr1 sF))
---                       ( map-section hC (pr1 sK))
---                       g' hA hC g
---                       G back-right)
---                     id id refl-htpy
---                     ( is-section-map-section hA (pr1 sF))
---                     ( is-section-map-section hC (pr1 sK)))
---                   ( λ sG →
---                     Σ ( coherence-square-maps h
---                         ( map-section hB (pr1 (pr2 sF)))
---                         ( map-section hD (pr1 (pr2 sK)))
---                         ( h'))
---                       ( λ H →
---                         Σ ( htpy-hom-map h h
---                             ( hB ∘ map-section hB (pr1 (pr2 sF)))
---                             ( hD ∘ map-section hD (pr1 (pr2 sK)))
---                             ( pasting-vertical-coherence-square-maps h
---                               ( map-section hB (pr1 (pr2 sF)))
---                               ( map-section hD (pr1 (pr2 sK)))
---                               h' hB hD h
---                               H front-left)
---                             id id refl-htpy
---                             ( is-section-map-section hB (pr1 (pr2 sF)))
---                             ( is-section-map-section hD (pr1 (pr2 sK))))
---                           ( λ sH →
---                             Σ ( coherence-cube-maps f' g' h' k' f g h k
---                                 ( map-section hA (pr1 sF))
---                                 ( map-section hB (pr1 (pr2 sF)))
---                                 ( map-section hC (pr1 sK))
---                                 ( map-section hD (pr1 (pr2 sK)))
---                                 ( bottom)
---                                 ( pr1 (pr2 (pr2 sF)))
---                                 ( G)
---                                 ( H)
---                                 ( pr1 (pr2 (pr2 sK)))
---                                 ( top))
---                               ( λ β →
---                                 htpy-hom-square f g h k f g h k bottom bottom
---                                   ( hA ∘ map-section hA (pr1 sF))
---                                   ( hB ∘ map-section hB (pr1 (pr2 sF)))
---                                   ( hC ∘ map-section hC (pr1 sK))
---                                   ( hD ∘ map-section hD (pr1 (pr2 sK)))
---                                   ( pasting-vertical-coherence-square-maps f
---                                     ( map-section hA (pr1 sF))
---                                     ( map-section hB (pr1 (pr2 sF)))
---                                     f' hA hB f
---                                     ( pr1 (pr2 (pr2 sF)))
---                                     ( back-left))
---                                   ( pasting-vertical-coherence-square-maps g
---                                     ( map-section hA (pr1 sF))
---                                     ( map-section hC (pr1 sK))
---                                     g' hA hC g
---                                     ( G)
---                                     ( back-right))
---                                   ( pasting-vertical-coherence-square-maps h
---                                     ( map-section hB (pr1 (pr2 sF)))
---                                     ( map-section hD (pr1 (pr2 sK)))
---                                     h' hB hD h
---                                     ( H)
---                                     ( front-left))
---                                   ( pasting-vertical-coherence-square-maps k
---                                     ( map-section hC (pr1 sK))
---                                     ( map-section hD (pr1 (pr2 sK)))
---                                     k' hC hD k
---                                     ( pr1 (pr2 (pr2 sK)))
---                                     ( front-right))
---                                   ( pasting-vertical-coherence-cube-maps f g h k
---                                     f' g' h' k' f g h k
---                                     hA hB hC hD
---                                     ( map-section hA (pr1 sF))
---                                     ( map-section hB (pr1 (pr2 sF)))
---                                     ( map-section hC (pr1 sK))
---                                     ( map-section hD (pr1 (pr2 sK)))
---                                     ( top)
---                                     back-left back-right front-left front-right bottom
---                                     ( bottom)
---                                     ( pr1 (pr2 (pr2 sF)))
---                                     ( G)
---                                     ( H)
---                                     ( pr1 (pr2 (pr2 sK)))
---                                     ( α)
---                                     ( β))
---                                   id id id id
---                                   refl-htpy refl-htpy refl-htpy refl-htpy
---                                   ( id-cube f g h k bottom)
---                                   ( is-section-map-section hA (pr1 sF))
---                                   ( is-section-map-section hB (pr1 (pr2 sF)))
---                                   ( is-section-map-section hC (pr1 sK))
---                                   ( is-section-map-section hD (pr1 (pr2 sK)))
---                                   ( pr2 (pr2 (pr2 sF)))
---                                   ( sG)
---                                   ( sH)
---                                   ( pr2 (pr2 (pr2 sK))))))))))
+--   compute-concat-dependent-identification-right-base-refl :
+--     { x y : A} (p : x ＝ y) →
+--     { x' : B x} {y' z' : B y} (p' : dependent-identification B p x' y') →
+--     ( q' : y' ＝ z') →
+--     concat-dependent-identification B p refl p' q' ＝ ap (λ r → tr B r x') right-unit ∙ p' ∙ q'
+--   compute-concat-dependent-identification-right-base-refl refl p' q' = ap (_∙ q') (ap-id p')
+
+--   interchange-concat-eq-pair-Σ-left :
+--     {y z : A} (q : y ＝ z) {x' y' : B y} {z' : B z} →
+--     (p' : x' ＝ y')
+--     (q' : dependent-identification B q y' z') →
+--     eq-pair-eq-fiber p' ∙ eq-pair-Σ q q' ＝
+--     eq-pair-Σ q (ap (tr B q) p' ∙ q')
+--   interchange-concat-eq-pair-Σ-left q refl q' = refl
+
+--   interchange-concat-eq-pair-Σ-right :
+--     {x y : A} (p : x ＝ y) {x' : B x} {y' z' : B y} →
+--     (p' : dependent-identification B p x' y') →
+--     (q' : y' ＝ z') →
+--     eq-pair-Σ p p' ∙ eq-pair-eq-fiber q' ＝
+--     eq-pair-Σ p (p' ∙ q')
+--   interchange-concat-eq-pair-Σ-right p p' refl =
+--     right-unit ∙ ap (eq-pair-Σ p) (inv right-unit)
 
 -- module _
---   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
---   {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
---   {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
---   (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
---   (g1' : (p : P1) → Q1 p → Q3 (g1 p))
---   (f1' : (p : P1) → Q1 p → Q2 (f1 p))
---   (f2' : (p : P3) → Q3 p → Q4 (f2 p))
---   (g2' : (p : P2) → Q2 p → Q4 (g2 p))
---   (bottom : g2 ∘ f1 ~ f2 ∘ g1)
---   (top : square-over g1 f1 f2 g2 (g1' _) (f1' _) (f2' _) (g2' _) bottom)
+--   {l1 l2 l3 l4 : Level}
+--   {A : UU l1} {B : UU l2} {P : A → UU l3} {Q : B → UU l4}
+--   {f g : A → B} (H : f ~ g)
+--   {f' : (a : A) → P a → Q (f a)} {g' : (a : A) → P a → Q (g a)}
+--   (H' : htpy-over Q H (f' _) (g' _))
+--   (sA : (a : A) → P a)
+--   (sB : (b : B) → Q b)
+--   (F : section-map-over f (f' _) sA sB)
+--   (G : section-map-over g (g' _) sA sB)
+--   (α : section-htpy-over H H' sA sB F G)
 --   where
-
---   tot-square-over :
---     coherence-square-maps
---       ( tot-map-over g1 g1')
---       ( tot-map-over f1 f1')
---       ( tot-map-over {B' = Q4} f2 f2')
---       ( tot-map-over g2 g2')
---   tot-square-over =
---     coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})
-
---   coh-tot-square-over :
---     coherence-cube-maps f1 g1 g2 f2
---       ( map-Σ Q2 f1 f1')
---       ( map-Σ Q3 g1 g1')
---       ( map-Σ Q4 g2 g2')
---       ( map-Σ Q4 f2 f2')
---       pr1 pr1 pr1 pr1
---       ( tot-square-over)
---       refl-htpy refl-htpy refl-htpy refl-htpy
---       ( bottom)
---   coh-tot-square-over (p , q) =
---     ap-pr1-eq-pair-Σ (bottom p) (top q) ∙ inv right-unit
-
---   module _
---     (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p)
---     (s3 : (p : P3) → Q3 p) (s4 : (p : P4) → Q4 p)
---     (G1 : (p : P1) → g1' p (s1 p) ＝ s3 (g1 p))
---     (F1 : (p : P1) → f1' p (s1 p) ＝ s2 (f1 p))
---     (F2 : (p : P3) → f2' p (s3 p) ＝ s4 (f2 p))
---     (G2 : (p : P2) → g2' p (s2 p) ＝ s4 (g2 p))
---     where
---     open import foundation.action-on-identifications-binary-functions
-
---     lemma :
---       pasting-vertical-coherence-square-maps g1
---         ( map-section-family s1) (map-section-family s3)
---         ( tot-map-over g1 g1') (tot-map-over f1 f1')
---         ( tot-map-over {B' = Q4} f2 f2') (tot-map-over g2 g2')
---         ( eq-pair-eq-fiber ∘ G1)
---         ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})) ~
---       ( λ p → eq-pair-Σ (bottom p) (top (s1 p) ∙ ap (f2' (g1 p)) (G1 p)))
---     lemma = λ p → ap
---               ( eq-pair-Σ (bottom p) (top (s1 p)) ∙_)
---               ( [i] p) ∙
---               ( inv (concat-vertical-eq-pair (bottom p) (top (s1 p)) (ap (f2' (g1 p)) (G1 p))))
---         where
---         [i] =
---           λ (p : P1) →
---           inv (ap-comp (map-Σ Q4 f2 f2') (pair (g1 p)) (G1 p)) ∙
---           ap-comp (pair (f2 (g1 p))) (f2' (g1 p)) (G1 p)
-
---     section-cube-over-sect-square-over :
---       section-square-over g1 f1 f2 g2
---         ( g1' _) (f1' _) (f2' _) (g2' _)
---         s1 s2 s3 s4
---         G1 F1 F2 G2
---         bottom top →
---       section-displayed-cube-over f1 g1 g2 f2
---         ( tot-map-over f1 f1')
---         ( tot-map-over g1 g1')
---         ( tot-map-over g2 g2')
---         ( tot-map-over f2 f2')
---         pr1 pr1 pr1 pr1
---         ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p}))
---         refl-htpy refl-htpy refl-htpy refl-htpy
---         ( bottom)
---         ( coh-tot-square-over)
---     pr1 (section-cube-over-sect-square-over α) =
---       ( section-dependent-function s1) ,
---       ( section-dependent-function s2) ,
---       ( eq-pair-eq-fiber ∘ F1) ,
---       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F1 p))
---     pr1 (pr2 (section-cube-over-sect-square-over α)) =
---       ( section-dependent-function s3) ,
---       ( section-dependent-function s4) ,
---       ( eq-pair-eq-fiber ∘ F2) ,
---       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F2 p))
---     pr2 (pr2 (section-cube-over-sect-square-over α)) =
---       ( eq-pair-eq-fiber ∘ G1) ,
---       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G1 p)) ,
---       ( eq-pair-eq-fiber ∘ G2) ,
---       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G2 p)) ,
---       ( λ p →
---         ap-binary
---           ( _∙_)
---           ( pasting-horizontal-comp f1' g2' s1 s2 s4 F1 G2 p)
---           ( ap-map-section-family-lemma s4 (bottom p)) ∙
---         {!!} ∙
---         ap (eq-pair-Σ (bottom p)) (inv (α p) ∙ assoc (top (s1 p)) (ap (f2' (g1 p)) (G1 p)) (F2 (g1 p))) ∙
---         concat-vertical-eq-pair
---           ( bottom p)
---           ( top (s1 p))
---           ( ap (f2' (g1 p)) (G1 p) ∙ F2 (g1 p)) ∙
---         ap-binary
---           ( _∙_)
---           ( refl {x = eq-pair-Σ (bottom p) (top (s1 p))})
---           ( inv (pasting-horizontal-comp g1' f2' s1 s3 s4 G1 F2 p))) ,
---       {!!}
--- ```
+--   open import foundation.embeddings
+
+--   _ : coh-section-hom-htpy
+--     ( λ p → eq-pair-Σ (H (pr1 p)) (H' (pr2 p)))
+--     ( H)
+--     pr1 pr1 refl-htpy refl-htpy
+--     ( λ p → ap-pr1-eq-pair-Σ (H (pr1 p)) (H' (pr2 p)) ∙ inv right-unit)
+--     ( section-dependent-function sA)
+--     ( section-dependent-function sB)
+--     ( eq-pair-eq-fiber ∘ F)
+--     ( eq-pair-eq-fiber ∘ G)
+--     -- The point is that this will be `ap pr1`'d, so the α in the fiber is
+--     -- projected away. This definition should probably be defined in a nicer way
+--     -- to make the proof less opaque.
+--     ( λ a →
+--       ap (eq-pair-eq-fiber (F a) ∙_) (ap-map-section-family-lemma sB (H a)) ∙
+--       interchange-concat-eq-pair-Σ-left (H a) (F a) (apd sB (H a)) ∙
+--       ap (eq-pair-Σ (H a)) (inv (α a)) ∙
+--       inv (interchange-concat-eq-pair-Σ-right (H a) (H' (sA a)) (G a)))
+--     ( λ a → right-unit ∙ ap-pr1-eq-pair-eq-fiber (F a))
+--     ( λ a → right-unit ∙ ap-pr1-eq-pair-eq-fiber (G a))
+--   _ = {!!}
+
+-- -- module _
+-- --   {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
+-- --   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+-- --   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+-- --   {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
+-- --   (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
+-- --   (top : h' ∘ f' ~ k' ∘ g')
+-- --   (bottom : h ∘ f ~ k ∘ g)
+-- --   (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
+-- --   (back-left : (f ∘ hA) ~ (hB ∘ f'))
+-- --   (back-right : (g ∘ hA) ~ (hC ∘ g'))
+-- --   (front-left : (h ∘ hB) ~ (hD ∘ h'))
+-- --   (front-right : (k ∘ hC) ~ (hD ∘ k'))
+-- --   (α :
+-- --     coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
+-- --       top back-left back-right front-left front-right bottom)
+-- --   (hA' : A' → A) (hB' : B' → B) (hC' : C' → C) (hD' : D' → D)
+-- --   (back-left' : (f ∘ hA') ~ (hB' ∘ f'))
+-- --   (back-right' : (g ∘ hA') ~ (hC' ∘ g'))
+-- --   (front-left' : (h ∘ hB') ~ (hD' ∘ h'))
+-- --   (front-right' : (k ∘ hC') ~ (hD' ∘ k'))
+-- --   (β :
+-- --     coherence-cube-maps f g h k f' g' h' k' hA' hB' hC' hD'
+-- --       top back-left' back-right' front-left' front-right' bottom)
+-- --   (σA : hA ~ hA') (σB : hB ~ hB') (σC : hC ~ hC') (σD : hD ~ hD')
+-- --   (back-left-H : htpy-hom-map f f' hA hB back-left hA' hB' back-left' σA σB)
+-- --   (back-right-H : htpy-hom-map g g' hA hC back-right hA' hC' back-right' σA σC)
+-- --   (front-left-H : htpy-hom-map h h' hB hD front-left hB' hD' front-left' σB σD)
+-- --   (front-right-H : htpy-hom-map k k' hC hD front-right hC' hD' front-right' σC σD)
+-- --   where
+-- --   open import foundation.commuting-squares-of-homotopies
+
+-- --   htpy-hom-square :
+-- --     UU (l4 ⊔ l1')
+-- --   htpy-hom-square =
+-- --     htpy-hom-htpy (h ∘ f) (k ∘ g) (h' ∘ f') (k' ∘ g') bottom top hA hD
+-- --       ( pasting-horizontal-coherence-square-maps f' h' hA hB hD f h back-left front-left)
+-- --       ( pasting-horizontal-coherence-square-maps g' k' hA hC hD g k back-right front-right)
+-- --       ( α)
+-- --       hA' hD'
+-- --       ( pasting-horizontal-coherence-square-maps f' h' hA' hB' hD' f h back-left' front-left')
+-- --       ( pasting-horizontal-coherence-square-maps g' k' hA' hC' hD' g k back-right' front-right')
+-- --       ( β)
+-- --       σA σD
+-- --       ( comp-htpy-hom-map f h f' h' hA hA' hB hB' hD hD' σA σB σD
+-- --         back-left back-left' back-left-H
+-- --         front-left front-left' front-left-H)
+-- --       ( comp-htpy-hom-map g k g' k' hA hA' hC hC' hD hD' σA σC σD
+-- --         back-right back-right' back-right-H
+-- --         front-right front-right' front-right-H)
+
+-- -- module _
+-- --   {l1 l2 l3 l4 : Level}
+-- --   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+-- --   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+-- --   (H : coherence-square-maps g f k h)
+-- --   where
+
+-- --   id-cube :
+-- --     coherence-cube-maps f g h k f g h k id id id id
+-- --       H refl-htpy refl-htpy refl-htpy refl-htpy H
+-- --   id-cube = left-unit-law-left-whisker-comp H ∙h inv-htpy-right-unit-htpy
+
+-- -- module _
+-- --   {l1 l2 l3 l4 l1' l2' l3' l4' : Level}
+-- --   {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
+-- --   (f : A → B) (g : A → C) (h : B → D) (k : C → D)
+-- --   {A' : UU l1'} {B' : UU l2'} {C' : UU l3'} {D' : UU l4'}
+-- --   (f' : A' → B') (g' : A' → C') (h' : B' → D') (k' : C' → D')
+-- --   (hA : A' → A) (hB : B' → B) (hC : C' → C) (hD : D' → D)
+-- --   (top : (h' ∘ f') ~ (k' ∘ g'))
+-- --   (back-left : (f ∘ hA) ~ (hB ∘ f'))
+-- --   (back-right : (g ∘ hA) ~ (hC ∘ g'))
+-- --   (front-left : (h ∘ hB) ~ (hD ∘ h'))
+-- --   (front-right : (k ∘ hC) ~ (hD ∘ k'))
+-- --   (bottom : (h ∘ f) ~ (k ∘ g))
+-- --   (α :
+-- --     coherence-cube-maps f g h k f' g' h' k' hA hB hC hD
+-- --       top back-left back-right front-left front-right bottom)
+-- --   where
+
+-- --   section-displayed-cube-over : UU (l1 ⊔ l2 ⊔ l3 ⊔ l4 ⊔ l1' ⊔ l2' ⊔ l3' ⊔ l4')
+-- --   section-displayed-cube-over =
+-- --     Σ ( section-displayed-map-over f f' hA hB back-left)
+-- --       ( λ sF →
+-- --         Σ ( section-displayed-map-over k k' hC hD front-right)
+-- --           ( λ sK →
+-- --             Σ ( coherence-square-maps g
+-- --                 ( map-section hA (pr1 sF))
+-- --                 ( map-section hC (pr1 sK))
+-- --                 ( g'))
+-- --               ( λ G →
+-- --                 Σ ( htpy-hom-map g g
+-- --                     ( hA ∘ map-section hA (pr1 sF))
+-- --                     ( hC ∘ map-section hC (pr1 sK))
+-- --                     ( pasting-vertical-coherence-square-maps g
+-- --                       ( map-section hA (pr1 sF))
+-- --                       ( map-section hC (pr1 sK))
+-- --                       g' hA hC g
+-- --                       G back-right)
+-- --                     id id refl-htpy
+-- --                     ( is-section-map-section hA (pr1 sF))
+-- --                     ( is-section-map-section hC (pr1 sK)))
+-- --                   ( λ sG →
+-- --                     Σ ( coherence-square-maps h
+-- --                         ( map-section hB (pr1 (pr2 sF)))
+-- --                         ( map-section hD (pr1 (pr2 sK)))
+-- --                         ( h'))
+-- --                       ( λ H →
+-- --                         Σ ( htpy-hom-map h h
+-- --                             ( hB ∘ map-section hB (pr1 (pr2 sF)))
+-- --                             ( hD ∘ map-section hD (pr1 (pr2 sK)))
+-- --                             ( pasting-vertical-coherence-square-maps h
+-- --                               ( map-section hB (pr1 (pr2 sF)))
+-- --                               ( map-section hD (pr1 (pr2 sK)))
+-- --                               h' hB hD h
+-- --                               H front-left)
+-- --                             id id refl-htpy
+-- --                             ( is-section-map-section hB (pr1 (pr2 sF)))
+-- --                             ( is-section-map-section hD (pr1 (pr2 sK))))
+-- --                           ( λ sH →
+-- --                             Σ ( coherence-cube-maps f' g' h' k' f g h k
+-- --                                 ( map-section hA (pr1 sF))
+-- --                                 ( map-section hB (pr1 (pr2 sF)))
+-- --                                 ( map-section hC (pr1 sK))
+-- --                                 ( map-section hD (pr1 (pr2 sK)))
+-- --                                 ( bottom)
+-- --                                 ( pr1 (pr2 (pr2 sF)))
+-- --                                 ( G)
+-- --                                 ( H)
+-- --                                 ( pr1 (pr2 (pr2 sK)))
+-- --                                 ( top))
+-- --                               ( λ β →
+-- --                                 htpy-hom-square f g h k f g h k bottom bottom
+-- --                                   ( hA ∘ map-section hA (pr1 sF))
+-- --                                   ( hB ∘ map-section hB (pr1 (pr2 sF)))
+-- --                                   ( hC ∘ map-section hC (pr1 sK))
+-- --                                   ( hD ∘ map-section hD (pr1 (pr2 sK)))
+-- --                                   ( pasting-vertical-coherence-square-maps f
+-- --                                     ( map-section hA (pr1 sF))
+-- --                                     ( map-section hB (pr1 (pr2 sF)))
+-- --                                     f' hA hB f
+-- --                                     ( pr1 (pr2 (pr2 sF)))
+-- --                                     ( back-left))
+-- --                                   ( pasting-vertical-coherence-square-maps g
+-- --                                     ( map-section hA (pr1 sF))
+-- --                                     ( map-section hC (pr1 sK))
+-- --                                     g' hA hC g
+-- --                                     ( G)
+-- --                                     ( back-right))
+-- --                                   ( pasting-vertical-coherence-square-maps h
+-- --                                     ( map-section hB (pr1 (pr2 sF)))
+-- --                                     ( map-section hD (pr1 (pr2 sK)))
+-- --                                     h' hB hD h
+-- --                                     ( H)
+-- --                                     ( front-left))
+-- --                                   ( pasting-vertical-coherence-square-maps k
+-- --                                     ( map-section hC (pr1 sK))
+-- --                                     ( map-section hD (pr1 (pr2 sK)))
+-- --                                     k' hC hD k
+-- --                                     ( pr1 (pr2 (pr2 sK)))
+-- --                                     ( front-right))
+-- --                                   ( pasting-vertical-coherence-cube-maps f g h k
+-- --                                     f' g' h' k' f g h k
+-- --                                     hA hB hC hD
+-- --                                     ( map-section hA (pr1 sF))
+-- --                                     ( map-section hB (pr1 (pr2 sF)))
+-- --                                     ( map-section hC (pr1 sK))
+-- --                                     ( map-section hD (pr1 (pr2 sK)))
+-- --                                     ( top)
+-- --                                     back-left back-right front-left front-right bottom
+-- --                                     ( bottom)
+-- --                                     ( pr1 (pr2 (pr2 sF)))
+-- --                                     ( G)
+-- --                                     ( H)
+-- --                                     ( pr1 (pr2 (pr2 sK)))
+-- --                                     ( α)
+-- --                                     ( β))
+-- --                                   id id id id
+-- --                                   refl-htpy refl-htpy refl-htpy refl-htpy
+-- --                                   ( id-cube f g h k bottom)
+-- --                                   ( is-section-map-section hA (pr1 sF))
+-- --                                   ( is-section-map-section hB (pr1 (pr2 sF)))
+-- --                                   ( is-section-map-section hC (pr1 sK))
+-- --                                   ( is-section-map-section hD (pr1 (pr2 sK)))
+-- --                                   ( pr2 (pr2 (pr2 sF)))
+-- --                                   ( sG)
+-- --                                   ( sH)
+-- --                                   ( pr2 (pr2 (pr2 sK))))))))))
+
+-- -- module _
+-- --   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
+-- --   {P1 : UU l1} {P2 : UU l2} {P3 : UU l3} {P4 : UU l4}
+-- --   {Q1 : P1 → UU l5} {Q2 : P2 → UU l6} {Q3 : P3 → UU l7} {Q4 : P4 → UU l8}
+-- --   (g1 : P1 → P3) (f1 : P1 → P2) (f2 : P3 → P4) (g2 : P2 → P4)
+-- --   (g1' : (p : P1) → Q1 p → Q3 (g1 p))
+-- --   (f1' : (p : P1) → Q1 p → Q2 (f1 p))
+-- --   (f2' : (p : P3) → Q3 p → Q4 (f2 p))
+-- --   (g2' : (p : P2) → Q2 p → Q4 (g2 p))
+-- --   (bottom : g2 ∘ f1 ~ f2 ∘ g1)
+-- --   (top : square-over g1 f1 f2 g2 (g1' _) (f1' _) (f2' _) (g2' _) bottom)
+-- --   where
+
+-- --   tot-square-over :
+-- --     coherence-square-maps
+-- --       ( tot-map-over g1 g1')
+-- --       ( tot-map-over f1 f1')
+-- --       ( tot-map-over {B' = Q4} f2 f2')
+-- --       ( tot-map-over g2 g2')
+-- --   tot-square-over =
+-- --     coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})
+
+-- --   coh-tot-square-over :
+-- --     coherence-cube-maps f1 g1 g2 f2
+-- --       ( map-Σ Q2 f1 f1')
+-- --       ( map-Σ Q3 g1 g1')
+-- --       ( map-Σ Q4 g2 g2')
+-- --       ( map-Σ Q4 f2 f2')
+-- --       pr1 pr1 pr1 pr1
+-- --       ( tot-square-over)
+-- --       refl-htpy refl-htpy refl-htpy refl-htpy
+-- --       ( bottom)
+-- --   coh-tot-square-over (p , q) =
+-- --     ap-pr1-eq-pair-Σ (bottom p) (top q) ∙ inv right-unit
+
+-- --   module _
+-- --     (s1 : (p : P1) → Q1 p) (s2 : (p : P2) → Q2 p)
+-- --     (s3 : (p : P3) → Q3 p) (s4 : (p : P4) → Q4 p)
+-- --     (G1 : (p : P1) → g1' p (s1 p) ＝ s3 (g1 p))
+-- --     (F1 : (p : P1) → f1' p (s1 p) ＝ s2 (f1 p))
+-- --     (F2 : (p : P3) → f2' p (s3 p) ＝ s4 (f2 p))
+-- --     (G2 : (p : P2) → g2' p (s2 p) ＝ s4 (g2 p))
+-- --     where
+-- --     open import foundation.action-on-identifications-binary-functions
+
+-- --     lemma :
+-- --       pasting-vertical-coherence-square-maps g1
+-- --         ( map-section-family s1) (map-section-family s3)
+-- --         ( tot-map-over g1 g1') (tot-map-over f1 f1')
+-- --         ( tot-map-over {B' = Q4} f2 f2') (tot-map-over g2 g2')
+-- --         ( eq-pair-eq-fiber ∘ G1)
+-- --         ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p})) ~
+-- --       ( λ p → eq-pair-Σ (bottom p) (top (s1 p) ∙ ap (f2' (g1 p)) (G1 p)))
+-- --     lemma = λ p → ap
+-- --               ( eq-pair-Σ (bottom p) (top (s1 p)) ∙_)
+-- --               ( [i] p) ∙
+-- --               ( inv (concat-vertical-eq-pair (bottom p) (top (s1 p)) (ap (f2' (g1 p)) (G1 p))))
+-- --         where
+-- --         [i] =
+-- --           λ (p : P1) →
+-- --           inv (ap-comp (map-Σ Q4 f2 f2') (pair (g1 p)) (G1 p)) ∙
+-- --           ap-comp (pair (f2 (g1 p))) (f2' (g1 p)) (G1 p)
+
+-- --     section-cube-over-sect-square-over :
+-- --       section-square-over g1 f1 f2 g2
+-- --         ( g1' _) (f1' _) (f2' _) (g2' _)
+-- --         s1 s2 s3 s4
+-- --         G1 F1 F2 G2
+-- --         bottom top →
+-- --       section-displayed-cube-over f1 g1 g2 f2
+-- --         ( tot-map-over f1 f1')
+-- --         ( tot-map-over g1 g1')
+-- --         ( tot-map-over g2 g2')
+-- --         ( tot-map-over f2 f2')
+-- --         pr1 pr1 pr1 pr1
+-- --         ( coherence-square-maps-Σ Q4 g1' f1' f2' g2' (λ p → top {p}))
+-- --         refl-htpy refl-htpy refl-htpy refl-htpy
+-- --         ( bottom)
+-- --         ( coh-tot-square-over)
+-- --     pr1 (section-cube-over-sect-square-over α) =
+-- --       ( section-dependent-function s1) ,
+-- --       ( section-dependent-function s2) ,
+-- --       ( eq-pair-eq-fiber ∘ F1) ,
+-- --       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F1 p))
+-- --     pr1 (pr2 (section-cube-over-sect-square-over α)) =
+-- --       ( section-dependent-function s3) ,
+-- --       ( section-dependent-function s4) ,
+-- --       ( eq-pair-eq-fiber ∘ F2) ,
+-- --       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (F2 p))
+-- --     pr2 (pr2 (section-cube-over-sect-square-over α)) =
+-- --       ( eq-pair-eq-fiber ∘ G1) ,
+-- --       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G1 p)) ,
+-- --       ( eq-pair-eq-fiber ∘ G2) ,
+-- --       ( λ p → right-unit ∙ ap-pr1-eq-pair-Σ refl (G2 p)) ,
+-- --       ( λ p →
+-- --         ap-binary
+-- --           ( _∙_)
+-- --           ( pasting-horizontal-comp f1' g2' s1 s2 s4 F1 G2 p)
+-- --           ( ap-map-section-family-lemma s4 (bottom p)) ∙
+-- --         {!!} ∙
+-- --         ap (eq-pair-Σ (bottom p)) (inv (α p) ∙ assoc (top (s1 p)) (ap (f2' (g1 p)) (G1 p)) (F2 (g1 p))) ∙
+-- --         concat-vertical-eq-pair
+-- --           ( bottom p)
+-- --           ( top (s1 p))
+-- --           ( ap (f2' (g1 p)) (G1 p) ∙ F2 (g1 p)) ∙
+-- --         ap-binary
+-- --           ( _∙_)
+-- --           ( refl {x = eq-pair-Σ (bottom p) (top (s1 p))})
+-- --           ( inv (pasting-horizontal-comp g1' f2' s1 s3 s4 G1 F2 p))) ,
+-- --       {!!}
+-- -- ```
diff --git a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
index 9e95f96ff4..80ac2fa11e 100644
--- a/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
+++ b/src/synthetic-homotopy-theory/zigzag-construction-identity-type-pushouts.lagda.md
@@ -1,7 +1,7 @@
 # The zigzag construction of identity types of pushouts
 
 ```agda
-{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
+{-# OPTIONS --lossy-unification #-}
 
 module synthetic-homotopy-theory.zigzag-construction-identity-type-pushouts where
 ```
@@ -342,232 +342,307 @@ module _
           ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit n p) →
         right-family-descent-data-pushout R
           ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))
-      Ψ s n p =
-        ( tr
-          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-          ( CB s n p)) ∘
-        ( map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p))
-
-      Φ :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
-        right-family-descent-data-pushout R
-          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
-        right-family-descent-data-pushout R
-          ( right-map-span-diagram 𝒮 s ,
-            concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-      Φ s n p =
-        ( tr
-          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-          ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))) ∘
-        ( tr
-          ( λ p →
-            right-family-descent-data-pushout R
-              ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-          ( glue-pushout _ _ (s , refl , p))) ∘
-        ( tr
-          ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
-          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
-
-      Φ' :
-        (s : spanning-type-span-diagram 𝒮) →
-        (n : ℕ) →
-        (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
-        right-family-descent-data-pushout R
-          ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
-        left-family-descent-data-pushout R
-          ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-      Φ' s n p =
-        ( inv-map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))) ∘
-        ( Φ s n p)
-
-    coh-dep-cocone-a :
-      (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
-      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-      coherence-square-maps
-        ( ( tr
-            ( λ p →
-              left-family-descent-data-pushout R
-                ( left-map-span-diagram 𝒮 s ,
-                  map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-            ( glue-pushout _ _ (s , refl , p))) ∘
-          ( tr
+      Ψ s =
+        map-over-diagram-equiv-over-colimit
+          ( up-standard-sequential-colimit)
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit _))
+          ( hom-diagram-zigzag-sequential-diagram
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+          ( ev-pair
+            ( left-family-descent-data-pushout R)
+            ( left-map-span-diagram 𝒮 s))
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( ev-pair
+            ( equiv-family-descent-data-pushout R)
+            ( s))
+        -- ( tr
+        --   ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+        --   ( CB s n p)) ∘
+        -- ( map-family-descent-data-pushout R
+        --   ( s , map-cocone-standard-sequential-colimit n p))
+
+      opaque
+        -- The definitions currently matter for α and β
+        -- Φ :
+        --   (s : spanning-type-span-diagram 𝒮) →
+        --   (n : ℕ) →
+        --   (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+        --   right-family-descent-data-pushout R
+        --     ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
+        --   right-family-descent-data-pushout R
+        --     ( right-map-span-diagram 𝒮 s ,
+        --       concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
+        -- Φ s n p =
+        --   ( tr
+        --     ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+        --     ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))) ∘
+        --   ( tr
+        --     ( λ p →
+        --       right-family-descent-data-pushout R
+        --         ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+        --     ( glue-pushout _ _ (s , refl , p))) ∘
+        --   ( tr
+        --     ( ev-pair (right-family-descent-data-pushout R) (right-map-span-diagram 𝒮 s))
+        --     ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
+
+        Φ' :
+          (s : spanning-type-span-diagram 𝒮) →
+          (n : ℕ) →
+          (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+          right-family-descent-data-pushout R
+            ( right-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) p) →
+          left-family-descent-data-pushout R
+            ( left-map-span-diagram 𝒮 s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+        Φ' s =
+          inv-map-over-diagram-equiv-zigzag
+            ( up-standard-sequential-colimit)
+            ( shift-once-cocone-sequential-diagram
+              ( cocone-standard-sequential-colimit _))
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
             ( ev-pair
               ( left-family-descent-data-pushout R)
               ( left-map-span-diagram 𝒮 s))
-            ( coherence-cocone-standard-sequential-colimit n p)))
-        ( map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p))
-        ( map-family-descent-data-pushout R
-          ( s ,
-            map-cocone-standard-sequential-colimit (succ-ℕ n)
-              ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
-        ( ( tr
             ( ev-pair
               ( right-family-descent-data-pushout R)
               ( right-map-span-diagram 𝒮 s))
-            ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
-          ( tr
-            ( λ p →
-              right-family-descent-data-pushout R
-                ( right-map-span-diagram 𝒮 s ,
-                  map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-            ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
-          ( tr
+            ( ev-pair
+              ( equiv-family-descent-data-pushout R)
+              ( s))
+
+    -- coh-dep-cocone-a :
+    --   (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+    --   (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+    --   coherence-square-maps
+    --     ( ( tr
+    --         ( λ p →
+    --           left-family-descent-data-pushout R
+    --             ( left-map-span-diagram 𝒮 s ,
+    --               map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+    --         ( glue-pushout _ _ (s , refl , p))) ∘
+    --       ( tr
+    --         ( ev-pair
+    --           ( left-family-descent-data-pushout R)
+    --           ( left-map-span-diagram 𝒮 s))
+    --         ( coherence-cocone-standard-sequential-colimit n p)))
+    --     ( map-family-descent-data-pushout R
+    --       ( s , map-cocone-standard-sequential-colimit n p))
+    --     ( map-family-descent-data-pushout R
+    --       ( s ,
+    --         map-cocone-standard-sequential-colimit (succ-ℕ n)
+    --           ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ( concat-s 𝒮 a₀ s n p))))
+    --     ( ( tr
+    --         ( ev-pair
+    --           ( right-family-descent-data-pushout R)
+    --           ( right-map-span-diagram 𝒮 s))
+    --         ( inv (CB s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) (concat-s 𝒮 a₀ s n p))))) ∘
+    --       ( tr
+    --         ( λ p →
+    --           right-family-descent-data-pushout R
+    --             ( right-map-span-diagram 𝒮 s ,
+    --               map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+    --         ( glue-pushout _ _ (s , refl , concat-s 𝒮 a₀ s n p))) ∘
+    --       ( tr
+    --         ( ev-pair
+    --           ( right-family-descent-data-pushout R)
+    --           ( right-map-span-diagram 𝒮 s))
+    --         ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))) ∘
+    --       ( tr
+    --         ( ev-pair
+    --           ( right-family-descent-data-pushout R)
+    --           ( right-map-span-diagram 𝒮 s))
+    --         ( CB s n p)))
+    -- coh-dep-cocone-a s n p =
+    --   ( ( inv-htpy
+    --       ( ( tr-concat _ _) ∙h
+    --         ( ( tr _ _) ·l
+    --           ( ( tr-concat _ _) ∙h
+    --             ( horizontal-concat-htpy
+    --               ( λ _ → substitution-law-tr _ _ _)
+    --               ( tr-concat _ _)))))) ·r
+    --     ( map-family-descent-data-pushout R
+    --       ( s , map-cocone-standard-sequential-colimit n p))) ∙h
+    --   ( ( λ q →
+    --       ap
+    --         ( λ r →
+    --           tr
+    --             ( ev-pair
+    --                ( right-family-descent-data-pushout R)
+    --                ( right-map-span-diagram 𝒮 s))
+    --             ( r)
+    --             ( map-family-descent-data-pushout R
+    --               ( s , map-cocone-standard-sequential-colimit n p)
+    --               ( q)))
+    --         ( inv ([i] p))) ∙h
+    --     ( λ q →
+    --       substitution-law-tr
+    --         ( ev-pair
+    --           ( right-family-descent-data-pushout R)
+    --           ( right-map-span-diagram 𝒮 s))
+    --         ( concat-s-inf 𝒮 a₀ s)
+    --         ( coherence-cocone-standard-sequential-colimit n p ∙
+    --           ap
+    --             ( map-cocone-standard-sequential-colimit (succ-ℕ n))
+    --             ( glue-standard-pushout _ _))) ∙h
+    --     ( inv-htpy
+    --       ( preserves-tr
+    --         ( ev-pair
+    --           ( map-family-descent-data-pushout R)
+    --           ( s))
+    --         ( coherence-cocone-standard-sequential-colimit n p ∙
+    --           ap (map-cocone-standard-sequential-colimit (succ-ℕ n)) (glue-standard-pushout _ _))))) ∙h
+    --   ( ( map-family-descent-data-pushout R
+    --       ( s ,
+    --         map-cocone-standard-sequential-colimit
+    --           ( succ-ℕ n)
+    --           ( concat-inv-s 𝒮 a₀ s
+    --             ( succ-ℕ n)
+    --             ( concat-s 𝒮 a₀ s n p)))) ·l
+    --     ( ( tr-concat _ _) ∙h
+    --       ( λ q → substitution-law-tr _ _ _)))
+    --   where
+    --   [i] :
+    --     ( ( concat-s-inf 𝒮 a₀ s) ·l
+    --       ( ( coherence-cocone-standard-sequential-colimit n) ∙h
+    --         ( ( map-cocone-standard-sequential-colimit
+    --           { A =
+    --             left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+    --               ( left-map-span-diagram 𝒮 s)}
+    --           ( succ-ℕ n)) ·l
+    --         ( λ p → glue-pushout _ _ (s , refl , p))))) ~
+    --     ( ( CB s n) ∙h
+    --       ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
+    --           ( concat-s 𝒮 a₀ s n)) ∙h
+    --       ( ( map-cocone-standard-sequential-colimit
+    --           { A =
+    --             right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+    --               ( right-map-span-diagram 𝒮 s)}
+    --           ( succ-ℕ (succ-ℕ n))) ·l
+    --         ( λ p → glue-pushout _ _ ( s , refl , concat-s 𝒮 a₀ s n p))) ∙h
+    --       ( ( inv-htpy (CB s (succ-ℕ n))) ·r
+    --         ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
+    --   [i] =
+    --     ( distributive-left-whisker-comp-concat _ _ _) ∙h
+    --     ( right-transpose-htpy-concat _ _ _
+    --       ( ( left-whisker-concat-coherence-square-homotopies _ _ _ _ _
+    --           ( λ p →
+    --             inv
+    --               ( nat-coherence-square-maps _ _ _ _
+    --                 ( CB s (succ-ℕ n))
+    --                 ( glue-pushout _ _ (s , refl , p))))) ∙h
+    --         ( map-inv-equiv
+    --           ( equiv-right-transpose-htpy-concat _ _ _)
+    --           ( ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
+    --               ( up-standard-sequential-colimit)
+    --               ( shift-once-cocone-sequential-diagram
+    --                 ( cocone-standard-sequential-colimit
+    --                   ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+    --                     ( right-map-span-diagram 𝒮 s))))
+    --               ( hom-diagram-zigzag-sequential-diagram
+    --                 ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+    --               ( n)) ∙h
+    --             ( ap-concat-htpy
+    --               ( CB s n)
+    --               ( ( ap-concat-htpy _
+    --                   ( ( distributive-left-whisker-comp-concat
+    --                       ( map-cocone-standard-sequential-colimit
+    --                         { A =
+    --                           right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
+    --                             ( right-map-span-diagram 𝒮 s)}
+    --                         ( succ-ℕ (succ-ℕ n)))
+    --                       ( _)
+    --                       ( _)) ∙h
+    --                     ( ap-concat-htpy _
+    --                       ( ( left-whisker-comp² _
+    --                           ( left-whisker-inv-htpy _ _)) ∙h
+    --                         ( left-whisker-inv-htpy _ _))))) ∙h
+    --                 ( inv-htpy-assoc-htpy _ _ _))) ∙h
+    --             ( inv-htpy-assoc-htpy _ _ _))))) ∙h
+    --     ( ap-concat-htpy' _
+    --       ( inv-htpy-assoc-htpy _ _ _))
+
+        α :
+          (s : spanning-type-span-diagram 𝒮) →
+          (n : ℕ) →
+          (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
+          coherence-square-maps
+            ( Ψ s n p)
+            ( tr
+              ( ev-pair
+                ( left-family-descent-data-pushout R)
+                ( left-map-span-diagram 𝒮 s))
+              ( coherence-cocone-standard-sequential-colimit n p))
+            ( Φ' s n (concat-s 𝒮 a₀ s n p))
+            ( tr
+              ( λ p →
+                left-family-descent-data-pushout R
+                  ( left-map-span-diagram 𝒮 s ,
+                    map-cocone-standard-sequential-colimit (succ-ℕ n) p))
+              ( glue-pushout _ _ (s , refl , p)))
+        α s n p =
+          upper-triangle-over
+            ( up-standard-sequential-colimit)
+            ( shift-once-cocone-sequential-diagram
+              ( cocone-standard-sequential-colimit _))
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
+            ( ev-pair
+              ( left-family-descent-data-pushout R)
+              ( left-map-span-diagram 𝒮 s))
             ( ev-pair
               ( right-family-descent-data-pushout R)
               ( right-map-span-diagram 𝒮 s))
-            ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) (concat-s 𝒮 a₀ s n p))) ∘
-          ( tr
+            ( ev-pair
+              ( equiv-family-descent-data-pushout R)
+              ( s))
+            ( n)
+            { p}
+          -- map-eq-transpose-equiv
+          --   ( equiv-family-descent-data-pushout R
+          --     ( s ,
+          --       map-cocone-standard-sequential-colimit
+          --         ( succ-ℕ n)
+          --         ( concat-inv-s 𝒮 a₀ s
+          --           ( succ-ℕ n)
+          --           ( concat-s 𝒮 a₀ s n p))))
+          --   ( inv (coh-dep-cocone-a s n p q))
+
+        β :
+          (s : spanning-type-span-diagram 𝒮) →
+          (n : ℕ) →
+          (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
+          coherence-square-maps
+            ( Φ' s n p)
+            ( tr
+              ( ev-pair
+                ( right-family-descent-data-pushout R)
+                ( right-map-span-diagram 𝒮 s))
+              ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
+            ( Ψ s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
+            ( tr
+              ( λ p →
+                right-family-descent-data-pushout R
+                  ( right-map-span-diagram 𝒮 s ,
+                    map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
+              ( glue-pushout _ _ (s , refl , p)))
+        β s n p =
+          lower-triangle-over
+            ( up-standard-sequential-colimit)
+            ( shift-once-cocone-sequential-diagram
+              ( cocone-standard-sequential-colimit _))
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
+            ( ev-pair
+              ( left-family-descent-data-pushout R)
+              ( left-map-span-diagram 𝒮 s))
             ( ev-pair
               ( right-family-descent-data-pushout R)
               ( right-map-span-diagram 𝒮 s))
-            ( CB s n p)))
-    coh-dep-cocone-a s n p =
-      ( ( inv-htpy
-          ( ( tr-concat _ _) ∙h
-            ( ( tr _ _) ·l
-              ( ( tr-concat _ _) ∙h
-                ( horizontal-concat-htpy
-                  ( λ _ → substitution-law-tr _ _ _)
-                  ( tr-concat _ _)))))) ·r
-        ( map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p))) ∙h
-      ( nat-lemma
-          ( concat-s-inf 𝒮 a₀ s)
-          ( ev-pair (map-family-descent-data-pushout R) s)
-          ( [i] p)) ∙h
-      ( ( map-family-descent-data-pushout R
-          ( s ,
-            map-cocone-standard-sequential-colimit
-              ( succ-ℕ n)
-              ( concat-inv-s 𝒮 a₀ s
-                ( succ-ℕ n)
-                ( concat-s 𝒮 a₀ s n p)))) ·l
-        ( ( tr-concat _ _) ∙h
-          ( λ q → substitution-law-tr _ _ _)))
-      where
-      [i] :
-        ( ( concat-s-inf 𝒮 a₀ s) ·l
-          ( ( coherence-cocone-standard-sequential-colimit n) ∙h
-            ( ( map-cocone-standard-sequential-colimit
-              { A =
-                left-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                  ( left-map-span-diagram 𝒮 s)}
-              ( succ-ℕ n)) ·l
-            ( λ p → glue-pushout _ _ (s , refl , p))))) ~
-        ( ( CB s n) ∙h
-          ( ( coherence-cocone-standard-sequential-colimit (succ-ℕ n)) ·r
-              ( concat-s 𝒮 a₀ s n)) ∙h
-          ( ( map-cocone-standard-sequential-colimit
-              { A =
-                right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                  ( right-map-span-diagram 𝒮 s)}
-              ( succ-ℕ (succ-ℕ n))) ·l
-            ( λ p → glue-pushout _ _ ( s , refl , concat-s 𝒮 a₀ s n p))) ∙h
-          ( ( inv-htpy (CB s (succ-ℕ n))) ·r
-            ( concat-inv-s 𝒮 a₀ s (succ-ℕ n) ∘ concat-s 𝒮 a₀ s n)))
-      [i] =
-        ( distributive-left-whisker-comp-concat _ _ _) ∙h
-        ( right-transpose-htpy-concat _ _ _
-          ( ( left-whisker-concat-coherence-square-homotopies _ _ _ _ _
-              ( λ p →
-                inv
-                  ( nat-coherence-square-maps _ _ _ _
-                    ( CB s (succ-ℕ n))
-                    ( glue-pushout _ _ (s , refl , p))))) ∙h
-            ( map-inv-equiv
-              ( equiv-right-transpose-htpy-concat _ _ _)
-              ( ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
-                  ( up-standard-sequential-colimit)
-                  ( shift-once-cocone-sequential-diagram
-                    ( cocone-standard-sequential-colimit
-                      ( right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                        ( right-map-span-diagram 𝒮 s))))
-                  ( hom-diagram-zigzag-sequential-diagram
-                    ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-                  ( n)) ∙h
-                ( ap-concat-htpy
-                  ( CB s n)
-                  ( ( ap-concat-htpy _
-                      ( ( distributive-left-whisker-comp-concat
-                          ( map-cocone-standard-sequential-colimit
-                            { A =
-                              right-sequential-diagram-zigzag-id-pushout 𝒮 a₀
-                                ( right-map-span-diagram 𝒮 s)}
-                            ( succ-ℕ (succ-ℕ n)))
-                          ( _)
-                          ( _)) ∙h
-                        ( ap-concat-htpy _
-                          ( ( left-whisker-comp² _
-                              ( left-whisker-inv-htpy _ _)) ∙h
-                            ( left-whisker-inv-htpy _ _))))) ∙h
-                    ( inv-htpy-assoc-htpy _ _ _))) ∙h
-                ( inv-htpy-assoc-htpy _ _ _))))) ∙h
-        ( ap-concat-htpy' _
-          ( inv-htpy-assoc-htpy _ _ _))
-
-    α :
-      (s : spanning-type-span-diagram 𝒮) →
-      (n : ℕ) →
-      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-      coherence-square-maps
-        ( Ψ s n p)
-        ( tr
-          ( ev-pair
-            ( left-family-descent-data-pushout R)
-            ( left-map-span-diagram 𝒮 s))
-          ( coherence-cocone-standard-sequential-colimit n p))
-        ( Φ' s n (concat-s 𝒮 a₀ s n p))
-        ( tr
-          ( λ p →
-            left-family-descent-data-pushout R
-              ( left-map-span-diagram 𝒮 s ,
-                map-cocone-standard-sequential-colimit (succ-ℕ n) p))
-          ( glue-pushout _ _ (s , refl , p)))
-    α s n p q =
-      map-eq-transpose-equiv
-        ( equiv-family-descent-data-pushout R
-          ( s ,
-            map-cocone-standard-sequential-colimit
-              ( succ-ℕ n)
-              ( concat-inv-s 𝒮 a₀ s
-                ( succ-ℕ n)
-                ( concat-s 𝒮 a₀ s n p))))
-        ( inv (coh-dep-cocone-a s n p q))
-
-    β :
-      (s : spanning-type-span-diagram 𝒮) →
-      (n : ℕ) →
-      (p : Path-to-b 𝒮 a₀ (right-map-span-diagram 𝒮 s) (succ-ℕ n)) →
-      coherence-square-maps
-        ( Φ' s n p)
-        ( tr
-          ( ev-pair
-            ( right-family-descent-data-pushout R)
-            ( right-map-span-diagram 𝒮 s))
-          ( coherence-cocone-standard-sequential-colimit (succ-ℕ n) p))
-        ( Ψ s (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p))
-        ( tr
-          ( λ p →
-            right-family-descent-data-pushout R
-              ( right-map-span-diagram 𝒮 s ,
-                map-cocone-standard-sequential-colimit (succ-ℕ (succ-ℕ n)) p))
-          ( glue-pushout _ _ (s , refl , p)))
-    β s n p q =
-      inv
-        ( ( ap
-            ( tr _ _)
-            ( is-section-map-inv-equiv
-              ( equiv-family-descent-data-pushout R
-                ( s , map-cocone-standard-sequential-colimit (succ-ℕ n) (concat-inv-s 𝒮 a₀ s (succ-ℕ n) p)))
-              ( _)) ∙
-          ( is-section-map-inv-equiv
-            ( equiv-tr _ _)
-            ( _))))
+            ( ev-pair
+              ( equiv-family-descent-data-pushout R)
+              ( s))
+            ( n)
+            { p}
 
     -- Note for refactoring: after contracting away the last component and the
     -- vertical map, the definition of prism2 will fail to typecheck, since
@@ -747,85 +822,6 @@ module _
           ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) a)
           ( p))
 
-    ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
-    pr1 ind-singleton-zigzag-id-pushout' (a , p) =
-      dependent-cogap-standard-sequential-colimit
-        ( tA a , KA a)
-        ( p)
-    pr1 (pr2 ind-singleton-zigzag-id-pushout') (b , p) =
-      dependent-cogap-standard-sequential-colimit
-        ( tB b , KB b)
-        ( p)
-      where
-    pr2 (pr2 ind-singleton-zigzag-id-pushout') (s , p) =
-      dependent-cogap-standard-sequential-colimit
-        ( tS , KS)
-        ( p)
-      where
-      [i] :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        tr
-          ( ev-pair
-            ( right-family-descent-data-pushout R)
-            ( right-map-span-diagram 𝒮 s))
-          ( CB s n p)
-          ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit n p)
-            ( tA (left-map-span-diagram 𝒮 s) n p)) ＝
-        tB (right-map-span-diagram 𝒮 s) (succ-ℕ n) (concat-s 𝒮 a₀ s n p)
-      [i] zero-ℕ (map-raise refl) = inv (compute-inr-dependent-cogap _ _ _ _)
-      [i] (succ-ℕ n) p = inv (compute-inr-dependent-cogap _ _ _ _)
-      tS :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        map-family-descent-data-pushout R
-          ( s , map-cocone-standard-sequential-colimit n p)
-          ( pr1
-            ( ind-singleton-zigzag-id-pushout')
-            ( left-map-span-diagram 𝒮 s ,
-              map-cocone-standard-sequential-colimit n p)) ＝
-        pr1
-          ( pr2 ind-singleton-zigzag-id-pushout')
-          ( right-map-span-diagram 𝒮 s ,
-            concat-s-inf 𝒮 a₀ s (map-cocone-standard-sequential-colimit n p))
-      tS n p =
-        ( ap
-          ( map-family-descent-data-pushout R
-            ( s , map-cocone-standard-sequential-colimit n p))
-          ( compute-incl-dependent-cogap-standard-sequential-colimit _ n p)) ∙
-        ( map-equiv
-          ( inv-equiv-ap-emb
-            ( emb-equiv
-              ( equiv-tr
-                ( ev-pair
-                  ( right-family-descent-data-pushout R)
-                  ( right-map-span-diagram 𝒮 s))
-                ( CB s n p))))
-          ( [i] n p ∙
-            inv
-              ( ( apd
-                  ( dependent-cogap-standard-sequential-colimit (tB (right-map-span-diagram 𝒮 s) , _))
-                  ( CB s n p)) ∙
-                ( compute-incl-dependent-cogap-standard-sequential-colimit _ (succ-ℕ n) _))))
-      KS :
-        (n : ℕ) (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-        tr
-          ( λ p →
-            map-family-descent-data-pushout R
-              ( s , p)
-              ( pr1
-                ( ind-singleton-zigzag-id-pushout')
-                ( left-map-span-diagram 𝒮 s , p)) ＝
-            pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p))
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( tS n p) ＝
-        tS (succ-ℕ n) (inl-Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n p)
-      KS n p =
-        map-compute-dependent-identification-eq-value _ _
-          ( coherence-cocone-standard-sequential-colimit n p)
-          ( _)
-          ( _)
-          ( {!!})
-
     tS-in-diagram :
       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
       (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
@@ -907,14 +903,10 @@ module _
       bottom2 = glue-pushout _ _ _
       far :
         {p : PAn n} → g'n (sAn p) ＝ sAn (gn p)
-      far = far' n _
-        where
-        far' : (n : ℕ) (p : PAn n) → g'n (sAn p) ＝ sAn (gn p)
-        far' zero-ℕ (map-raise refl) = inv (compute-inl-dependent-cogap _ _ _ _)
-        far' (succ-ℕ n) p = inv (compute-inl-dependent-cogap _ _ _ _)
+      far = KA (left-map-span-diagram 𝒮 s) n _
       near :
         {p : PBn n} → h'n (sBn p) ＝ sBn (hn p)
-      near = inv (compute-inl-dependent-cogap _ _ _ _)
+      near = KB (right-map-span-diagram 𝒮 s) (succ-ℕ n) _
       mid :
         {p : PBn n} → m'n (sBn p) ＝ sAn (mn p)
       mid = mid' _ _
@@ -928,7 +920,7 @@ module _
       top1 = α s n _
       top2 :
         {p : PBn n} (q : QBn p) →
-        tr QBn bottom2 (h'n q) ＝ f'n (m'n q)
+        tr QBn bottom2 (h'n {n = n} q) ＝ f'n {n = succ-ℕ n} (m'n q)
       top2 = β s n _
       top :
         {p : PAn n} (q : QAn p) →
@@ -984,80 +976,96 @@ module _
       -- THE COMMENTED CODE WORKS, DON'T DELETE IT!
       -- It just takes too long to typecheck it in its current state
       prism1 : (n : ℕ) → PRISM1 n
-      prism1 = {!!}
-      -- prism1 zero-ℕ (map-raise refl) =
-      --   lem _ _ _ _ _
-      --     ( ( ap
-      --         ( _∙ (top1 0 (sAn _) ∙ ap m'n (left 0)))
-      --         ( ( inv (ap-inv (tr QAn (bottom1 0)) (far 0))) ∙
-      --           ( ap² (tr QAn (bottom1 0)) (inv-inv _)))) ∙
-      --       ( [i]) ∙
-      --       ( ap
-      --         ( apd sAn (bottom1 0) ∙_)
-      --         ( inv (inv-inv _))))
-      --   where
-      --     open import foundation.action-on-higher-identifications-functions
-      --     [i] =
-      --       inv
-      --         ( compute-glue-dependent-cogap _ _
-      --           ( pr1 (pr2 (stages-cocones' 0)) (left-map-span-diagram 𝒮 s))
-      --           ( s , refl , (map-raise refl)))
-      -- prism1 (succ-ℕ n) p =
-      --   lem _ _ _ _ _
-      --     ( ( ap
-      --         ( _∙ (top1 (succ-ℕ n) (sAn _) ∙ ap m'n (left (succ-ℕ n))))
-      --         ( ( inv (ap-inv (tr QAn (bottom1 (succ-ℕ n))) (far (succ-ℕ n)))) ∙
-      --           ( ap² (tr QAn (bottom1 (succ-ℕ n))) (inv-inv _)))) ∙
-      --       ( [i]) ∙
-      --       ( ap
-      --         ( apd sAn (bottom1 (succ-ℕ n)) ∙_)
-      --         ( inv (inv-inv _))))
-      --   where
-      --     open import foundation.action-on-higher-identifications-functions
-      --     [i] =
-      --       inv
-      --         ( compute-glue-dependent-cogap _ _
-      --           ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) (left-map-span-diagram 𝒮 s))
-      --           ( s , refl , p))
+      -- prism1 = {!!}
+      prism1 zero-ℕ (map-raise refl) =
+        lem _ _ _ _ _
+          ( ( ap
+              ( _∙ (top1 0 (sAn _) ∙ ap m'n (left 0)))
+              ( ( inv (ap-inv (tr QAn (bottom1 0)) (far 0))) ∙
+                ( ap² (tr QAn (bottom1 0)) (inv-inv _)))) ∙
+            -- ( [i]) ∙
+            ( inv
+              ( compute-glue-dependent-cogap _ _
+                ( pr1 (pr2 (stages-cocones' 0)) (left-map-span-diagram 𝒮 s))
+                ( s , refl , (map-raise refl)))) ∙
+            ( ap
+              ( apd sAn (bottom1 0) ∙_)
+              ( inv (inv-inv _))))
+        where
+          open import foundation.action-on-higher-identifications-functions
+      prism1 (succ-ℕ n) p =
+        lem _ _ _ _ _
+          ( ( ap
+              ( _∙ (top1 (succ-ℕ n) (sAn _) ∙ ap m'n (left (succ-ℕ n))))
+              ( ( inv (ap-inv (tr QAn (bottom1 (succ-ℕ n))) (far (succ-ℕ n)))) ∙
+                ( ap² (tr QAn (bottom1 (succ-ℕ n))) (inv-inv _)))) ∙
+            ( inv
+              ( compute-glue-dependent-cogap _ _
+                ( pr1 (pr2 (stages-cocones' (succ-ℕ n))) (left-map-span-diagram 𝒮 s))
+                ( s , refl , p))) ∙
+            -- ( [i]) ∙
+            ( ap
+              ( apd sAn (bottom1 (succ-ℕ n)) ∙_)
+              ( inv (inv-inv _))))
+        where
+          open import foundation.action-on-higher-identifications-functions
 
       prism2 : (n : ℕ) → PRISM2 n
-      prism2 = {!!}
-      -- prism2 0 p =
-      --   lem _ _ _ _ _
-      --     ( ( ap
-      --         ( _∙ (top2 0 (sBn p) ∙ ap f'n (mid 0)))
-      --         ( ( inv (ap-inv (tr QBn (bottom2 0)) (near 0))) ∙
-      --           ( ap² (tr (QBn {1}) (bottom2 0)) (inv-inv _)))) ∙
-      --       ( inv [ii]) ∙
-      --       ( ap
-      --         ( apd sBn (bottom2 0) ∙_)
-      --         ( inv (inv-inv _))))
-      --   where
-      --     open import foundation.action-on-higher-identifications-functions
-      --     [i] =
-      --       -- inv
-      --         ( compute-glue-dependent-cogap _ _
-      --           ( pr1 (stages-cocones' 1) (right-map-span-diagram 𝒮 s))
-      --           ( s , refl , p))
-      --     [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 0 (sBn p) ∙ ap f'n (inv q))) right-unit
-      -- prism2 (succ-ℕ n) p =
-      --   lem _ _ _ _ _
-      --     ( ( ap
-      --         ( _∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (mid (succ-ℕ n))))
-      --         ( ( inv (ap-inv (tr QBn (bottom2 (succ-ℕ n))) (near (succ-ℕ n)))) ∙
-      --           ( ap² (tr QBn (bottom2 (succ-ℕ n))) (inv-inv _)))) ∙
-      --       ( inv [ii]) ∙
-      --       ( ap
-      --         ( apd sBn (bottom2 (succ-ℕ n)) ∙_)
-      --         ( inv (inv-inv _))))
-      --   where
-      --     open import foundation.action-on-higher-identifications-functions
-      --     [i] =
-      --       -- inv
-      --         ( compute-glue-dependent-cogap _ _
-      --           ( pr1 (stages-cocones' (succ-ℕ (succ-ℕ n))) (right-map-span-diagram 𝒮 s))
-      --           ( s , refl , p))
-      --     [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (inv q))) right-unit
+      -- prism2 = {!!}
+      prism2 0 p =
+        lem _ _ _ _ _
+          ( ( ap
+              ( _∙ (top2 0 (sBn p) ∙ ap f'n (mid 0)))
+              ( ( inv (ap-inv (tr QBn (bottom2 0)) (near 0))) ∙
+                ( ap² (tr (QBn {1}) (bottom2 0)) (inv-inv _)))) ∙
+            -- ( inv [ii]) ∙
+            ( inv
+              ( ( compute-glue-dependent-cogap _ _
+                  ( pr1 (stages-cocones' 1) (right-map-span-diagram 𝒮 s))
+                  ( s , refl , p)) ∙
+                ( ap
+                  ( λ q →
+                    ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙
+                    (top2 0 (sBn p) ∙ ap f'n (inv q)))
+                  ( right-unit)))) ∙
+            ( ap
+              ( apd sBn (bottom2 0) ∙_)
+              ( inv (inv-inv _))))
+        where
+          open import foundation.action-on-higher-identifications-functions
+          -- [i] =
+          --   -- inv
+          --     ( compute-glue-dependent-cogap _ _
+          --       ( pr1 (stages-cocones' 1) (right-map-span-diagram 𝒮 s))
+          --       ( s , refl , p))
+          -- [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 0 (sBn p) ∙ ap f'n (inv q))) right-unit
+      prism2 (succ-ℕ n) p =
+        lem _ _ _ _ _
+          ( ( ap
+              ( _∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (mid (succ-ℕ n))))
+              ( ( inv (ap-inv (tr QBn (bottom2 (succ-ℕ n))) (near (succ-ℕ n)))) ∙
+                ( ap² (tr QBn (bottom2 (succ-ℕ n))) (inv-inv _)))) ∙
+            -- ( inv [ii]) ∙
+            ( inv
+              ( ( compute-glue-dependent-cogap _ _
+                  ( pr1 (stages-cocones' (succ-ℕ (succ-ℕ n))) (right-map-span-diagram 𝒮 s))
+                  ( s , refl , p)) ∙
+                ( ap
+                  ( λ q →
+                    ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙
+                    (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (inv q)))
+                  ( right-unit)))) ∙
+            ( ap
+              ( apd sBn (bottom2 (succ-ℕ n)) ∙_)
+              ( inv (inv-inv _))))
+        where
+          open import foundation.action-on-higher-identifications-functions
+          -- [i] =
+          --   -- inv
+          --     ( compute-glue-dependent-cogap _ _
+          --       ( pr1 (stages-cocones' (succ-ℕ (succ-ℕ n))) (right-map-span-diagram 𝒮 s))
+          --       ( s , refl , p))
+          -- [ii] = [i] ∙ ap (λ q → ap (tr QBn _) (compute-inl-dependent-cogap _ _ _ _) ∙ (top2 (succ-ℕ n) (sBn p) ∙ ap f'n (inv q))) right-unit
 
       cube : (n : ℕ) → CUBE n
       cube n =
@@ -1081,7 +1089,7 @@ module _
               ( λ p → bottom1 n {p})
               ( top1 n)
               sAn sAn _ _
-              (unget-section-triangle-over fn gn mn f'n g'n m'n sAn sBn sAn
+              ( unget-section-triangle-over fn gn mn f'n g'n m'n sAn sBn sAn
                 ( λ p → left n {p})
                 ( λ p → far n {p})
                 ( λ p → mid n {p})
@@ -1090,63 +1098,130 @@ module _
                 ( prism1 n))))
           ( prism2 n)
 
+
+    opaque
+      unfolding Φ' -- square-over-diagram-square-over-colimit γ
+
+      realign-top :
+        (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
+        (p : vertices.PAn s n) →
+        sides.top s n {p} ~
+        square-over-diagram-square-over-colimit
+          ( up-standard-sequential-colimit)
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit _))
+          ( hom-diagram-zigzag-sequential-diagram
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+          ( ev-pair
+            ( left-family-descent-data-pushout R)
+            ( left-map-span-diagram 𝒮 s))
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( ev-pair
+            ( equiv-family-descent-data-pushout R)
+            ( s))
+          ( n)
+          ( p)
+      realign-top s =
+        compute-square-over-zigzag-square-over-colimit
+          ( up-standard-sequential-colimit)
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit _))
+          ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s)
+          ( ev-pair
+            ( left-family-descent-data-pushout R)
+            ( left-map-span-diagram 𝒮 s))
+          ( ev-pair
+            ( right-family-descent-data-pushout R)
+            ( right-map-span-diagram 𝒮 s))
+          ( ev-pair
+            ( equiv-family-descent-data-pushout R)
+            ( s))
+
     KS-in-diagram :
       (s : spanning-type-span-diagram 𝒮) (n : ℕ) →
-      (p : Path-to-a 𝒮 a₀ (left-map-span-diagram 𝒮 s) n) →
-      sides.top s n (vertices.sAn s p) ∙
-       ap (vertices.f'n s) (sides.far s n)
-       ∙ sides.right s n
-       ＝
-       ap (tr (vertices.QBn s) (sides.bottom s n) ∘ vertices.h'n s)
-       (sides.left s n)
-       ∙ ap (tr (vertices.QBn s) (sides.bottom s n)) (sides.near s n)
-       ∙ apd (vertices.sBn s) (sides.bottom s n)
+      section-square-over
+        ( vertices.gn s)
+        ( vertices.fn s)
+        ( vertices.fn s)
+        ( vertices.hn s)
+        ( vertices.g'n s)
+        ( vertices.f'n s)
+        ( vertices.f'n s)
+        ( vertices.h'n s)
+        ( vertices.sAn s)
+        ( vertices.sBn s)
+        ( vertices.sAn s)
+        ( vertices.sBn s)
+        ( λ p → sides.far s n)
+        ( λ p → sides.left s n)
+        ( λ p → sides.right s n)
+        ( λ p → sides.near s n)
+        ( λ p → sides.bottom s n)
+        ( sides.top s n)
     KS-in-diagram = cube.cube
 
+    alt-section-RA :
+      (a : domain-span-diagram 𝒮)
+      (p : left-id-pushout 𝒮 a₀ a) →
+      left-family-descent-data-pushout R (a , p)
+    alt-section-RA a =
+      sect-family-sect-dd-sequential-colimit
+        ( up-standard-sequential-colimit)
+        ( _)
+        ( tA a , KA a)
+
+    alt-section-RB :
+      (b : codomain-span-diagram 𝒮)
+      (p : right-id-pushout 𝒮 a₀ b) →
+      right-family-descent-data-pushout R (b , p)
+    alt-section-RB b =
+      sect-family-sect-dd-sequential-colimit
+        ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
+        ( _)
+        ( tB b ∘ succ-ℕ , KB b ∘ succ-ℕ)
+
     alt-ind-coherence :
       (s : spanning-type-span-diagram 𝒮)
       (p : left-id-pushout 𝒮 a₀ (left-map-span-diagram 𝒮 s)) →
-      {!!}
-       -- (pr1 (pr2 (pr2 R) (s , p))
-       --  (sect-family-sect-dd-sequential-colimit
-       --   up-standard-sequential-colimit
-       --   (λ y → pr1 R (pr1 (pr2 (pr2 (pr2 𝒮))) s , y))
-       --   (tA (pr1 (pr2 (pr2 (pr2 𝒮))) s) , KA (pr1 (pr2 (pr2 (pr2 𝒮))) s))
-       --   p)) ＝
-       -- (sect-family-sect-dd-sequential-colimit
-       --  (up-shift-cocone-sequential-diagram 1
-       --   up-standard-sequential-colimit)
-       --  (λ y → pr1 (pr2 R) (pr2 (pr2 (pr2 (pr2 𝒮))) s , y))
-       --  (tB (pr2 (pr2 (pr2 (pr2 𝒮))) s) ∘ succ-ℕ ,
-       --   KB (pr2 (pr2 (pr2 (pr2 𝒮))) s) ∘ succ-ℕ)
-       --  (big-thm.f∞ up-standard-sequential-colimit
-       --   (up-shift-cocone-sequential-diagram 1
-       --    up-standard-sequential-colimit)
-       --   (hom-diagram-zigzag-sequential-diagram
-       --    (zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-       --   p))
-      -- map-family-descent-data-pushout R _ (pr1 ind-singleton-zigzag-id-pushout' (left-map-span-diagram 𝒮 s , p)) ＝
-      -- pr1 (pr2 ind-singleton-zigzag-id-pushout') (right-map-span-diagram 𝒮 s , concat-s-inf 𝒮 a₀ s p)
+      map-family-descent-data-pushout R
+        ( s , p)
+        ( alt-section-RA (left-map-span-diagram 𝒮 s) p) ＝
+      alt-section-RB
+        ( right-map-span-diagram 𝒮 s)
+        ( map-sequential-colimit-hom-sequential-diagram
+          ( up-standard-sequential-colimit)
+          ( shift-once-cocone-sequential-diagram
+            ( cocone-standard-sequential-colimit _))
+          ( hom-diagram-zigzag-sequential-diagram
+            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
+          ( p))
     alt-ind-coherence s p =
-      big-thm.thm
+      square-colimit-cube-diagram
         ( up-standard-sequential-colimit)
         ( up-shift-cocone-sequential-diagram 1 up-standard-sequential-colimit)
         ( hom-diagram-zigzag-sequential-diagram
-            ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
-        ( ev-pair
-          ( left-family-descent-data-pushout R)
-          ( left-map-span-diagram 𝒮 s))
-        ( ev-pair
-          ( right-family-descent-data-pushout R)
-          ( right-map-span-diagram 𝒮 s))
-        ( λ {p} → map-family-descent-data-pushout R (s , p))
+          ( zigzag-sequential-diagram-zigzag-id-pushout 𝒮 a₀ s))
         ( tA (left-map-span-diagram 𝒮 s) , KA (left-map-span-diagram 𝒮 s))
         ( tB (right-map-span-diagram 𝒮 s) ∘ succ-ℕ ,
           KB (right-map-span-diagram 𝒮 s) ∘ succ-ℕ)
+        ( λ p → equiv-family-descent-data-pushout R (s , p))
         ( tS-in-diagram s)
-        ( {!!})
+        ( λ n p →
+          ap
+            ( λ H → H ∙ ap (vertices.f'n s) (sides.far s n) ∙ sides.right s n)
+            ( inv (realign-top s n p (vertices.sAn s p))) ∙ KS-in-diagram s n p)
         ( p)
 
+    alt-ind-singleton-zigzag-id-pushout' : section-descent-data-pushout R
+    pr1 alt-ind-singleton-zigzag-id-pushout' =
+      ind-Σ alt-section-RA
+    pr1 (pr2 alt-ind-singleton-zigzag-id-pushout') =
+      ind-Σ alt-section-RB
+    pr2 (pr2 alt-ind-singleton-zigzag-id-pushout') =
+      ind-Σ alt-ind-coherence
+
   is-identity-system-zigzag-id-pushout :
     is-identity-system-descent-data-pushout
       ( descent-data-zigzag-id-pushout 𝒮 a₀)
@@ -1155,5 +1230,6 @@ module _
     is-identity-system-descent-data-pushout-ind-singleton up-c
       ( descent-data-zigzag-id-pushout 𝒮 a₀)
       ( refl-id-pushout 𝒮 a₀)
-      ( ind-singleton-zigzag-id-pushout')
+      -- ( ind-singleton-zigzag-id-pushout')
+      ( alt-ind-singleton-zigzag-id-pushout')
 ```

From bf811bfd6ed621045f9edd12d2dc098714a8c3f4 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Wed, 19 Mar 2025 19:25:15 +0100
Subject: [PATCH 28/33] Progress

---
 .../functoriality-stuff.lagda.md              | 278 +++++++++++++++---
 .../morphisms-sequential-diagrams.lagda.md    |   1 +
 2 files changed, 239 insertions(+), 40 deletions(-)

diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index 6164d0acb0..cae4c64a40 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -869,50 +869,95 @@ module _
 
 ```agda
 module _
-  {l1 l2 l3 l4 l5 l6 l7 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l7}
-  {P : A → UU l4} {P' : B → UU l5} {Q' : C → UU l6}
-  {h : A → B} (h' : (a : A) → P a → P' (h a))
-  {l : A → D} (j : D → C) (l' : (a : A) → P a → Q' (j (l a)))
-  (s : (a : A) → P' (h a) → Q' (j (l a)))
-  {k : D → B} (t : (a : A) → Q' (j (l a)) → P' (k (l a)))
-  (U : h ~ k ∘ l)
-  (H : (a : A) (p : P a) → l' a p ＝ s a (h' a p))
-  (K : (a : A) (p : P' (h a)) → t a (s a p) ＝ tr P' (U a) p)
+  {l1 l2 : Level}
+  {A : UU l1}
+  {P : A → UU l2}
   where
   open import foundation.dependent-identifications
 
-  compute-lemma :
-    (a : A) (p : P a) →
-    inv-dependent-identification P' (U a)
-      ( inv
-        ( ap (t a) (H a p) ∙
-          K a (h' a p))) ＝
-    ap
-      ( tr P' (inv (U a)) ∘ t a)
-      ( H a p) ∙
-    inv-dependent-identification P' (U a)
-      ( inv (K a (h' a p)))
-  compute-lemma a p =
-    compute-inv-dependent-identification (U a) _ ∙
+  compute-lemma'' :
+    {x y : A} (p : x ＝ y) →
+    {x' : P x} {y' z' : P y}
+    (K : dependent-identification P p x' y')
+    (H : y' ＝ z') →
+    inv-dependent-identification P p (K ∙ H) ＝
     ap
-      ( map-eq-transpose-equiv-inv' (equiv-tr P' (U a)))
-      ( inv-inv _) ∙
+      ( tr P (inv p))
+      ( inv H) ∙
+    inv-dependent-identification P p K
+  compute-lemma'' refl K refl = ap inv right-unit
+
+module _
+  {l1 l2 l5 l6 : Level}
+  {A : UU l1} {B : UU l2}
+  {P : A → UU l5} {Q : UU l6} -- {Q : B → UU l6}
+  where
+  open import foundation.dependent-identifications
+
+  compute-lemma :
+    {x y : A} (p : x ＝ y) →
+    {u v : Q} (H : u ＝ v) →
+    (f : Q → P y)
+    {x' : P x} (K : dependent-identification P p x' (f u)) →
+    inv-dependent-identification P p (K ∙ ap f H) ＝
     ap
-      ( _∙ is-retraction-map-inv-equiv (equiv-tr P' (U a)) _)
-      ( ap-concat (tr P' (inv (U a))) _ _) ∙
-    assoc _ _ _ ∙
+      ( tr P (inv p) ∘ f)
+      ( inv H) ∙
+    inv-dependent-identification P p K
+  compute-lemma p H f K =
+    compute-lemma'' p K (ap f H) ∙
     ap
-      (_∙ map-eq-transpose-equiv-inv' (equiv-tr P' (U a)) (K a (h' a p)))
-      ( inv (ap-comp (tr P' (inv (U a))) (t a) (H a p))) ∙
+      ( _∙ inv-dependent-identification P p K)
+      ( ap
+          ( ap (tr P (inv p)))
+          ( inv (ap-inv f H)) ∙
+        inv (ap-comp (tr P (inv p)) f (inv H)))
+
+  compute-lemma' :
+    {x y : A} (p : x ＝ y) →
+    {u v : Q} (H : u ＝ v) →
+    (f : Q → P y) →
+    {x' : P x} (K : f v ＝ tr P p x') →
+    inv-dependent-identification P p (inv (ap f H ∙ K)) ＝
     ap
-      ( ap (tr P' (inv (U a)) ∘ t a) (H a p) ∙_)
-      ( inv
-        ( compute-inv-dependent-identification (U a) _ ∙
-          ap (map-eq-transpose-equiv-inv' (equiv-tr P' (U a))) (inv-inv _)))
+      ( tr P (inv p) ∘ f)
+      ( H) ∙
+    inv-dependent-identification P p (inv K)
+  compute-lemma' refl refl f K = refl
+    -- ap
+    --   ( inv-dependent-identification P p)
+    --   ( distributive-inv-concat (ap f H) K ∙ ap (inv K ∙_) (inv (ap-inv f H))) ∙
+    -- compute-lemma p (inv H) f (inv K) ∙
+    -- ap
+    --   ( λ r → ap (tr P (inv p) ∘ f) r ∙ inv-dependent-identification P p (inv K))
+    --   ( inv-inv H)
 ```
 
 ```agda
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {A : UU l1} {B : A → UU l2}
+  {X : UU l3} {Y : X → UU l4}
+  where
+
+  compute-left-whisker-transpose :
+    {s : A → X} (s' : {a : A} → B a → Y (s a))
+    {x y : A} (p : y ＝ x)
+    {x' : B x} {y' : B y} (p' : x' ＝ tr B p y') →
+    left-whisk-dependent-identification {B' = Y} s' (inv p)
+      ( map-eq-transpose-equiv-inv' (equiv-tr B p) p') ＝
+    ap
+      ( λ r → tr Y r (s' x'))
+      ( ap-inv s p) ∙
+    inv
+      ( map-eq-transpose-equiv
+        ( equiv-tr Y (ap s p))
+        ( left-whisk-dependent-identification {B' = Y} s' p
+          ( inv p')))
+  compute-left-whisker-transpose s' refl refl =
+    inv (ap inv (compute-refl-eq-transpose-equiv id-equiv))
+
 open import synthetic-homotopy-theory.zigzags-sequential-diagrams
 module _
   {l1 l2 l3 l4 l5 : Level}
@@ -972,8 +1017,53 @@ module _
       tr
         ( family-descent-data-sequential-colimit P' (succ-ℕ n))
         ( upper-triangle-zigzag-sequential-diagram z n a)
-    inv-upper-triangle-over' n a =
-      {!!}
+    inv-upper-triangle-over' n a p =
+      inv
+        ( ( preserves-tr
+            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
+            ( upper-triangle-zigzag-sequential-diagram z n a)
+            ( p)) ∙
+        ( inv
+          ( substitution-law-tr
+            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+            ( map-zigzag-sequential-diagram z (succ-ℕ n))
+            ( upper-triangle-zigzag-sequential-diagram z n a))) ∙
+        ( ap
+          ( λ r →
+            tr
+              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+              ( r)
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
+                ( map-sequential-diagram A n a)
+                ( p)))
+          ( inv
+            ( ap
+              ( _∙ lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+              ( distributive-inv-concat
+                ( lower-triangle-zigzag-sequential-diagram z n
+                  ( map-zigzag-sequential-diagram z n a))
+                ( ap
+                  ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                  ( inv (upper-triangle-zigzag-sequential-diagram z n a)))) ∙
+            assoc _ _ _ ∙
+            ap
+              ( inv (ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a))) ∙_)
+              ( left-inv (lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))) ∙
+            right-unit ∙
+            ap inv (ap-inv _ _) ∙
+            inv-inv _))) ∙
+        ( tr-concat
+          ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
+          ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+          ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) p)))
+      -- inv
+      --   ( tr-concat
+      --     ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
+      --     ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+      --     ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) p)) ∙
+      -- {!preserves-tr
+      --   ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
+      --   ( )!}
 
   opaque
     upper-triangle-over' :
@@ -1008,8 +1098,7 @@ module _
       ( inv-map-over-diagram-equiv-zigzag n (map-zigzag-sequential-diagram z n a))
   inv-upper-triangle-over n a p =
     ap
-      ( map-inv-fam-equiv e _ ∘
-        tr Q (inv (C (succ-ℕ n) _)) ∘
+      ( inv-map-over-diagram-equiv-zigzag' (succ-ℕ n) _ ∘
         tr
           ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
           ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)))
@@ -1077,6 +1166,65 @@ module _
          ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
          ( lower-triangle-zigzag-sequential-diagram z n b)
          ( map-family-descent-data-sequential-colimit Q' n b q))
+
+  trivial-pasting :
+    (n : ℕ) →
+    htpy-over
+      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+      ( naturality-map-hom-diagram-zigzag-sequential-diagram z n)
+      ( tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n _)) ∘
+        map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+      ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+  trivial-pasting n =
+    concat-htpy-over
+      ( lower-triangle-zigzag-sequential-diagram z n ·r
+        ( map-zigzag-sequential-diagram z n))
+      ( ( map-zigzag-sequential-diagram z (succ-ℕ n)) ·l
+        ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n)))
+      ( λ p →
+        lower-triangle-over' (succ-ℕ n) _
+          ( tr
+            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+            ( lower-triangle-zigzag-sequential-diagram z n _)
+            ( tr
+              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+              ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n _))
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
+                ( map-sequential-diagram A n _)
+                ( p)))))
+      ( left-whisk-htpy-over
+        ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
+        ( λ p →
+          map-eq-transpose-equiv-inv'
+            ( equiv-tr
+              ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+              ( upper-triangle-zigzag-sequential-diagram z n _))
+            ( upper-triangle-over' n _ p))
+        ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _))
+
+  abstract
+    open import foundation.dependent-identifications
+    is-trivial-trivial-pasting :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      trivial-pasting n {a} ~
+      is-section-map-inv-equiv
+        ( equiv-tr
+          ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+          ( naturality-map-hom-diagram-zigzag-sequential-diagram z n a)) ·r
+        map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a)
+    is-trivial-trivial-pasting n a p =
+      ap
+        ( λ K' →
+          concat-dependent-identification _ _ _
+          ( lower-triangle-over' (succ-ℕ n) _ _)
+          ( K'))
+        ( compute-left-whisker-transpose
+          ( λ {a} → map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) a)
+          ( upper-triangle-zigzag-sequential-diagram z n a)
+          ( upper-triangle-over' n a p)) ∙
+      {!!}
 ```
 
 ```agda
@@ -1138,7 +1286,7 @@ module _
 
   opaque
     -- TODO: Maybe this goes through for general equivalences immediately?
-    -- I haven't tried
+    -- I haven't tried yet
     compute-square-over-zigzag-square-over-colimit-id :
       (n : ℕ) (a : family-sequential-diagram A n) →
       pasting-triangles-over
@@ -1326,7 +1474,57 @@ module _
       assoc _ _ _ ∙
       ap
         ( square-over-diagram-square-over-colimit up-c c' f P Q id-fam-equiv n a p ∙_)
-        ( {!!}) ∙
+        ( ap
+          ( inv
+            ( is-section-map-inv-equiv
+              ( equiv-tr
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                ( naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n)
+                ( map-sequential-diagram A n a)
+                ( map-family-descent-data-sequential-colimit P' n a p))) ∙_)
+          ( assoc _ _ _ ∙
+            inv
+              ( compute-concat-dependent-identification
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+                ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
+                ( lower-triangle-over' up-c c' z P Q id-fam-equiv (succ-ℕ n)
+                  ( inv-map-zigzag-sequential-diagram z n
+                    ( map-zigzag-sequential-diagram z n a))
+                  ( tr
+                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                    ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+                    ( tr
+                      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                      ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
+                      ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n)
+                        ( map-sequential-diagram A n a)
+                        ( map-family-descent-data-sequential-colimit P' n a p)))))
+                ( _)) ∙
+              ap
+                ( concat-dependent-identification
+                  ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                  ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+                  ( ap
+                    ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                    ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
+                  ( lower-triangle-over' up-c c' z P Q id-fam-equiv (succ-ℕ n)
+                    ( inv-map-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
+                    ( _)))
+                ( inv
+                  ( compute-left-whisk-dependent-identification
+                    ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) _)
+                    ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+                    ( map-eq-transpose-equiv-inv'
+                      ( equiv-tr
+                        ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                        ( upper-triangle-zigzag-sequential-diagram z n a))
+                      ( upper-triangle-over' up-c c' z P Q id-fam-equiv n a
+                        ( map-family-descent-data-sequential-colimit P' n _ p))))) ∙
+              is-trivial-trivial-pasting up-c c' z P Q id-fam-equiv n a
+                ( map-family-descent-data-sequential-colimit P' n _ p)) ∙
+          ( left-inv _)) ∙
       right-unit
 ```
 
diff --git a/src/synthetic-homotopy-theory/morphisms-sequential-diagrams.lagda.md b/src/synthetic-homotopy-theory/morphisms-sequential-diagrams.lagda.md
index 94686c5aed..d4a6a5751d 100644
--- a/src/synthetic-homotopy-theory/morphisms-sequential-diagrams.lagda.md
+++ b/src/synthetic-homotopy-theory/morphisms-sequential-diagrams.lagda.md
@@ -24,6 +24,7 @@ open import foundation.structure-identity-principle
 open import foundation.torsorial-type-families
 open import foundation.universe-levels
 open import foundation.whiskering-homotopies-composition
+open import foundation.whiskering-homotopies-concatenation
 
 open import synthetic-homotopy-theory.dependent-sequential-diagrams
 open import synthetic-homotopy-theory.sequential-diagrams

From 2a6219c6e9e8a2f64bcec9a5694f3862d4c0df68 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Thu, 20 Mar 2025 10:57:33 +0100
Subject: [PATCH 29/33] Forgot I file

---
 .../fiberwise-equivalence-induction.lagda.md  | 119 ++++++++++++++++++
 1 file changed, 119 insertions(+)
 create mode 100644 src/foundation/fiberwise-equivalence-induction.lagda.md

diff --git a/src/foundation/fiberwise-equivalence-induction.lagda.md b/src/foundation/fiberwise-equivalence-induction.lagda.md
new file mode 100644
index 0000000000..51cc0a5577
--- /dev/null
+++ b/src/foundation/fiberwise-equivalence-induction.lagda.md
@@ -0,0 +1,119 @@
+# Fiberwise equivalence induction
+
+```agda
+module foundation.fiberwise-equivalence-induction where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import foundation.dependent-pair-types
+open import foundation.equivalences
+open import foundation.families-of-equivalences
+open import foundation.identity-systems
+open import foundation.identity-types
+-- open import foundation.subuniverses
+-- open import foundation.univalence
+-- open import foundation.universal-property-identity-systems
+open import foundation.universe-levels
+
+-- open import foundation-core.commuting-triangles-of-maps
+-- open import foundation-core.contractible-maps
+-- open import foundation-core.function-types
+-- open import foundation-core.postcomposition-functions
+-- open import foundation-core.sections
+-- open import foundation-core.torsorial-type-families
+```
+
+</details>
+
+## Idea
+
+## Definitions
+
+### Evaluation at the family of identity equivalences
+
+```agda
+module _
+  {l1 l2 l3 : Level} {A : UU l1} {P : A → UU l2}
+  (R : (Q : A → UU l2) → fam-equiv P Q → UU l3)
+  where
+
+  ev-id-fam-equiv :
+    ((Q : A → UU l2) → (e : fam-equiv P Q) → R Q e) →
+    R P id-fam-equiv
+  ev-id-fam-equiv r = r P id-fam-equiv
+```
+
+### The induction principle of families of equivalences
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} (P : A → UU l2)
+  where
+
+  induction-principle-fam-equiv : UUω
+  induction-principle-fam-equiv =
+    is-identity-system (λ (Q : A → UU l2) → fam-equiv P Q) P id-fam-equiv
+
+  induction-principle-fam-equiv' : UUω
+  induction-principle-fam-equiv' =
+    is-identity-system (λ (Q : A → UU l2) → fam-equiv Q P) P id-fam-equiv
+```
+
+## Theorems
+
+### Induction on families of equivalences
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {P : A → UU l2}
+  where
+
+  abstract
+    is-identity-system-fam-equiv : induction-principle-fam-equiv P
+    is-identity-system-fam-equiv =
+      is-identity-system-is-torsorial P
+        ( id-fam-equiv)
+        ( is-torsorial-fam-equiv)
+
+    is-identity-system-fam-equiv' : induction-principle-fam-equiv' P
+    is-identity-system-fam-equiv' =
+      is-identity-system-is-torsorial P
+        ( id-fam-equiv)
+        ( is-torsorial-fam-equiv')
+
+module _
+  {l1 l2 l3 : Level} {A : UU l1} {P : A → UU l2}
+  (R : (Q : A → UU l2) → fam-equiv P Q → UU l3)
+  (r : R P id-fam-equiv)
+  where
+
+  abstract
+    ind-fam-equiv :
+      {Q : A → UU l2} (e : fam-equiv P Q) → R Q e
+    ind-fam-equiv {Q = Q} e =
+      pr1 (is-identity-system-fam-equiv R) r Q e
+
+    compute-ind-fam-equiv :
+      ind-fam-equiv id-fam-equiv ＝ r
+    compute-ind-fam-equiv =
+      pr2 (is-identity-system-fam-equiv R) r
+
+module _
+  {l1 l2 l3 : Level} {A : UU l1} {P : A → UU l2}
+  (R : (Q : A → UU l2) → fam-equiv Q P → UU l3)
+  (r : R P id-fam-equiv)
+  where
+
+  abstract
+    ind-fam-equiv' :
+      {Q : A → UU l2} (e : fam-equiv Q P) → R Q e
+    ind-fam-equiv' {Q = Q} e =
+      pr1 (is-identity-system-fam-equiv' R) r Q e
+
+    compute-ind-fam-equiv' :
+      ind-fam-equiv' id-fam-equiv ＝ r
+    compute-ind-fam-equiv' =
+      pr2 (is-identity-system-fam-equiv' R) r
+```

From 02a9023fce2870188b9758f771c96db29b817a7e Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Sat, 22 Mar 2025 21:29:35 +0100
Subject: [PATCH 30/33] Look mom, no holes!

---
 .../functoriality-stuff.lagda.md              | 765 +++++++++++++++---
 1 file changed, 665 insertions(+), 100 deletions(-)

diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index cae4c64a40..362cc80091 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -1,7 +1,7 @@
 # Functoriality stuff
 
 ```agda
-{-# OPTIONS --lossy-unification --allow-unsolved-metas #-}
+{-# OPTIONS --lossy-unification #-}
 
 module synthetic-homotopy-theory.functoriality-stuff where
 ```
@@ -867,6 +867,228 @@ module _
   compute-eq-transpose-equiv-inv-concat' refl q = refl
 ```
 
+```agda
+module _
+  {l1 l2 l3 l4 : Level} {A : UU l1} {B : A → UU l2} {X : UU l3} {Y : X → UU l4}
+  where
+  open import foundation.dependent-identifications
+
+  compute-left-whisk-dependent-identification-concat :
+    {s : X → A} (s' : (x : X) → Y x → B (s x)) →
+    {x y : X} (p : x ＝ y) →
+    {x' : Y x} {y' z' : Y y} (p' : dependent-identification Y p x' y') →
+    (q : y' ＝ z') →
+    left-whisk-dependent-identification {B' = B} (s' _) p (p' ∙ q) ＝
+    left-whisk-dependent-identification (s' _) p p' ∙ ap (s' y) q
+  compute-left-whisk-dependent-identification-concat s' refl p' q =
+    ap-concat (s' _) p' q
+
+  compute-left-whisk-dependent-identification-concat' :
+    {s : X → A} (s' : (x : X) → Y x → B (s x)) →
+    {x y : X} (p : x ＝ y) →
+    {x' w' : Y x} {y' : Y y} (p' : x' ＝ w') →
+    (q' : dependent-identification Y p w' y') →
+    left-whisk-dependent-identification {B' = B} (s' _) p (ap (tr Y p) p' ∙ q') ＝
+    ap (tr B (ap s p)) (ap (s' x) p') ∙
+    left-whisk-dependent-identification {B' = B} (s' _) p q'
+  compute-left-whisk-dependent-identification-concat' s' refl refl q' = refl
+```
+
+```agda
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+  open import foundation.dependent-identifications
+
+  compute-right-concat-dependent-identification :
+    {x y : A} (p : x ＝ y)
+    {z : A} (q : y ＝ z)
+    {x' : B x} {y' : B y} (p' : dependent-identification B p x' y')
+    {z' : B z} (q' : dependent-identification B q y' z')
+    {w' : B z} (r : z' ＝ w') →
+    concat-dependent-identification B p q p' (q' ∙ r) ＝
+    concat-dependent-identification B p q p' q' ∙ r
+  compute-right-concat-dependent-identification refl q refl q' r = refl
+```
+
+```agda
+module _
+  {l1 l2 l3 l4 : Level} {I : UU l1} {A : I → UU l2} {J : UU l3} {B : J → UU l4}
+  {s : I → J} (s' : (i : I) → A i → B (s i))
+  where
+
+  concat-preserves-tr-left-whisk :
+    {i j : I} (p : i ＝ j) {x : A i} →
+    ap
+      ( tr B (ap s (inv p)))
+      ( inv (preserves-tr s' p x)) ∙
+    left-whisk-dependent-identification {B' = B} (s' _) (inv p)
+      ( is-retraction-map-inv-equiv (equiv-tr A p) x) ＝
+    substitution-law-tr B s (inv p) ∙
+    is-retraction-map-inv-equiv (equiv-tr (B ∘ s) p) (s' i x)
+  concat-preserves-tr-left-whisk refl = refl
+
+module _
+  {l1 l2 l3 l4 : Level}
+  {I : UU l1} {A : I → UU l2} {B : I → UU l3} {C : I → UU l4}
+  (g : (i : I) → B i → C i) (f : (i : I) → A i → B i)
+  where
+
+  preserves-tr-comp :
+    {i j : I} (p : i ＝ j) →
+    preserves-tr (λ i → g i ∘ f i) p ~
+    pasting-horizontal-coherence-square-maps (f i) (g i) (tr A p) (tr B p) (tr C p) (f j) (g j)
+      ( preserves-tr f p)
+      ( preserves-tr g p)
+  preserves-tr-comp refl i = refl
+
+  inv-preserves-tr-comp :
+    {i j : I} (p : i ＝ j) →
+    inv-htpy (preserves-tr (λ i → g i ∘ f i) p) ~
+    pasting-vertical-coherence-square-maps (tr A p) (f i) (f j) (tr B p) (g i) (g j) (tr C p)
+      ( inv-htpy (preserves-tr f p))
+      ( inv-htpy (preserves-tr g p))
+  inv-preserves-tr-comp refl x = refl
+
+module _
+  {l1 l2 l3 : Level} {I : UU l1} {A : I → UU l1} {B : I → UU l2}
+  (f : (i : I) → A i → B i)
+  where
+
+  preserves-tr-concat :
+    {i j : I} (p : i ＝ j)
+    {k : I} (q : j ＝ k) →
+    preserves-tr f (p ∙ q) ∙h tr-concat p q ·r f i ~
+    f k ·l tr-concat p q ∙h
+    pasting-vertical-coherence-square-maps (f i) (tr A p) (tr B p) (f j) (tr A q) (tr B q) (f k)
+      ( preserves-tr f p)
+      ( preserves-tr f q)
+  preserves-tr-concat refl q x = refl
+
+  aaa :
+    {i j : I} (p : i ＝ j) →
+    pasting-horizontal-coherence-square-maps
+      ( tr A p) (tr A (inv p)) (f i) (f j) (f i) (tr B p) (tr B (inv p))
+      ( inv-htpy (preserves-tr f p))
+      ( inv-htpy (preserves-tr f (inv p))) ∙h
+    f i ·l is-retraction-map-inv-equiv (equiv-tr A p) ~
+    is-retraction-map-inv-equiv (equiv-tr B p) ·r f i
+  aaa refl x = refl
+
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+
+  ooo :
+    {x y : A} (p : x ＝ y) (b : B x) →
+    tr-concat p (inv p) b ∙ is-retraction-map-inv-equiv (equiv-tr B p) b ＝
+    ap (λ r → tr B r b) (right-inv p)
+  ooo refl b = refl
+
+  open import foundation.homotopy-algebra
+
+  xxx :
+    {l3 : Level} {C : UU l3} (f : C → A)
+    {x y : C} (p : x ＝ y) →
+    horizontal-concat-htpy
+      ( inv-htpy (λ b → substitution-law-tr B f (inv p) {b}))
+      ( inv-htpy (λ b → substitution-law-tr B f p {b})) ∙h
+    ( λ b →
+      ap
+        ( λ r → tr B r (tr B (ap f p) b))
+        ( ap-inv f p)) ∙h
+    is-retraction-map-inv-equiv (equiv-tr B (ap f p)) ~
+    is-retraction-map-inv-equiv (equiv-tr (B ∘ f) p)
+  xxx f refl x = refl
+
+  bbb :
+    {x y : A} (p : x ＝ y)
+    {z : A} (q : y ＝ z) →
+    is-section-map-inv-equiv (equiv-tr B (p ∙ q)) ~
+    horizontal-concat-htpy
+      ( tr-concat p q)
+      ( (λ b → ap (λ r → tr B r b) (distributive-inv-concat p q)) ∙h
+        tr-concat (inv q) (inv p)) ∙h
+    tr B q ·l (is-section-map-inv-equiv (equiv-tr B p)) ·r tr B (inv q) ∙h
+    is-section-map-inv-equiv (equiv-tr B q)
+  bbb refl refl x =
+    inv
+      ( ap
+        ( _∙ is-section-map-inv-equiv id-equiv x)
+        ( ap-id _ ∙ coherence-map-inv-equiv id-equiv x))
+
+  open import foundation.dependent-identifications
+  bbb' :
+    {x y : A} (p : x ＝ y)
+    {z : A} (q : y ＝ z) →
+    (b : B z) →
+    concat-dependent-identification B p q
+      ( ap
+        ( tr B p)
+        ( ( ap
+            ( λ r → tr B r b)
+            ( distributive-inv-concat p q)) ∙
+          ( tr-concat (inv q) (inv p) b)) ∙
+        is-section-map-inv-equiv (equiv-tr B p) (tr B (inv q) b))
+      ( is-section-map-inv-equiv (equiv-tr B q) b) ＝
+    is-section-map-inv-equiv (equiv-tr B (p ∙ q)) b
+  bbb' refl refl b =
+    ap
+      ( _∙ is-section-map-inv-equiv id-equiv b)
+      ( ap-id _ ∙ coherence-map-inv-equiv id-equiv b)
+
+  ccc :
+    {l3 : Level} {C : UU l3} (f : C → A)
+    {x y : C} (p : x ＝ y) →
+    horizontal-concat-htpy
+      ( λ b → substitution-law-tr B f (inv p) {b})
+      ( λ b →
+        ap
+          ( λ r → tr B r b)
+          ( inv (ap-inv f (inv p)) ∙ ap (ap f) (inv-inv p)) ∙
+        substitution-law-tr B f p {b}) ∙h
+    is-retraction-map-inv-equiv (equiv-tr (B ∘ f) p) ~
+    is-section-map-inv-equiv (equiv-tr B (ap f (inv p)))
+  ccc f refl x = inv (coherence-map-inv-equiv id-equiv x)
+
+module _
+  {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : UU l3} (f : C → A)
+  where
+
+
+  bbb'' :
+    {x y : C} (p : x ＝ y)
+    {z : A} (q : z ＝ f y) →
+    {b : B (f x)} →
+    tr-concat q (ap f (inv p)) (tr B (inv (q ∙ ap f (inv p))) b) ∙
+    ap
+      ( tr B (ap f (inv p)))
+      ( ( ap
+          ( tr B q)
+          ( ( ap (λ r → tr B r b) (distributive-inv-concat _ _)) ∙
+            ( tr-concat _ _ b))) ∙
+        ( is-section-map-inv-equiv
+          ( equiv-tr B q)
+          ( tr B (inv (ap f (inv p))) b)) ∙
+        ( ap
+          ( λ r → tr B r b)
+          ( inv (ap-inv f (inv p)) ∙ ap (ap f) (inv-inv p))) ∙
+        ( substitution-law-tr B f p)) ∙
+    ( substitution-law-tr B f (inv p) ∙
+      is-retraction-map-inv-equiv
+        ( equiv-tr (B ∘ f) p)
+        ( b)) ＝
+    is-section-map-inv-equiv
+      ( equiv-tr B (q ∙ ap f (inv p)))
+      ( b)
+  bbb'' refl refl {b} =
+    ap
+      ( _∙ is-retraction-map-inv-equiv id-equiv b)
+      ( ap-id _ ∙ right-unit ∙ right-unit) ∙
+    right-unit
+
+```
+
 ```agda
 module _
   {l1 l2 : Level}
@@ -924,13 +1146,6 @@ module _
       ( H) ∙
     inv-dependent-identification P p (inv K)
   compute-lemma' refl refl f K = refl
-    -- ap
-    --   ( inv-dependent-identification P p)
-    --   ( distributive-inv-concat (ap f H) K ∙ ap (inv K ∙_) (inv (ap-inv f H))) ∙
-    -- compute-lemma p (inv H) f (inv K) ∙
-    -- ap
-    --   ( λ r → ap (tr P (inv p) ∘ f) r ∙ inv-dependent-identification P p (inv K))
-    --   ( inv-inv H)
 ```
 
 ```agda
@@ -948,15 +1163,81 @@ module _
     left-whisk-dependent-identification {B' = Y} s' (inv p)
       ( map-eq-transpose-equiv-inv' (equiv-tr B p) p') ＝
     ap
-      ( λ r → tr Y r (s' x'))
-      ( ap-inv s p) ∙
-    inv
-      ( map-eq-transpose-equiv
-        ( equiv-tr Y (ap s p))
-        ( left-whisk-dependent-identification {B' = Y} s' p
-          ( inv p')))
+      ( tr Y (ap s (inv p)))
+      ( ap s' p') ∙
+    left-whisk-dependent-identification {B' = Y} s' (inv p)
+      ( is-retraction-map-inv-equiv (equiv-tr B p) y')
+    -- ap
+    --   ( λ r → tr Y r (s' x'))
+    --   ( ap-inv s p) ∙
+    -- inv
+    --   ( map-eq-transpose-equiv
+    --     ( equiv-tr Y (ap s p))
+    --     ( left-whisk-dependent-identification {B' = Y} s' p
+    --       ( inv p')))
   compute-left-whisker-transpose s' refl refl =
-    inv (ap inv (compute-refl-eq-transpose-equiv id-equiv))
+    refl
+    -- inv (ap inv (compute-refl-eq-transpose-equiv id-equiv))
+
+module _
+  {l1 l2 : Level} {A : UU l1} {B : UU l2}
+  (e : A ≃ B)
+  where
+
+  inv-coherence-map-inv-is-equiv :
+    (a : A) →
+    ap (map-equiv e) (inv (is-retraction-map-inv-equiv e a)) ＝
+    inv (is-section-map-inv-equiv e (map-equiv e a))
+  inv-coherence-map-inv-is-equiv a =
+    ap-inv (map-equiv e) (is-retraction-map-inv-equiv e a) ∙
+    ap inv (inv (coherence-map-inv-equiv e a))
+
+  left-inv-is-retraction-map-inv-equiv :
+    (a : A) →
+    inv (is-section-map-inv-equiv e (map-equiv e a)) ∙
+    ap (map-equiv e) (is-retraction-map-inv-equiv e a) ＝
+    refl
+  left-inv-is-retraction-map-inv-equiv a =
+    ap
+      ( inv (is-section-map-inv-equiv e (map-equiv e a)) ∙_)
+      ( inv (coherence-map-inv-equiv e a)) ∙
+    left-inv (is-section-map-inv-equiv e (map-equiv e a))
+
+module _
+  {l1 l2 : Level} {A : UU l1} {B : UU l2}
+  (e : A ≃ B)
+  where
+
+  triangle-eq-transpose-equiv-inv'' :
+    {x : B} {y : A} (p : x ＝ map-equiv e y) →
+    inv (is-section-map-inv-equiv e x) ∙ ap (map-equiv e) (map-eq-transpose-equiv-inv' e p) ＝
+    p
+  triangle-eq-transpose-equiv-inv'' refl = left-inv-is-retraction-map-inv-equiv e _
+
+module _
+  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  where
+  open import foundation.dependent-identifications
+
+  nat-concat-dependent-identification :
+    {x y : A} (p : x ＝ y) →
+    {z : A} (q : y ＝ z) →
+    (f : B x → B y) →
+    (H : tr B p ~ f) →
+    {x' y' : B x} (p' : x' ＝ y') →
+    concat-dependent-identification B p q (ap (tr B p) p') (ap (tr B q) (H y')) ＝
+    concat-dependent-identification B p q (H x') (ap (tr B q) (ap f p'))
+  nat-concat-dependent-identification refl refl f H refl = inv right-unit
+
+  nat-concat-dependent-identification-id :
+    {x y : A} (p : x ＝ y) →
+    {z : A} (q : y ＝ z) →
+    (f : B y → B y) →
+    (H : id ~ f) →
+    {x' : B x} {y' : B y} (p' : dependent-identification B p x' y') →
+    concat-dependent-identification B p q p' (ap (tr B q) (H y')) ＝
+    concat-dependent-identification B p q (H (tr B p x')) (ap (tr B q) (ap f p'))
+  nat-concat-dependent-identification-id refl q f H refl = inv right-unit
 
 open import synthetic-homotopy-theory.zigzags-sequential-diagrams
 module _
@@ -1004,6 +1285,46 @@ module _
       ( coherence-cocone-sequential-diagram c' n b)
 
   opaque
+    internal-triangle-upper-triangle-over' :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)) ∘
+      tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a)) ~
+      tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( ap
+          ( map-zigzag-sequential-diagram z (succ-ℕ n))
+          ( upper-triangle-zigzag-sequential-diagram z n a))
+    internal-triangle-upper-triangle-over' n a p =
+      ap
+        ( tr
+          ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+          ( lower-triangle-zigzag-sequential-diagram z n
+            ( map-zigzag-sequential-diagram z n a)))
+        ( ( ap
+            ( λ r → tr (family-descent-data-sequential-colimit Q' (succ-ℕ n)) r p)
+            ( distributive-inv-concat _ _)) ∙
+          ( tr-concat _ _ p)) ∙
+      is-section-map-inv-equiv
+        ( equiv-tr
+          ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+          ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)))
+          ( _) ∙
+      ap
+        ( λ r →
+          tr
+            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+            ( r)
+            ( p))
+        ( ( inv
+            ( ap-inv
+              ( map-zigzag-sequential-diagram z (succ-ℕ n))
+              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))) ∙
+          ( ap (ap (map-zigzag-sequential-diagram z (succ-ℕ n))) (inv-inv _)))
+
     inv-upper-triangle-over' :
       (n : ℕ) (a : family-sequential-diagram A n) →
       tr
@@ -1018,58 +1339,94 @@ module _
         ( family-descent-data-sequential-colimit P' (succ-ℕ n))
         ( upper-triangle-zigzag-sequential-diagram z n a)
     inv-upper-triangle-over' n a p =
+      internal-triangle-upper-triangle-over' n a
+        ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) p) ∙
+      -- left-whisk-dependent-identification
+      --   ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+      --   ( upper-triangle-zigzag-sequential-diagram z n a)
+      --   ( refl)
+      substitution-law-tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+        ( map-zigzag-sequential-diagram z (succ-ℕ n))
+        ( upper-triangle-zigzag-sequential-diagram z n a) ∙
       inv
-        ( ( preserves-tr
-            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
-            ( upper-triangle-zigzag-sequential-diagram z n a)
-            ( p)) ∙
-        ( inv
-          ( substitution-law-tr
-            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-            ( map-zigzag-sequential-diagram z (succ-ℕ n))
-            ( upper-triangle-zigzag-sequential-diagram z n a))) ∙
-        ( ap
-          ( λ r →
-            tr
-              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-              ( r)
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
-                ( map-sequential-diagram A n a)
-                ( p)))
-          ( inv
-            ( ap
-              ( _∙ lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-              ( distributive-inv-concat
-                ( lower-triangle-zigzag-sequential-diagram z n
-                  ( map-zigzag-sequential-diagram z n a))
-                ( ap
-                  ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                  ( inv (upper-triangle-zigzag-sequential-diagram z n a)))) ∙
-            assoc _ _ _ ∙
-            ap
-              ( inv (ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a))) ∙_)
-              ( left-inv (lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))) ∙
-            right-unit ∙
-            ap inv (ap-inv _ _) ∙
-            inv-inv _))) ∙
-        ( tr-concat
-          ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
-          ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-          ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) p)))
-      -- inv
-      --   ( tr-concat
-      --     ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
-      --     ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-      --     ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) p)) ∙
-      -- {!preserves-tr
-      --   ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
-      --   ( )!}
+        ( preserves-tr
+          ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
+          ( upper-triangle-zigzag-sequential-diagram z n a)
+          ( p))
+
+  opaque
+    inv-transport-squares :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      coherence-square-maps
+        ( tr
+          ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+          ( upper-triangle-zigzag-sequential-diagram z n a))
+        ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
+          ( map-sequential-diagram A n a))
+        ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
+          ( inv-map-zigzag-sequential-diagram z n
+            ( map-zigzag-sequential-diagram z n a)))
+        ( tr
+          ( family-descent-data-sequential-colimit Q' (succ-ℕ n) ∘
+            map-zigzag-sequential-diagram z (succ-ℕ n))
+          ( upper-triangle-zigzag-sequential-diagram z n a))
+    inv-transport-squares n a =
+      inv-htpy
+        ( preserves-tr
+          ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
+          ( upper-triangle-zigzag-sequential-diagram z n a))
+      -- pasting-vertical-coherence-square-maps
+      --   ( tr
+      --     ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+      --     ( upper-triangle-zigzag-sequential-diagram z n a))
+      --   ( map-fam-equiv e _)
+      --   ( map-fam-equiv e _)
+      --   ( tr
+      --     ( Q ∘ f∞ ∘ map-cocone-sequential-diagram c (succ-ℕ n))
+      --     ( upper-triangle-zigzag-sequential-diagram z n a))
+      --   ( tr Q (C (succ-ℕ n) _))
+      --   ( tr Q (C (succ-ℕ n) _))
+      --   ( tr
+      --     ( family-descent-data-sequential-colimit Q' (succ-ℕ n) ∘
+      --       map-zigzag-sequential-diagram z (succ-ℕ n))
+      --     ( upper-triangle-zigzag-sequential-diagram z n a))
+      --   ( inv-htpy
+      --     ( preserves-tr
+      --       ( map-fam-equiv e ∘ map-cocone-sequential-diagram c (succ-ℕ n))
+      --       ( upper-triangle-zigzag-sequential-diagram z n a)))
+      --   ( inv-htpy
+      --     ( preserves-tr
+      --       ( λ a → tr Q (C (succ-ℕ n) a))
+      --       ( upper-triangle-zigzag-sequential-diagram z n a)))
+
+  opaque
+    transpose-squares :
+      (n : ℕ) (a : family-sequential-diagram A n) →
+      inv-map-over-diagram-equiv-zigzag' (succ-ℕ n)
+        ( inv-map-zigzag-sequential-diagram z n
+          ( map-zigzag-sequential-diagram z n a)) ∘
+      tr
+        ( family-descent-data-sequential-colimit Q' (succ-ℕ n) ∘
+          map-zigzag-sequential-diagram z (succ-ℕ n))
+        ( upper-triangle-zigzag-sequential-diagram z n a) ∘
+      map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
+        ( map-sequential-diagram A n a) ~
+      tr
+        ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+        ( upper-triangle-zigzag-sequential-diagram z n a)
+    transpose-squares n a p =
+      map-eq-transpose-equiv-inv'
+        ( e _)
+        ( map-eq-transpose-equiv-inv'
+          ( equiv-tr Q (C (succ-ℕ n) _))
+          ( inv-transport-squares n a p))
+
 
   opaque
     upper-triangle-over' :
       (n : ℕ) (a : family-sequential-diagram A n) →
-      map-inv-fam-equiv e _ ∘
-      tr Q (inv (C (succ-ℕ n) _)) ∘
+      inv-map-over-diagram-equiv-zigzag' (succ-ℕ n) _ ∘
       tr
         ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
         ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)) ∘
@@ -1081,11 +1438,16 @@ module _
         ( family-descent-data-sequential-colimit P' (succ-ℕ n))
         ( upper-triangle-zigzag-sequential-diagram z n a)
     upper-triangle-over' n a p =
-      map-eq-transpose-equiv-inv'
-        ( e _)
-        ( map-eq-transpose-equiv-inv'
-          ( equiv-tr Q (C (succ-ℕ n) _))
-          ( inv-upper-triangle-over' n a p))
+       ap
+        ( map-inv-fam-equiv e _ ∘
+          tr Q (inv (C (succ-ℕ n) _)))
+        ( internal-triangle-upper-triangle-over' n a
+          ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) p) ∙
+          substitution-law-tr
+            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+            ( map-zigzag-sequential-diagram z (succ-ℕ n))
+            ( upper-triangle-zigzag-sequential-diagram z n a)) ∙
+        transpose-squares n a p
 
   inv-upper-triangle-over :
     (n : ℕ) (a : family-sequential-diagram A n) →
@@ -1127,6 +1489,12 @@ module _
   upper-triangle-over n {a} p =
     inv (inv-upper-triangle-over n a p)
 
+
+  opaque
+    priv-is-section :
+      {l1 l2 : Level} {A : UU l1} {B : UU l2}
+      (e : A ≃ B) → map-equiv e ∘ map-inv-equiv e ~ id
+    priv-is-section = is-section-map-inv-equiv
   opaque
     lower-triangle-over' :
       (n : ℕ) (a : family-sequential-diagram A n)
@@ -1138,13 +1506,13 @@ module _
         ( inv-map-over-diagram-equiv-zigzag' n a q)
     lower-triangle-over' n a q =
       inv
-        ( is-section-map-inv-equiv
+        ( priv-is-section -- is-section-map-inv-equiv
           ( equiv-tr Q (C n a))
           ( q)) ∙
       ap
         ( tr Q (C n a))
         ( inv
-          ( is-section-map-inv-equiv
+          ( priv-is-section -- is-section-map-inv-equiv
             ( e (map-cocone-sequential-diagram c n a))
             ( tr Q (inv (C n a)) q)))
 
@@ -1204,7 +1572,9 @@ module _
             ( upper-triangle-over' n _ p))
         ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _))
 
-  abstract
+  abstract opaque
+    unfolding lower-triangle-over' upper-triangle-over' inv-transport-squares
+      internal-triangle-upper-triangle-over'
     open import foundation.dependent-identifications
     is-trivial-trivial-pasting :
       (n : ℕ) (a : family-sequential-diagram A n) →
@@ -1220,38 +1590,233 @@ module _
           concat-dependent-identification _ _ _
           ( lower-triangle-over' (succ-ℕ n) _ _)
           ( K'))
-        ( compute-left-whisker-transpose
-          ( λ {a} → map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) a)
-          ( upper-triangle-zigzag-sequential-diagram z n a)
-          ( upper-triangle-over' n a p)) ∙
-      {!!}
+        ( ( ap
+            ( left-whisk-dependent-identification
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
+            ( compute-eq-transpose-equiv-inv-concat'
+              ( equiv-tr
+                ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                ( upper-triangle-zigzag-sequential-diagram z n a))
+              ( _)
+              ( transpose-squares n a p))) ∙
+          ( ( compute-left-whisk-dependent-identification-concat'
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
+              ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+              ( _)
+              ( map-eq-transpose-equiv-inv'
+                ( equiv-tr
+                  ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                  ( upper-triangle-zigzag-sequential-diagram z n a))
+                ( transpose-squares n a p))) ∙
+            ( ap
+              ( λ r →
+                ap
+                  ( tr
+                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                    ( ap
+                      ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                      ( inv (upper-triangle-zigzag-sequential-diagram z n a))))
+                  ( r) ∙
+                left-whisk-dependent-identification
+                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+                  ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+                  ( map-eq-transpose-equiv-inv'
+                    ( equiv-tr
+                      ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                      ( upper-triangle-zigzag-sequential-diagram z n a))
+                    ( transpose-squares n a p)))
+              ( inv
+                ( ap-comp
+                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+                  ( inv-map-over-diagram-equiv-zigzag' (succ-ℕ n) _)
+                  ( _)))))) ∙
+      compute-right-concat-dependent-identification
+        ( lower-triangle-zigzag-sequential-diagram z n
+          ( map-zigzag-sequential-diagram z n a))
+        ( ap
+          ( map-zigzag-sequential-diagram z (succ-ℕ n))
+          ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
+        ( _)
+        ( _)
+        ( _) ∙
+      ap
+        ( _∙
+          left-whisk-dependent-identification
+            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+            ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+            ( map-eq-transpose-equiv-inv'
+              ( equiv-tr
+                ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                ( upper-triangle-zigzag-sequential-diagram z n a))
+              ( transpose-squares n a p)))
+        ( inv
+          ( nat-concat-dependent-identification-id
+            ( lower-triangle-zigzag-sequential-diagram z n
+              ( map-zigzag-sequential-diagram z n a))
+            ( ap
+              ( map-zigzag-sequential-diagram z (succ-ℕ n))
+              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
+            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ ∘
+              inv-map-over-diagram-equiv-zigzag' (succ-ℕ n) _)
+            ( λ q →
+              lower-triangle-over' (succ-ℕ n)
+                ( inv-map-zigzag-sequential-diagram z n
+                  ( map-zigzag-sequential-diagram z n a))
+                ( q))
+            ( internal-triangle-upper-triangle-over' n a
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ p) ∙
+              substitution-law-tr
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                ( _)
+                ( upper-triangle-zigzag-sequential-diagram z n a))) ∙
+          compute-right-concat-dependent-identification
+            ( lower-triangle-zigzag-sequential-diagram z n
+              ( map-zigzag-sequential-diagram z n a))
+            ( ap
+              ( map-zigzag-sequential-diagram z (succ-ℕ n))
+              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
+            ( _)
+            ( refl)
+            ( _)) ∙
+      assoc _ _ _ ∙
+      ap
+        ( concat-dependent-identification
+          ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+          ( _)
+          ( _)
+          ( internal-triangle-upper-triangle-over' n a
+            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ p) ∙
+            substitution-law-tr
+              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+              ( _)
+              ( upper-triangle-zigzag-sequential-diagram z n a))
+          ( refl) ∙_)
+        ( ( ap
+            ( ap
+              ( tr
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                ( ap
+                  ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                  ( inv (upper-triangle-zigzag-sequential-diagram z n a))))
+              ( lower-triangle-over' (succ-ℕ n) _ _) ∙_)
+            ( compute-left-whisker-transpose
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+              ( upper-triangle-zigzag-sequential-diagram z n a)
+              ( transpose-squares n a p))) ∙
+          ( inv (assoc _ _ _)) ∙
+          ( ap
+            ( _∙
+              left-whisk-dependent-identification
+                ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+                ( inv (upper-triangle-zigzag-sequential-diagram z n a))
+                ( is-retraction-map-inv-equiv
+                  ( equiv-tr
+                    ( family-descent-data-sequential-colimit P' (succ-ℕ n))
+                    ( upper-triangle-zigzag-sequential-diagram z n a))
+                  ( p)))
+            ( ( inv
+                ( ap-concat
+                  ( tr
+                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                    ( ap
+                      ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                      ( inv (upper-triangle-zigzag-sequential-diagram z n a))))
+                  ( lower-triangle-over' (succ-ℕ n) _ _)
+                  ( ap
+                    ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+                    ( transpose-squares n a p)))) ∙
+              ( ap
+                ( ap
+                  ( tr
+                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+                    ( ap
+                      ( map-zigzag-sequential-diagram z (succ-ℕ n))
+                      ( inv (upper-triangle-zigzag-sequential-diagram z n a)))))
+                ( [i] p)))) ∙
+          ( concat-preserves-tr-left-whisk
+            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
+            ( upper-triangle-zigzag-sequential-diagram z n a))) ∙
+      ap
+        ( _∙
+          ( ( substitution-law-tr
+              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+              ( map-zigzag-sequential-diagram z (succ-ℕ n))
+              ( inv (upper-triangle-zigzag-sequential-diagram z n a))) ∙
+            ( is-retraction-map-inv-equiv
+              ( equiv-tr
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n) ∘
+                  map-zigzag-sequential-diagram z (succ-ℕ n))
+                ( upper-triangle-zigzag-sequential-diagram z n a))
+              ( _))))
+        ( ( compute-concat-dependent-identification
+            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
+            ( lower-triangle-zigzag-sequential-diagram z n
+              ( map-zigzag-sequential-diagram z n a))
+            ( ap
+              ( map-zigzag-sequential-diagram z (succ-ℕ n))
+              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
+            ( _)
+            ( _)) ∙
+          right-unit) ∙
+      bbb''
+        ( map-zigzag-sequential-diagram z (succ-ℕ n))
+        ( upper-triangle-zigzag-sequential-diagram z n a)
+        ( lower-triangle-zigzag-sequential-diagram z n
+          ( map-zigzag-sequential-diagram z n a))
+      where
+      opaque
+        unfolding lower-triangle-over' transpose-squares priv-is-section
+        [i] :
+          lower-triangle-over' (succ-ℕ n)
+            ( inv-map-zigzag-sequential-diagram z n
+              ( map-zigzag-sequential-diagram z n a)) ·r
+            ( ( tr
+                ( family-descent-data-sequential-colimit Q' (succ-ℕ n) ∘
+                  map-zigzag-sequential-diagram z (succ-ℕ n))
+                ( upper-triangle-zigzag-sequential-diagram z n a)) ∘
+              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
+                ( map-sequential-diagram A n a))) ∙h
+          map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ ·l
+          transpose-squares n a ~
+          inv-transport-squares n a
+        [i] p =
+          assoc _ _ _ ∙
+          ap
+            ( inv
+              ( is-section-map-inv-equiv
+                ( equiv-tr Q
+                  ( C (succ-ℕ n) _))
+                ( _)) ∙_)
+            ( ( ap
+                ( ap
+                  ( tr Q (C (succ-ℕ n) _))
+                  ( inv
+                    ( is-section-map-inv-equiv
+                      ( e _)
+                      ( tr Q (inv (C (succ-ℕ n) _)) _))) ∙_)
+                ( ap-comp
+                  ( tr Q (C (succ-ℕ n) _))
+                  ( map-fam-equiv e _)
+                  ( transpose-squares n a p))) ∙
+              ( inv
+                ( ap-concat
+                  ( tr Q (C (succ-ℕ n) _))
+                  ( _)
+                  ( _))) ∙
+              ( ap
+                ( ap (tr Q (C (succ-ℕ n) _)))
+                ( triangle-eq-transpose-equiv-inv''
+                  ( e _)
+                  ( map-eq-transpose-equiv-inv'
+                    ( equiv-tr Q (C (succ-ℕ n) _))
+                    ( inv-transport-squares n a p))))) ∙
+          triangle-eq-transpose-equiv-inv''
+            ( equiv-tr Q (C (succ-ℕ n) _))
+            ( inv-transport-squares n a p)
 ```
 
 ```agda
-module _
-  {l1 l2 : Level} {A : UU l1} {B : UU l2}
-  (e : A ≃ B)
-  where
-
-  inv-coherence-map-inv-is-equiv :
-    (a : A) →
-    ap (map-equiv e) (inv (is-retraction-map-inv-equiv e a)) ＝
-    inv (is-section-map-inv-equiv e (map-equiv e a))
-  inv-coherence-map-inv-is-equiv a =
-    ap-inv (map-equiv e) (is-retraction-map-inv-equiv e a) ∙
-    ap inv (inv (coherence-map-inv-equiv e a))
-
-  left-inv-is-retraction-map-inv-equiv :
-    (a : A) →
-    inv (is-section-map-inv-equiv e (map-equiv e a)) ∙
-    ap (map-equiv e) (is-retraction-map-inv-equiv e a) ＝
-    refl
-  left-inv-is-retraction-map-inv-equiv a =
-    ap
-      ( inv (is-section-map-inv-equiv e (map-equiv e a)) ∙_)
-      ( inv (coherence-map-inv-equiv e a)) ∙
-    left-inv (is-section-map-inv-equiv e (map-equiv e a))
-
 module _
   {l1 l2 : Level} {A : UU l1} {B : UU l2}
   (e : A ≃ B)

From b93771b6f21d059804de8488fc0dcf7ee7f1038b Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Sat, 22 Mar 2025 21:35:32 +0100
Subject: [PATCH 31/33] Remove old stuff

---
 .../old-stuff.lagda.md                        | 1400 -----------------
 1 file changed, 1400 deletions(-)
 delete mode 100644 src/synthetic-homotopy-theory/old-stuff.lagda.md

diff --git a/src/synthetic-homotopy-theory/old-stuff.lagda.md b/src/synthetic-homotopy-theory/old-stuff.lagda.md
deleted file mode 100644
index 8234ecbf02..0000000000
--- a/src/synthetic-homotopy-theory/old-stuff.lagda.md
+++ /dev/null
@@ -1,1400 +0,0 @@
-New idea: instead of bruteforcing this direction, show that a square induces
-coherent cubes, and show that it's an equivalence because it fits in a diagram.
-
--- ## Commuting cubes induce commuting squares in the colimit
-
--- ```agda
--- open import foundation.commuting-cubes-of-maps
--- module _
---   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
---   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
---   (up-a : universal-property-sequential-colimit a)
---   {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
---   (up-b : universal-property-sequential-colimit b)
---   {P : sequential-diagram l5} {V : UU l6} {p : cocone-sequential-diagram P V}
---   (up-p : universal-property-sequential-colimit p)
---   {Q : sequential-diagram l7} {W : UU l8} {q : cocone-sequential-diagram Q W}
---   (up-q : universal-property-sequential-colimit q)
---   (f' : hom-sequential-diagram P Q)
---   (f : hom-sequential-diagram A B)
---   (g : hom-sequential-diagram P A)
---   (h : hom-sequential-diagram Q B)
---   where
-
---   square-cube-sequential-colimit :
---     (faces :
---       (n : ℕ) →
---       coherence-square-maps
---         ( map-hom-sequential-diagram Q f' n)
---         ( map-hom-sequential-diagram A g n)
---         ( map-hom-sequential-diagram B h n)
---         ( map-hom-sequential-diagram B f n)) →
---     (cubes :
---       (n : ℕ) →
---       coherence-cube-maps
---         ( map-hom-sequential-diagram B f n)
---         ( map-sequential-diagram A n)
---         ( map-sequential-diagram B n)
---         ( map-hom-sequential-diagram B f (succ-ℕ n))
---         ( map-hom-sequential-diagram Q f' n)
---         ( map-sequential-diagram P n)
---         ( map-sequential-diagram Q n)
---         ( map-hom-sequential-diagram Q f' (succ-ℕ n))
---         ( map-hom-sequential-diagram A g n)
---         ( map-hom-sequential-diagram B h n)
---         ( map-hom-sequential-diagram A g (succ-ℕ n))
---         ( map-hom-sequential-diagram B h (succ-ℕ n))
---         ( naturality-map-hom-sequential-diagram Q f' n)
---         ( faces n)
---         ( naturality-map-hom-sequential-diagram A g n)
---         ( naturality-map-hom-sequential-diagram B h n)
---         ( faces (succ-ℕ n))
---         ( naturality-map-hom-sequential-diagram B f n)) →
---     coherence-square-maps
---       ( map-sequential-colimit-hom-sequential-diagram up-p q f')
---       ( map-sequential-colimit-hom-sequential-diagram up-p a g)
---       ( map-sequential-colimit-hom-sequential-diagram up-q b h)
---       ( map-sequential-colimit-hom-sequential-diagram up-a b f)
---   square-cube-sequential-colimit faces cubes =
---     inv-htpy
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-p up-a b
---         f g) ∙h
---     induced-htpy ∙h
---     preserves-comp-map-sequential-colimit-hom-sequential-diagram up-p up-q b h f'
---     where
---     comp1 comp2 : hom-sequential-diagram P B
---     comp1 = comp-hom-sequential-diagram P A B f g
---     comp2 = comp-hom-sequential-diagram P Q B h f'
---     induced-hom-htpy : htpy-hom-sequential-diagram B comp1 comp2
---     pr1 induced-hom-htpy = faces
---     pr2 induced-hom-htpy n =
---       assoc-htpy _ _ _ ∙h
---       inv-htpy (cubes n) ∙h
---       assoc-htpy _ _ _
---     induced-htpy :
---       map-sequential-colimit-hom-sequential-diagram up-p b comp1 ~
---       map-sequential-colimit-hom-sequential-diagram up-p b comp2
---     induced-htpy =
---       htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-p b
---         ( induced-hom-htpy)
--- ```
-
--- ## Concatenation of homotopies of morphisms of sequential diagrams
-
--- ```agda
--- open import foundation.whiskering-homotopies-concatenation
--- module _
---   {l1 l2 : Level}
---   {A : sequential-diagram l1} {B : sequential-diagram l2}
---   (f g h : hom-sequential-diagram A B)
---   where
-
---   module _
---     (H : htpy-hom-sequential-diagram B f g)
---     (K : htpy-hom-sequential-diagram B g h)
---     where
-
---     concat-htpy-hom-sequential-diagram : htpy-hom-sequential-diagram B f h
---     pr1 concat-htpy-hom-sequential-diagram n =
---       htpy-htpy-hom-sequential-diagram _ H n ∙h
---       htpy-htpy-hom-sequential-diagram _ K n
---     pr2 concat-htpy-hom-sequential-diagram n =
---       inv-htpy-assoc-htpy _ _ _ ∙h
---       right-whisker-concat-htpy
---         ( coherence-htpy-htpy-hom-sequential-diagram B H n)
---         ( htpy-htpy-hom-sequential-diagram _ K (succ-ℕ n) ·r map-sequential-diagram A n) ∙h
---       assoc-htpy _ _ _ ∙h
---       left-whisker-concat-htpy
---         ( map-sequential-diagram B n ·l htpy-htpy-hom-sequential-diagram _ H n)
---         ( coherence-htpy-htpy-hom-sequential-diagram B K n) ∙h
---       inv-htpy-assoc-htpy _ _ _ ∙h
---       right-whisker-concat-htpy
---         ( inv-htpy
---           ( distributive-left-whisker-comp-concat
---             ( map-sequential-diagram B n)
---             ( htpy-htpy-hom-sequential-diagram _ H n)
---             ( htpy-htpy-hom-sequential-diagram _ K n)))
---         ( naturality-map-hom-sequential-diagram B h n)
-
---   htpy-eq-concat-hom-sequential-diagram :
---     (p : f ＝ g) (q : g ＝ h) →
---     htpy-eq-sequential-diagram A B f h (p ∙ q) ＝
---     concat-htpy-hom-sequential-diagram
---       ( htpy-eq-sequential-diagram A B f g p)
---       ( htpy-eq-sequential-diagram A B g h q)
---   htpy-eq-concat-hom-sequential-diagram refl refl =
---     eq-pair-eq-fiber
---       ( inv
---         ( eq-binary-htpy _ _
---           λ n a →
---           right-unit ∙ right-unit ∙
---           ap
---             ( (inv (assoc _ refl refl) ∙ ap (_∙ refl) right-unit) ∙ refl ∙_)
---             ( ap-id right-unit) ∙
---           ap
---             ( _∙ right-unit)
---             ( right-unit ∙
---               ap
---                 ( λ p → inv p ∙ ap (_∙ refl) right-unit)
---                 ( middle-unit-law-assoc
---                     ( naturality-map-hom-sequential-diagram B f n a)
---                     ( refl)) ∙
---               left-inv (ap (_∙ refl) right-unit))))
---     where
---       open import foundation.binary-homotopies
---       open import foundation.path-algebra
-
---   eq-htpy-concat-hom-sequential-diagram :
---     (H : htpy-hom-sequential-diagram B f g)
---     (K : htpy-hom-sequential-diagram B g h) →
---     eq-htpy-sequential-diagram A B f h
---       ( concat-htpy-hom-sequential-diagram H K) ＝
---     eq-htpy-sequential-diagram A B f g H ∙
---     eq-htpy-sequential-diagram A B g h K
---   eq-htpy-concat-hom-sequential-diagram H K =
---     ap
---       ( eq-htpy-sequential-diagram A B f h)
---       ( inv
---         ( htpy-eq-concat-hom-sequential-diagram
---           ( eq-htpy-sequential-diagram A B f g H)
---           ( eq-htpy-sequential-diagram A B g h K) ∙
---         ap-binary concat-htpy-hom-sequential-diagram
---           ( is-section-map-inv-equiv
---             ( extensionality-hom-sequential-diagram A B f g)
---             ( H))
---           ( is-section-map-inv-equiv
---             ( extensionality-hom-sequential-diagram A B g h)
---             ( K)))) ∙
---     is-retraction-map-inv-equiv
---       ( extensionality-hom-sequential-diagram A B f h)
---       ( eq-htpy-sequential-diagram A B f g H ∙
---         eq-htpy-sequential-diagram A B g h K)
---     where open import foundation.action-on-identifications-binary-functions
--- ```
-
--- ## Vertical pasting of cubes of stuff
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 l5 l6 : Level}
---   {A : sequential-diagram l1} {B : sequential-diagram l2}
---   {A' : sequential-diagram l3} {B' : sequential-diagram l4}
---   {A'' : sequential-diagram l5} {B'' : sequential-diagram l6}
---   (top : hom-sequential-diagram A'' B'')
---   (top-left : hom-sequential-diagram A'' A')
---   (top-right : hom-sequential-diagram B'' B')
---   (mid : hom-sequential-diagram A' B')
---   (bottom-left : hom-sequential-diagram A' A)
---   (bottom-right : hom-sequential-diagram B' B)
---   (bottom : hom-sequential-diagram A B)
---   (H :
---     htpy-hom-sequential-diagram B
---       ( comp-hom-sequential-diagram A' A B bottom bottom-left)
---       ( comp-hom-sequential-diagram A' B' B bottom-right mid))
---   (K :
---     htpy-hom-sequential-diagram B'
---       ( comp-hom-sequential-diagram A'' A' B' mid top-left)
---       ( comp-hom-sequential-diagram A'' B'' B' top-right top))
---   -- (faces-top :
---   --   (n : ℕ) →
---   --   coherence-square-maps
---   --     ( map-hom-sequential-diagram B'' top n)
---   --     ( map-hom-sequential-diagram A' top-left n)
---   --     ( map-hom-sequential-diagram B' top-right n)
---   --     ( map-hom-sequential-diagram B' mid n))
---   -- (faces-bottom :
---   --   (n : ℕ) → {!!})
---   -- (cubes-top :
---   --   (n : ℕ) → {!!})
---   -- (cubes-bottom :
---   --   (n : ℕ) → {!!})
---   -- -- (cubes :
---   -- --   (n : ℕ) →
---   -- --   coherence-cube-maps
---   -- --     ( map-hom-sequential-diagram B f n)
---   -- --     ( map-sequential-diagram A n)
---   -- --     ( map-sequential-diagram B n)
---   -- --     ( map-hom-sequential-diagram B f (succ-ℕ n))
---   -- --     ( map-hom-sequential-diagram Q f' n)
---   -- --     ( map-sequential-diagram P n)
---   -- --     ( map-sequential-diagram Q n)
---   -- --     ( map-hom-sequential-diagram Q f' (succ-ℕ n))
---   -- --     ( map-hom-sequential-diagram A g n)
---   -- --     ( map-hom-sequential-diagram B h n)
---   -- --     ( map-hom-sequential-diagram A g (succ-ℕ n))
---   -- --     ( map-hom-sequential-diagram B h (succ-ℕ n))
---   -- --     ( naturality-map-hom-sequential-diagram Q f' n)
---   -- --     ( faces n)
---   -- --     ( naturality-map-hom-sequential-diagram A g n)
---   -- --     ( naturality-map-hom-sequential-diagram B h n)
---   -- --     ( faces (succ-ℕ n))
---   -- --     ( naturality-map-hom-sequential-diagram B f n)) →
---   where
-
---   pasting-vertical-coherence-square-hom-sequential-diagram :
---     htpy-hom-sequential-diagram B
---       ( comp-hom-sequential-diagram A'' A B bottom
---         ( comp-hom-sequential-diagram A'' A' A bottom-left top-left))
---       ( comp-hom-sequential-diagram A'' B'' B
---         ( comp-hom-sequential-diagram B'' B' B bottom-right top-right)
---         ( top))
---   pasting-vertical-coherence-square-hom-sequential-diagram = {!!}
--- ```
-
--- ## Whiskering of homotopies of morphisms of sequential diagrams
-
--- ### Right whiskering
-
--- ```agda
--- module _
---   {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3}
---   where
-
---   htpy-eq-right-whisker :
---     {f g : B → C} (p : f ＝ g) (h : A → B) →
---     htpy-eq (ap (_∘ h) p) ＝ htpy-eq p ·r h
---   htpy-eq-right-whisker refl h = refl
-
---   eq-htpy-right-whisker :
---     {f g : B → C} (H : f ~ g) (h : A → B) →
---     eq-htpy (H ·r h) ＝ ap (_∘ h) (eq-htpy H)
---   eq-htpy-right-whisker H h =
---     ap eq-htpy
---       ( inv
---         ( htpy-eq-right-whisker (eq-htpy H) h ∙
---           ap (_·r h) (is-section-eq-htpy H))) ∙
---     is-retraction-eq-htpy (ap (_∘ h) (eq-htpy H))
-
---   htpy-eq-left-whisker :
---     {f g : A → B} (h : B → C) (p : f ＝ g) →
---     htpy-eq (ap (h ∘_) p) ＝ h ·l htpy-eq p
---   htpy-eq-left-whisker h refl = refl
-
---   -- alternatively, using homotopy induction
---   eq-htpy-left-whisker :
---     {f g : A → B} (h : B → C) (H : f ~ g) →
---     eq-htpy (h ·l H) ＝ ap (h ∘_) (eq-htpy H)
---   eq-htpy-left-whisker {f} h =
---     ind-htpy f
---       ( λ g H →
---         eq-htpy (h ·l H) ＝ ap (h ∘_) (eq-htpy H))
---       ( eq-htpy-refl-htpy (h ∘ f) ∙
---         inv (ap (ap (h ∘_)) (eq-htpy-refl-htpy f)))
---     where open import foundation.homotopy-induction
--- ```
-
--- ```agda
--- module _
---   {l1 l2 l3 : Level}
---   {A : sequential-diagram l1} {B : sequential-diagram l2}
---   {X : sequential-diagram l3}
---   {f g : hom-sequential-diagram A B}
---   where
---   open import foundation.whiskering-identifications-concatenation
-
---   module _
---     (H : htpy-hom-sequential-diagram B f g)
---     (h : hom-sequential-diagram X A)
---     where
-
---     right-whisker-concat-htpy-hom-sequential-diagram :
---       htpy-hom-sequential-diagram B
---         ( comp-hom-sequential-diagram X A B f h)
---         ( comp-hom-sequential-diagram X A B g h)
---     pr1 right-whisker-concat-htpy-hom-sequential-diagram n =
---       htpy-htpy-hom-sequential-diagram _ H n ·r map-hom-sequential-diagram A h n
---     pr2 right-whisker-concat-htpy-hom-sequential-diagram n x =
---       assoc _ _ _ ∙
---       left-whisker-concat
---         ( naturality-map-hom-sequential-diagram B f n (map-hom-sequential-diagram A h n x))
---         ( inv-nat-htpy
---           ( htpy-htpy-hom-sequential-diagram B H (succ-ℕ n))
---           ( naturality-map-hom-sequential-diagram A h n x)) ∙
---       inv (assoc _ _ _) ∙
---       right-whisker-concat
---         ( coherence-htpy-htpy-hom-sequential-diagram B H n (map-hom-sequential-diagram A h n x))
---         ( ap
---           ( map-hom-sequential-diagram B g (succ-ℕ n))
---           ( naturality-map-hom-sequential-diagram A h n x)) ∙
---       assoc _ _ _
-
---   htpy-eq-right-whisker-htpy-hom-sequential-diagram :
---     (p : f ＝ g) (h : hom-sequential-diagram X A) →
---     htpy-eq-sequential-diagram X B
---       ( comp-hom-sequential-diagram X A B f h)
---       ( comp-hom-sequential-diagram X A B g h)
---       ( ap (λ f → comp-hom-sequential-diagram X A B f h) p) ＝
---     right-whisker-concat-htpy-hom-sequential-diagram
---       ( htpy-eq-sequential-diagram A B f g p)
---       ( h)
---   htpy-eq-right-whisker-htpy-hom-sequential-diagram refl h =
---     eq-pair-eq-fiber
---       ( eq-binary-htpy _ _
---         λ n x →
---         inv
---           ( right-unit ∙
---             ap-binary
---               ( λ p q →
---                 p ∙
---                 left-whisker-concat _ q ∙
---                 inv (assoc _ refl _) ∙
---                 right-whisker-concat _ _)
---               ( right-unit-law-assoc _ _)
---               ( inv-nat-refl-htpy _ _) ∙
---             ap
---               ( λ p →
---                 right-unit ∙
---                 left-whisker-concat _ (inv right-unit) ∙
---                 left-whisker-concat _ right-unit ∙
---                 inv p ∙
---                 right-whisker-concat right-unit _)
---               ( middle-unit-law-assoc _ _) ∙
---             is-section-inv-concat'
---               ( right-whisker-concat right-unit _)
---               ( right-unit ∙
---                 left-whisker-concat _ (inv right-unit) ∙
---                 left-whisker-concat _ right-unit) ∙
---             ap
---               ( λ p → right-unit ∙ p ∙ left-whisker-concat _ right-unit)
---               ( ap-inv (naturality-map-hom-sequential-diagram B f n _ ∙_) right-unit) ∙
---             is-section-inv-concat'
---               ( ap (naturality-map-hom-sequential-diagram B f n _ ∙_) right-unit)
---               ( right-unit)))
---     where
---       open import foundation.binary-homotopies
---       open import foundation.path-algebra
---       open import foundation.action-on-identifications-binary-functions
-
---   eq-htpy-right-whisker-htpy-hom-sequential-diagram :
---     (H : htpy-hom-sequential-diagram B f g) (h : hom-sequential-diagram X A) →
---     eq-htpy-sequential-diagram X B
---       ( comp-hom-sequential-diagram X A B f h)
---       ( comp-hom-sequential-diagram X A B g h)
---       ( right-whisker-concat-htpy-hom-sequential-diagram H h) ＝
---     ap
---       ( λ f → comp-hom-sequential-diagram X A B f h)
---       ( eq-htpy-sequential-diagram A B f g H)
---   eq-htpy-right-whisker-htpy-hom-sequential-diagram H h =
---     ap
---       ( eq-htpy-sequential-diagram X B _ _)
---       ( inv
---         ( htpy-eq-right-whisker-htpy-hom-sequential-diagram
---             ( eq-htpy-sequential-diagram A B f g H)
---             ( h) ∙
---           ap
---             ( λ H → right-whisker-concat-htpy-hom-sequential-diagram H h)
---             ( is-section-map-inv-equiv
---               ( extensionality-hom-sequential-diagram A B f g)
---               ( H)))) ∙
---     is-retraction-map-inv-equiv
---       ( extensionality-hom-sequential-diagram X B
---         ( comp-hom-sequential-diagram X A B f h)
---         ( comp-hom-sequential-diagram X A B g h))
---       ( ap
---         ( λ f → comp-hom-sequential-diagram X A B f h)
---         ( eq-htpy-sequential-diagram A B f g H))
--- ```
-
--- ### Left whiskering
-
--- ```agda
--- module _
---   {l1 l2 l3 : Level}
---   {A : sequential-diagram l1} {B : sequential-diagram l2}
---   {X : sequential-diagram l3}
---   {f g : hom-sequential-diagram A B}
---   where
---   open import foundation.whiskering-identifications-concatenation
-
---   module _
---     (h : hom-sequential-diagram B X)
---     (H : htpy-hom-sequential-diagram B f g)
---     where
-
---     left-whisker-concat-htpy-hom-sequential-diagram :
---       htpy-hom-sequential-diagram X
---         ( comp-hom-sequential-diagram A B X h f)
---         ( comp-hom-sequential-diagram A B X h g)
---     pr1 left-whisker-concat-htpy-hom-sequential-diagram n =
---       map-hom-sequential-diagram X h n ·l htpy-htpy-hom-sequential-diagram _ H n
---     pr2 left-whisker-concat-htpy-hom-sequential-diagram n a =
---       assoc _ _ _ ∙
---       left-whisker-concat
---         ( naturality-map-hom-sequential-diagram X h n (map-hom-sequential-diagram B f n a))
---         ( inv (ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
---           ap
---             ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
---             ( coherence-htpy-htpy-hom-sequential-diagram B H n a) ∙
---           ap-concat (map-hom-sequential-diagram X h (succ-ℕ n)) _ _) ∙
---       inv (assoc _ _ _) ∙
---       right-whisker-concat
---         ( left-whisker-concat
---             ( naturality-map-hom-sequential-diagram X h n
---               ( map-hom-sequential-diagram B f n a))
---             ( inv
---               ( ap-comp
---                 ( map-hom-sequential-diagram X h (succ-ℕ n))
---                 ( map-sequential-diagram B n)
---                 ( htpy-htpy-hom-sequential-diagram B H n a))) ∙
---           nat-htpy
---             ( naturality-map-hom-sequential-diagram X h n)
---             ( htpy-htpy-hom-sequential-diagram B H n a) ∙
---           right-whisker-concat
---             ( ap-comp
---               ( map-sequential-diagram X n)
---               ( map-hom-sequential-diagram X h n)
---               ( htpy-htpy-hom-sequential-diagram B H n a))
---             ( naturality-map-hom-sequential-diagram X h n
---               ( map-hom-sequential-diagram B g n a)))
---         ( ap
---           ( map-hom-sequential-diagram X h (succ-ℕ n))
---           ( naturality-map-hom-sequential-diagram B g n a)) ∙
---       assoc _ _ _
-
---   htpy-eq-left-whisker-htpy-hom-sequential-diagram :
---     (h : hom-sequential-diagram B X) (p : f ＝ g) →
---     htpy-eq-sequential-diagram A X
---       ( comp-hom-sequential-diagram A B X h f)
---       ( comp-hom-sequential-diagram A B X h g)
---       ( ap (comp-hom-sequential-diagram A B X h) p) ＝
---     left-whisker-concat-htpy-hom-sequential-diagram h
---       ( htpy-eq-sequential-diagram A B f g p)
---   htpy-eq-left-whisker-htpy-hom-sequential-diagram h refl =
---     eq-pair-eq-fiber
---       ( eq-binary-htpy _ _
---         ( λ n a →
---           inv
---             ( right-unit ∙
---               ( ap-binary
---                 ( λ p q →
---                   p ∙
---                   left-whisker-concat
---                     ( naturality-map-hom-sequential-diagram X h n
---                       ( map-hom-sequential-diagram B f n a))
---                     ( inv (ap-concat _ _ refl) ∙
---                       ap
---                         ( ap (map-hom-sequential-diagram X h (succ-ℕ n)))
---                         ( right-unit) ∙
---                       refl) ∙
---                   q ∙
---                   right-whisker-concat (right-unit ∙ refl) _)
---                 ( right-unit-law-assoc _ (ap _ _) ∙
---                   left-whisker-concat right-unit (ap-inv _ right-unit))
---                 ( ap inv (middle-unit-law-assoc _ _))) ∙
---               ( ap-binary
---                 ( λ p q →
---                   right-unit ∙
---                   inv (left-whisker-concat _ right-unit) ∙
---                   left-whisker-concat _ p ∙
---                   inv (right-whisker-concat right-unit _) ∙
---                   right-whisker-concat q _)
---                 ( right-unit ∙
---                   right-whisker-concat
---                     ( ap inv (compute-right-refl-ap-concat _ _) ∙
---                       distributive-inv-concat
---                         ( ap (ap _) right-unit)
---                         ( inv right-unit) ∙
---                       right-whisker-concat (inv-inv right-unit) _)
---                     ( ap (ap _) right-unit) ∙
---                   is-section-inv-concat' (ap (ap _) right-unit) right-unit)
---                 ( right-unit)) ∙
---               is-section-inv-concat'
---                 ( right-whisker-concat right-unit _)
---                 ( right-unit ∙ inv _ ∙ _) ∙
---               is-section-inv-concat'
---                 ( left-whisker-concat _ right-unit)
---                 ( right-unit))))
---     where
---       open import foundation.action-on-identifications-binary-functions
---       open import foundation.binary-homotopies
---       open import foundation.path-algebra
-
---   eq-htpy-left-whisker-htpy-hom-sequential-diagram :
---     (h : hom-sequential-diagram B X) (H : htpy-hom-sequential-diagram B f g) →
---     eq-htpy-sequential-diagram A X
---       ( comp-hom-sequential-diagram A B X h f)
---       ( comp-hom-sequential-diagram A B X h g)
---       ( left-whisker-concat-htpy-hom-sequential-diagram h H) ＝
---     ap
---       ( comp-hom-sequential-diagram A B X h)
---       ( eq-htpy-sequential-diagram A B f g H)
---   eq-htpy-left-whisker-htpy-hom-sequential-diagram h H =
---     ap
---       ( eq-htpy-sequential-diagram A X _ _)
---       ( inv
---         ( htpy-eq-left-whisker-htpy-hom-sequential-diagram h
---             ( eq-htpy-sequential-diagram A B f g H) ∙
---           ap
---             ( left-whisker-concat-htpy-hom-sequential-diagram h)
---             ( is-section-map-inv-equiv
---               ( extensionality-hom-sequential-diagram A B f g)
---               ( H)))) ∙
---     is-retraction-map-inv-equiv
---       ( extensionality-hom-sequential-diagram A X
---         ( comp-hom-sequential-diagram A B X h f)
---         ( comp-hom-sequential-diagram A B X h g))
---       ( ap
---         ( comp-hom-sequential-diagram A B X h)
---         ( eq-htpy-sequential-diagram A B f g H))
--- ```
-
--- ## Action on homotopies of morphisms of sequential diagrams preserves whiskering
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 l5 l6 : Level}
---   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
---   (up-a : universal-property-sequential-colimit a)
---   {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
---   (up-b : universal-property-sequential-colimit b)
---   {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
---   {f g : hom-sequential-diagram B C}
---   where
-
---   coh-comp-hom-sequential-diagram :
---     (p : f ＝ g) (h : hom-sequential-diagram A B) →
---     ap
---       ( map-sequential-colimit-hom-sequential-diagram up-a c)
---       ( ap (λ f → comp-hom-sequential-diagram A B C f h) p) ∙
---     eq-htpy
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h) ＝
---     eq-htpy
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙
---     ap
---       ( _∘ map-sequential-colimit-hom-sequential-diagram up-a b h)
---       ( ap
---         ( map-sequential-colimit-hom-sequential-diagram up-b c)
---         ( p))
---   coh-comp-hom-sequential-diagram refl h = inv right-unit
-
---   preserves-right-whisker-htpy-hom-sequential-diagram :
---     (H : htpy-hom-sequential-diagram C f g)
---     (h : hom-sequential-diagram A B) →
---     ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
---         ( right-whisker-concat-htpy-hom-sequential-diagram H h)) ∙h
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c g h)) ~
---     ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c f h) ∙h
---       ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-b c H ·r
---         map-sequential-colimit-hom-sequential-diagram up-a b h))
---   preserves-right-whisker-htpy-hom-sequential-diagram H h =
---     htpy-eq
---       ( ( ap
---           ( λ p →
---             htpy-eq
---               ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p) ∙h
---             preserves-comp-map-sequential-colimit-hom-sequential-diagram
---               up-a up-b c g h)
---           ( eq-htpy-right-whisker-htpy-hom-sequential-diagram H h)) ∙
---         ( inv [i]) ∙
---         ( ap htpy-eq
---           ( coh-comp-hom-sequential-diagram
---             ( eq-htpy-sequential-diagram B C f g H)
---             ( h))) ∙
---         ( htpy-eq-concat _ _) ∙
---         ( ap-binary
---           ( _∙h_)
---           ( is-section-eq-htpy
---             ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
---               up-a up-b c f h))
---            ( htpy-eq-right-whisker
---              ( ap
---                ( map-sequential-colimit-hom-sequential-diagram up-b c)
---                ( eq-htpy-sequential-diagram B C f g H))
---              ( map-sequential-colimit-hom-sequential-diagram up-a b h))))
---      where
---        open import foundation.action-on-identifications-binary-functions
---        [i] =
---          htpy-eq-concat
---            ( ap
---              ( map-sequential-colimit-hom-sequential-diagram up-a c)
---              ( ap
---                ( λ f → comp-hom-sequential-diagram A B C f h)
---                ( eq-htpy-sequential-diagram B C f g H)))
---            ( eq-htpy
---              ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
---                up-a up-b c g h)) ∙
---          ap
---            ( htpy-eq
---              ( ap
---                ( map-sequential-colimit-hom-sequential-diagram up-a c)
---                ( ap
---                  ( λ f → comp-hom-sequential-diagram A B C f h)
---                  ( eq-htpy-sequential-diagram B C f g H))) ∙h_)
---            ( is-section-eq-htpy
---              ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
---                up-a up-b c g h))
--- ```
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 l5 l6 : Level}
---   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
---   (up-a : universal-property-sequential-colimit a)
---   {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
---   (up-b : universal-property-sequential-colimit b)
---   {C : sequential-diagram l5} {Z : UU l6} (c : cocone-sequential-diagram C Z)
---   (h : hom-sequential-diagram B C)
---   {f g : hom-sequential-diagram A B}
---   where
-
---   coh-comp-hom-sequential-diagram' :
---     (p : f ＝ g) →
---     ap
---       ( map-sequential-colimit-hom-sequential-diagram up-a c)
---       ( ap (comp-hom-sequential-diagram A B C h) p) ∙
---     eq-htpy
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g) ＝
---     eq-htpy
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙
---     ap
---       ( map-sequential-colimit-hom-sequential-diagram up-b c h ∘_)
---       ( ap
---         ( map-sequential-colimit-hom-sequential-diagram up-a b)
---         ( p))
---   coh-comp-hom-sequential-diagram' refl = inv right-unit
-
---   preserves-left-whisker-htpy-hom-sequential-diagram :
---     (H : htpy-hom-sequential-diagram B f g) →
---     ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a c
---         ( left-whisker-concat-htpy-hom-sequential-diagram h H)) ∙h
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h g)) ~
---     ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b c h f) ∙h
---       ( map-sequential-colimit-hom-sequential-diagram up-b c h ·l
---         htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H))
---   preserves-left-whisker-htpy-hom-sequential-diagram H =
---     htpy-eq
---       ( ap-binary
---           ( λ p q →
---             htpy-eq
---               ( ap (map-sequential-colimit-hom-sequential-diagram up-a c) p) ∙h
---             q)
---           ( eq-htpy-left-whisker-htpy-hom-sequential-diagram h H)
---           ( inv
---             ( is-section-eq-htpy
---               ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
---                 up-a up-b c h g))) ∙
---         inv
---           ( htpy-eq-concat
---             ( ap
---               ( map-sequential-colimit-hom-sequential-diagram up-a c)
---               ( ap
---                 ( comp-hom-sequential-diagram A B C h)
---                 ( eq-htpy-sequential-diagram A B f g H)))
---             ( eq-htpy
---               ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
---                 up-a up-b c h g))) ∙
---         ap htpy-eq
---           ( coh-comp-hom-sequential-diagram'
---             ( eq-htpy-sequential-diagram A B f g H)) ∙
---         htpy-eq-concat _ _ ∙
---         ap-binary _∙h_
---           ( is-section-eq-htpy
---             ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
---               up-a up-b c h f))
---           ( htpy-eq-left-whisker
---             ( map-sequential-colimit-hom-sequential-diagram up-b c h)
---             ( ap
---               ( map-sequential-colimit-hom-sequential-diagram up-a b)
---               ( eq-htpy-sequential-diagram A B f g H))))
---      where
---        open import foundation.action-on-identifications-binary-functions
--- ```
-
--- ## Action on homotopies of morphisms of sequential diagrams preserves concatenation
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 : Level}
---   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
---   (up-a : universal-property-sequential-colimit a)
---   {B : sequential-diagram l3} {Y : UU l4} (b : cocone-sequential-diagram B Y)
---   {f g h : hom-sequential-diagram A B}
---   (H : htpy-hom-sequential-diagram B f g)
---   (K : htpy-hom-sequential-diagram B g h)
---   where
-
---   preserves-concat-htpy-hom-sequential-diagram :
---     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b
---       ( concat-htpy-hom-sequential-diagram f g h H K) ~
---     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b H ∙h
---     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a b K
---   preserves-concat-htpy-hom-sequential-diagram =
---     htpy-eq
---       ( ( ap
---           ( λ p →
---             htpy-eq
---               ( ap
---                 ( map-sequential-colimit-hom-sequential-diagram up-a b)
---                 ( p)))
---           ( eq-htpy-concat-hom-sequential-diagram f g h H K)) ∙
---         ( ap htpy-eq
---           ( ap-concat
---             ( map-sequential-colimit-hom-sequential-diagram up-a b)
---             ( eq-htpy-sequential-diagram A B f g H)
---             ( eq-htpy-sequential-diagram A B g h K))) ∙
---         ( htpy-eq-concat
---           ( ap
---             ( map-sequential-colimit-hom-sequential-diagram up-a b)
---             ( eq-htpy-sequential-diagram A B f g H))
---           ( ap
---             ( map-sequential-colimit-hom-sequential-diagram up-a b)
---             ( eq-htpy-sequential-diagram A B g h K))))
--- ```
-
--- ## Action on homotopies of morphisms of sequential diagrams preserves associativity
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 l5 l6 l7 l8 : Level}
---   {A : sequential-diagram l1} {X : UU l2} {a : cocone-sequential-diagram A X}
---   (up-a : universal-property-sequential-colimit a)
---   {B : sequential-diagram l3} {Y : UU l4} {b : cocone-sequential-diagram B Y}
---   (up-b : universal-property-sequential-colimit b)
---   {C : sequential-diagram l5} {Z : UU l6} {c : cocone-sequential-diagram C Z}
---   (up-c : universal-property-sequential-colimit c)
---   {D : sequential-diagram l7} {V : UU l8} (d : cocone-sequential-diagram D V)
---   (f : hom-sequential-diagram A B) (g : hom-sequential-diagram B C)
---   (h : hom-sequential-diagram C D)
---   where
-
---   coh-assoc-comp-hom-sequential-diagram :
---     {!!}
---   coh-assoc-comp-hom-sequential-diagram = {!!}
-
---   preserves-assoc-comp-hom-sequential-diagram :
---     ( ( htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-a d
---         ( assoc-comp-hom-sequential-diagram f g h)) ∙h
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-c d h
---         ( comp-hom-sequential-diagram A B C g f)) ∙h
---       ( map-sequential-colimit-hom-sequential-diagram up-c d h ·l
---         preserves-comp-map-sequential-colimit-hom-sequential-diagram
---           up-a up-b c g f)) ~
---     ( ( preserves-comp-map-sequential-colimit-hom-sequential-diagram up-a up-b d
---         ( comp-hom-sequential-diagram B C D h g)
---         ( f)) ∙h
---       ( preserves-comp-map-sequential-colimit-hom-sequential-diagram
---           up-b up-c d h g ·r
---         map-sequential-colimit-hom-sequential-diagram up-a b f))
---   preserves-assoc-comp-hom-sequential-diagram =
---     {!!}
--- ```
-
--- ```agda
--- nat-lemma :
---   {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2}
---   {P : A → UU l3} {Q : B → UU l4}
---   (f : A → B) (h : (a : A) → P a → Q (f a))
---   {x y : A} {p : x ＝ y}
---   {q : f x ＝ f y} (α : ap f p ＝ q) →
---   coherence-square-maps
---     ( tr P p)
---     ( h x)
---     ( h y)
---     ( tr Q q)
--- nat-lemma f h {p = p} refl x =
---   substitution-law-tr _ f p ∙ inv (preserves-tr h p x)
--- ```
-
--- ##
-
--- ```agda
--- open import synthetic-homotopy-theory.families-descent-data-sequential-colimits
--- open import synthetic-homotopy-theory.total-cocones-families-sequential-diagrams
--- open import synthetic-homotopy-theory.total-sequential-diagrams
-
--- open import foundation.action-on-identifications-functions
--- open import foundation.commuting-squares-of-identifications
--- open import foundation.functoriality-dependent-pair-types
--- open import foundation.equality-dependent-pair-types
--- open import foundation.identity-types
--- open import synthetic-homotopy-theory.sequential-colimits
--- open import synthetic-homotopy-theory.functoriality-sequential-colimits
--- module _
---   {l1 l2 l3 l4 : Level}
---   {A : sequential-diagram l1}
---   {X : UU l2} {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   (P : family-with-descent-data-sequential-colimit c l3)
---   {Y : UU l4}
---   {c' :
---     cocone-sequential-diagram
---       ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
---       ( Y)}
---   (up-c' : universal-property-sequential-colimit c')
---   where
-
---   mediating-cocone :
---     cocone-sequential-diagram
---       ( total-sequential-diagram-family-with-descent-data-sequential-colimit P)
---       ( Σ X (family-cocone-family-with-descent-data-sequential-colimit P))
---   pr1 mediating-cocone n =
---     map-Σ
---       ( family-cocone-family-with-descent-data-sequential-colimit P)
---       ( map-cocone-sequential-diagram c n)
---       ( λ a → map-equiv-descent-data-family-with-descent-data-sequential-colimit P n a)
---   pr2 mediating-cocone n (a , p) =
---     eq-pair-Σ
---       ( coherence-cocone-sequential-diagram c n a)
---       ( inv
---         ( coherence-square-equiv-descent-data-family-with-descent-data-sequential-colimit P n a p))
-
---   totι' : Y → Σ X (family-cocone-family-with-descent-data-sequential-colimit P)
---   totι' =
---     map-universal-property-sequential-colimit up-c' mediating-cocone
---   triangle-pr1∞-pr1 :
---     pr1-sequential-colimit-total-sequential-diagram
---       ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)
---       ( up-c')
---       ( c) ~
---     pr1 ∘ totι'
---   triangle-pr1∞-pr1 =
---     htpy-htpy-out-of-sequential-colimit up-c'
---       ( concat-htpy-cocone-sequential-diagram
---         ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c' c
---           ( pr1-total-sequential-diagram
---             ( dependent-sequential-diagram-family-with-descent-data-sequential-colimit P)))
---         ( ( λ n →
---             inv-htpy (pr1 ·l (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n))) ,
---           ( λ n x →
---             ap (_∙ inv (ap pr1 (pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))) right-unit ∙
---             horizontal-inv-coherence-square-identifications _
---               ( ap (pr1 ∘ totι') (coherence-cocone-sequential-diagram c' n x))
---               ( coherence-cocone-sequential-diagram c n (pr1 x))
---               _
---               ( ( ap
---                   ( _∙ ap pr1
---                     ( pr1 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) (succ-ℕ n) _))
---                   ( ap-comp pr1
---                     ( totι')
---                     ( coherence-cocone-sequential-diagram c' n x))) ∙
---                 ( inv
---                   ( ap-concat pr1
---                     ( ap
---                       ( totι')
---                       ( coherence-cocone-sequential-diagram c' n x)) _)) ∙
---                 ( ap (ap pr1) (pr2 (htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone) n x)) ∙
---                 ( ap-concat pr1
---                   ( pr1
---                     ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
---                     n x)
---                   ( coherence-cocone-sequential-diagram mediating-cocone n x)) ∙
---                 ( ap
---                   ( ap pr1
---                     ( pr1
---                       ( htpy-cocone-universal-property-sequential-colimit up-c' mediating-cocone)
---                       n x) ∙_)
---                   ( ap-pr1-eq-pair-Σ
---                     ( coherence-cocone-sequential-diagram c n (pr1 x))
---                     ( _)))))))
--- ```
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 l5 l6 : Level}
---   {A : sequential-diagram l1} {X : UU l2}
---   {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   {B : sequential-diagram l3} {Y : UU l4}
---   {c' : cocone-sequential-diagram B Y}
---   (up-c' : universal-property-sequential-colimit c')
---   (P : X → UU l5) (Q : Y → UU l6)
---   (f : hom-sequential-diagram A B)
---   (f' :
---     (x : X) → P x →
---     Q (map-sequential-colimit-hom-sequential-diagram up-c c' f x))
---   where
-
---   open import synthetic-homotopy-theory.flattening-lemma-sequential-colimits
-
---   ΣAP : sequential-diagram (l1 ⊔ l5)
---   ΣAP =
---     total-sequential-diagram (dependent-sequential-diagram-family-cocone c P)
-
---   ΣBQ : sequential-diagram (l3 ⊔ l6)
---   ΣBQ =
---     total-sequential-diagram (dependent-sequential-diagram-family-cocone c' Q)
-
---   private
---     finf : X → Y
---     finf = (map-sequential-colimit-hom-sequential-diagram up-c c' f)
-
---   totff' : hom-sequential-diagram ΣAP ΣBQ
---   pr1 totff' n =
---     map-Σ _
---       ( map-hom-sequential-diagram B f n)
---       ( λ a →
---         tr Q
---           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---             up-c c' f n a) ∘
---         f' (map-cocone-sequential-diagram c n a))
---   pr2 totff' n (a , p) =
---     eq-pair-Σ
---       ( naturality-map-hom-sequential-diagram B f n a)
---       ((pasting-vertical-coherence-square-maps
---       ( tr P (coherence-cocone-sequential-diagram c n a))
---       ( f' _)
---       ( f' _)
---       ( tr Q (ap finf (coherence-cocone-sequential-diagram c n a)))
---       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
---       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
---       ( ( tr
---           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---           ( naturality-map-hom-sequential-diagram B f n a)) ∘
---         ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
---       ( λ q →
---         substitution-law-tr Q finf (coherence-cocone-sequential-diagram c n a) ∙
---         inv (preserves-tr f' (coherence-cocone-sequential-diagram c n a) q))
---       ( ( inv-htpy
---           ( λ q →
---             ( tr-concat
---               ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                 up-c c' f n a)
---               ( _)
---               ( q)) ∙
---             ( tr-concat
---               ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
---               ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
---               ( tr Q
---                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                   up-c c' f n a)
---                 ( q))) ∙
---             ( substitution-law-tr Q
---               ( map-cocone-sequential-diagram c' (succ-ℕ n))
---               ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
---         ( λ q →
---           ap
---             ( λ p → tr Q p q)
---             ( inv
---               ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
---         ( tr-concat
---           ( ap finf (coherence-cocone-sequential-diagram c n a))
---           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---             up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))) p)
-
-
---   totff'∞ : Σ X P → Σ Y Q
---   totff'∞ =
---     map-sequential-colimit-hom-sequential-diagram
---       ( flattening-lemma-sequential-colimit _ P up-c)
---       ( total-cocone-family-cocone-sequential-diagram c' Q)
---       ( totff')
-
---   pr1A∙ : hom-sequential-diagram ΣAP A
---   pr1A∙ =
---     pr1-total-sequential-diagram
---       ( dependent-sequential-diagram-family-cocone c P)
---   pr1B∙ : hom-sequential-diagram ΣBQ B
---   pr1B∙ =
---     pr1-total-sequential-diagram
---       ( dependent-sequential-diagram-family-cocone c' Q)
-
---   pr1∘totff' : hom-sequential-diagram ΣAP B
---   pr1∘totff' = comp-hom-sequential-diagram ΣAP ΣBQ B pr1B∙ totff'
---   f∘pr1 : hom-sequential-diagram ΣAP B
---   f∘pr1 = comp-hom-sequential-diagram ΣAP A B f pr1A∙
-
---   pr1coh∙ : htpy-hom-sequential-diagram B f∘pr1 pr1∘totff'
---   pr1 pr1coh∙ n =
---     refl-htpy
---   pr2 pr1coh∙ n =
---     right-unit-htpy ∙h
---     right-unit-htpy ∙h
---     ( λ x →
---       inv
---         ( ap-pr1-eq-pair-Σ
---           ( naturality-map-hom-sequential-diagram B f n (pr1 x))
---           ( _)))
-
---   module _
---     (sA :
---       section-descent-data-sequential-colimit
---         ( descent-data-family-cocone-sequential-diagram c P))
---     (sB :
---       section-descent-data-sequential-colimit
---         ( descent-data-family-cocone-sequential-diagram c' Q))
---     where
---     open import foundation.sections
-
---     -- vertical maps, the "sides" of the cubes
---     sA∙ : hom-sequential-diagram A ΣAP
---     pr1 sA∙ n = map-section-family (pr1 sA n)
---     pr2 sA∙ n a = eq-pair-eq-fiber (pr2 sA n a)
---     sB∙ : hom-sequential-diagram B ΣBQ
---     pr1 sB∙ n = map-section-family (pr1 sB n)
---     pr2 sB∙ n b = eq-pair-eq-fiber (pr2 sB n b)
---     totff'∘sA∙ : hom-sequential-diagram A ΣBQ
---     totff'∘sA∙ = comp-hom-sequential-diagram A ΣAP ΣBQ totff' sA∙
---     sB∙∘f : hom-sequential-diagram A ΣBQ
---     sB∙∘f = comp-hom-sequential-diagram A B ΣBQ sB∙ f
---     -- the unaligned cubes
---     H∙ :
---       htpy-hom-sequential-diagram ΣBQ totff'∘sA∙ sB∙∘f
---     pr1 H∙ n a = eq-pair-eq-fiber {!!}
---     pr2 H∙ = {!!}
-
---     pr1∙∘sA∙ : hom-sequential-diagram A A
---     pr1∙∘sA∙ = comp-hom-sequential-diagram A ΣAP A pr1A∙ sA∙
-
---     idA∙ : hom-sequential-diagram A A
---     idA∙ = id-hom-sequential-diagram A
---     idB∙ : hom-sequential-diagram B B
---     idB∙ = id-hom-sequential-diagram B
---     f∘idA∙ : hom-sequential-diagram A B
---     f∘idA∙ = comp-hom-sequential-diagram A A B f idA∙
---     idB∙∘f : hom-sequential-diagram A B
---     idB∙∘f = comp-hom-sequential-diagram A B B idB∙ f
---     refl∙ : htpy-hom-sequential-diagram B f∘idA∙ idB∙∘f
---     pr1 refl∙ = ev-pair refl-htpy
---     pr2 refl∙ n a =
---       right-unit ∙
---       right-unit ∙
---       inv (ap-id (naturality-map-hom-sequential-diagram B f n a))
---     -- the alignment: postcomposing H∙ with pr1coh∙ is homotopic with id
---     ℋ :
---       {!htpy²-hom-sequential-diagram!}
---     ℋ = {!!}
-
---   _ :
---     totι' up-c
---       ( family-with-descent-data-family-cocone-sequential-diagram c P)
---       ( flattening-lemma-sequential-colimit c P up-c) ~
---     id
---   _ =
---     compute-map-universal-property-sequential-colimit-id
---       ( flattening-lemma-sequential-colimit _ P up-c)
-
---   _ :
---     coherence-square-maps
---       ( totι' up-c
---         ( family-with-descent-data-family-cocone-sequential-diagram c P)
---         ( flattening-lemma-sequential-colimit c P up-c))
---       ( totff'∞)
---       ( map-Σ Q
---         ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---         f')
---       ( totι' up-c'
---         ( family-with-descent-data-family-cocone-sequential-diagram c' Q)
---         ( flattening-lemma-sequential-colimit c' Q up-c'))
---   _ =
---     ( compute-map-universal-property-sequential-colimit-id
---       ( flattening-lemma-sequential-colimit c' Q up-c') ·r _) ∙h
---     ( htpy-htpy-out-of-sequential-colimit
---       ( flattening-lemma-sequential-colimit c P up-c)
---       ( concat-htpy-cocone-sequential-diagram
---         ( htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---           ( flattening-lemma-sequential-colimit c P up-c)
---           ( total-cocone-family-cocone-sequential-diagram c' Q)
---           ( totff'))
---         ( ( λ n (a , p) →
---             inv
---               ( eq-pair-Σ
---                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c'
---                   ( f)
---                   ( n)
---                   ( a))
---                 refl)) ,
---           {!!}))) ∙h
---     ( _ ·l
---       ( inv-htpy
---         (compute-map-universal-property-sequential-colimit-id
---           ( flattening-lemma-sequential-colimit c P up-c))))
-
---     -- htpy-htpy-out-of-sequential-colimit
---     --   ( flattening-lemma-sequential-colimit c P up-c)
---     --   ( {!!})
--- ```
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 : Level}
---   {A : sequential-diagram l1} {X : UU l2}
---   {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   {B : sequential-diagram l3} {Y : UU l4}
---   {c' : cocone-sequential-diagram B Y}
---   (up-c' : universal-property-sequential-colimit c')
---   (f : hom-sequential-diagram A B)
---   where
---   open import foundation.homotopies-morphisms-arrows
-
---   interm :
---     coherence-square-maps
---       ( id)
---       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---       ( id)
---   interm =
---     htpy-map-sequential-colimit-htpy-hom-sequential-diagram up-c c'
---       ( refl-htpy-hom-sequential-diagram A B f)
-
---   preserves-refl-htpy-sequential-colimit :
---     htpy-hom-arrow
---       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---       ( map-sequential-colimit-hom-sequential-diagram up-c c' f)
---       ( id , id , interm)
---       ( id , id , refl-htpy)
---   pr1 preserves-refl-htpy-sequential-colimit = refl-htpy
---   pr1 (pr2 preserves-refl-htpy-sequential-colimit) = refl-htpy
---   pr2 (pr2 preserves-refl-htpy-sequential-colimit) =
---     right-unit-htpy ∙h
---     htpy-eq
---       ( ap
---         ( htpy-eq ∘ ap (map-sequential-colimit-hom-sequential-diagram up-c c'))
---         ( is-retraction-map-inv-equiv
---           ( extensionality-hom-sequential-diagram A B f f)
---           ( refl)))
--- ```
-
--- ```agda
--- module _
---   {l1 l2 l3 l4 : Level}
---   {A : sequential-diagram l1}
---   (B : sequential-diagram l2)
---   (f : hom-sequential-diagram A B)
---   (P : descent-data-sequential-colimit A l3)
---   (Q : descent-data-sequential-colimit B l4)
---   where
-
---   hom-over-hom : UU (l1 ⊔ l3 ⊔ l4)
---   hom-over-hom =
---     Σ ( (n : ℕ) (a : family-sequential-diagram A n) →
---         family-descent-data-sequential-colimit P n a →
---         family-descent-data-sequential-colimit Q n
---           ( map-hom-sequential-diagram B f n a))
---       ( λ f'n →
---         (n : ℕ) →
---         square-over
---           { Q4 = family-descent-data-sequential-colimit Q (succ-ℕ n)}
---           ( map-sequential-diagram A n)
---           ( map-hom-sequential-diagram B f n)
---           ( map-hom-sequential-diagram B f (succ-ℕ n))
---           ( map-sequential-diagram B n)
---           ( λ {a} → map-family-descent-data-sequential-colimit P n a)
---           ( λ {a} → f'n n a)
---           ( λ {a} → f'n (succ-ℕ n) a)
---           ( λ {a} → map-family-descent-data-sequential-colimit Q n a)
---           ( naturality-map-hom-sequential-diagram B f n))
--- module _
---   {l1 l2 l3 l4 l5 l6 : Level}
---   {A : sequential-diagram l1} {X : UU l2}
---   {c : cocone-sequential-diagram A X}
---   (up-c : universal-property-sequential-colimit c)
---   {B : sequential-diagram l3} {Y : UU l4}
---   {c' : cocone-sequential-diagram B Y}
---   (up-c' : universal-property-sequential-colimit c')
---   (f : hom-sequential-diagram A B)
---   (P : X → UU l5) (Q : Y → UU l6)
---   where
-
---   private
---     f∞ : X → Y
---     f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f
---     DDMO : descent-data-sequential-colimit A (l5 ⊔ l6)
---     pr1 DDMO n a =
---       P (map-cocone-sequential-diagram c n a) →
---       Q (map-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
---     pr2 DDMO n a =
---       ( equiv-postcomp _
---         ( ( equiv-tr
---             ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---             ( naturality-map-hom-sequential-diagram B f n a)) ∘e
---           ( equiv-tr Q (coherence-cocone-sequential-diagram c' n _)))) ∘e
---       ( equiv-precomp
---         ( inv-equiv (equiv-tr P (coherence-cocone-sequential-diagram c n a)))
---         ( _))
-
---   sect-over-DDMO-map-over :
---     ((a : X) → P a → Q (f∞ a)) →
---     section-descent-data-sequential-colimit DDMO
---   pr1 (sect-over-DDMO-map-over f∞') n a =
---     ( tr Q
---       ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
---     ( f∞' (map-cocone-sequential-diagram c n a))
---   pr2 (sect-over-DDMO-map-over f∞') n a =
---     eq-htpy
---       ( λ p →
---         {!coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a!})
-
---   sect-over-DDMO-map-over' :
---     ((a : X) → P a → Q (f∞ a)) →
---     section-descent-data-sequential-colimit DDMO
---   sect-over-DDMO-map-over' =
---     {!sect-family-sect-dd-sequential-colimit!}
-
---   map-over-sect-DDMO :
---     section-descent-data-sequential-colimit DDMO →
---     hom-over-hom B f
---       ( descent-data-family-cocone-sequential-diagram c P)
---       ( descent-data-family-cocone-sequential-diagram c' Q)
---   map-over-sect-DDMO =
---     tot
---       ( λ s →
---         map-Π
---           ( λ n →
---             ( map-implicit-Π
---               ( λ a →
---                 ( concat-htpy
---                   ( inv-htpy
---                     ( ( ( tr
---                           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---                           ( naturality-map-hom-sequential-diagram B f n a)) ∘
---                         ( tr Q
---                           ( coherence-cocone-sequential-diagram c' n
---                             (map-hom-sequential-diagram B f n a))) ∘
---                         ( s n a)) ·l
---                       ( is-retraction-inv-tr P
---                         ( coherence-cocone-sequential-diagram c n a))))
---                   ( _)) ∘
---                 ( map-equiv
---                   ( equiv-htpy-precomp-htpy-Π _ _
---                     ( equiv-tr P
---                       ( coherence-cocone-sequential-diagram c n a)))) ∘
---                 ( htpy-eq
---                   {f =
---                     ( tr
---                       ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---                       ( naturality-map-hom-sequential-diagram B f n a)) ∘
---                     ( tr Q
---                       ( coherence-cocone-sequential-diagram c' n
---                         ( map-hom-sequential-diagram B f n a))) ∘
---                     ( s n a) ∘
---                     ( tr P (inv (coherence-cocone-sequential-diagram c n a)))}
---                   { s (succ-ℕ n) (map-sequential-diagram A n a)}))) ∘
---             ( implicit-explicit-Π)))
-
---   map-over-diagram-map-over-colimit :
---     ((a : X) → P a → Q (f∞ a)) →
---     hom-over-hom B f
---       ( descent-data-family-cocone-sequential-diagram c P)
---       ( descent-data-family-cocone-sequential-diagram c' Q)
---   pr1 (map-over-diagram-map-over-colimit f∞') n a =
---     ( tr Q
---       ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a)) ∘
---     ( f∞' (map-cocone-sequential-diagram c n a))
---   pr2 (map-over-diagram-map-over-colimit f∞') n {a} =
---     pasting-vertical-coherence-square-maps
---       ( tr P (coherence-cocone-sequential-diagram c n a))
---       ( f∞' _)
---       ( f∞' _)
---       ( tr Q (ap f∞ (coherence-cocone-sequential-diagram c n a)))
---       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ a))
---       ( tr Q (htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f _ (map-sequential-diagram A n a)))
---       ( ( tr
---           ( Q ∘ map-cocone-sequential-diagram c' (succ-ℕ n))
---           ( naturality-map-hom-sequential-diagram B f n a)) ∘
---         ( tr Q (coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))))
---       ( λ q →
---         substitution-law-tr Q f∞ (coherence-cocone-sequential-diagram c n a) ∙
---         inv (preserves-tr f∞' (coherence-cocone-sequential-diagram c n a) q))
---       ( ( inv-htpy
---           ( λ q →
---             ( tr-concat
---               ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                 up-c c' f n a)
---               ( _)
---               ( q)) ∙
---             ( tr-concat
---               ( coherence-cocone-sequential-diagram c' n (map-hom-sequential-diagram B f n a))
---               ( ap (map-cocone-sequential-diagram c' (succ-ℕ n)) (naturality-map-hom-sequential-diagram B f n a))
---               ( tr Q
---                 ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---                   up-c c' f n a)
---                 ( q))) ∙
---             ( substitution-law-tr Q
---               ( map-cocone-sequential-diagram c' (succ-ℕ n))
---               ( naturality-map-hom-sequential-diagram B f n a)))) ∙h
---         ( λ q →
---           ap
---             ( λ p → tr Q p q)
---             ( inv
---               ( coherence-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f n a))) ∙h
---         ( tr-concat
---           ( ap f∞ (coherence-cocone-sequential-diagram c n a))
---           ( htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram
---             up-c c' f (succ-ℕ n) (map-sequential-diagram A n a))))
-
---   abstract
---     triangle-map-over-sect-DDMO :
---       coherence-triangle-maps
---         ( map-over-diagram-map-over-colimit)
---         ( map-over-sect-DDMO)
---         ( sect-over-DDMO-map-over)
---     triangle-map-over-sect-DDMO f∞' =
---       eq-pair-eq-fiber
---         ( eq-htpy
---           ( λ n →
---             eq-htpy-implicit
---               ( λ a →
---                 eq-htpy
---                   ( λ p →
---                     {!!}))))
-
---     is-equiv-map-over-sect-DDMO :
---       is-equiv map-over-sect-DDMO
---     is-equiv-map-over-sect-DDMO =
---       is-equiv-tot-is-fiberwise-equiv
---         ( λ s →
---           is-equiv-map-Π-is-fiberwise-equiv
---             ( λ n →
---               is-equiv-comp _ _
---                 ( is-equiv-implicit-explicit-Π)
---                 ( is-equiv-map-implicit-Π-is-fiberwise-equiv
---                   ( λ a →
---                     is-equiv-comp _ _
---                       ( funext _ _)
---                       ( is-equiv-comp _ _
---                         ( is-equiv-map-equiv (equiv-htpy-precomp-htpy-Π _ _ _))
---                         ( is-equiv-concat-htpy _ _))))))
-
---     is-equiv-map-over-diagram-map-over-colimit :
---       is-equiv map-over-diagram-map-over-colimit
---     is-equiv-map-over-diagram-map-over-colimit =
---       {!is-equiv-left-map-triangle
---         ( map-over-diagram-map-over-colimit)
---         ( map-over-sect-DDMO)
---         ( sect-over-DDMO-map-over)
---         ( triangle-map-over-sect-DDMO)
---         ( is-equiv) !}
--- ```
-
-NB: apd sB∞ (Cn n a) ≠ apd sB∞ (κ n a)!!!
-
-```agda
-module _
-  {l1 l2 : Level} {A : UU l1} {B : UU l2}
-  (e : A ≃ B)
-  where
-
-  unap-square' :
-    {x y : A} (p : x ＝ y) →
-    (is-retraction-map-inv-equiv e x) ∙ map-equiv (inv-equiv-ap-emb (emb-equiv e)) (ap (map-equiv e) p) ＝
-    ap (map-inv-equiv e) (ap (map-equiv e) p) ∙ is-retraction-map-inv-equiv e y
-  unap-square' {x} {y} p =
-    ap
-      ( is-retraction-map-inv-equiv e x ∙_)
-      ( is-retraction-map-inv-equiv (equiv-ap e x y) p ∙ inv (ap-id p)) ∙
-    nat-htpy
-      ( is-retraction-map-inv-equiv e)
-      ( p) ∙
-    ap
-      ( _∙ is-retraction-map-inv-equiv e y)
-      ( ap-comp (map-inv-equiv e) (map-equiv e) p)
-
-  unap-square :
-    {x y : A} (p : map-equiv e x ＝ map-equiv e y) →
-    is-retraction-map-inv-equiv e x ∙ map-equiv (inv-equiv-ap-emb (emb-equiv e)) p ＝
-    ap (map-inv-equiv e) p ∙ is-retraction-map-inv-equiv e y
-  unap-square {x} {y} p =
-    ap
-      ( λ p →
-        is-retraction-map-inv-equiv e x ∙
-        map-equiv (inv-equiv-ap-emb (emb-equiv e)) p)
-      ( inv (is-section-map-inv-equiv (equiv-ap e x y) p)) ∙
-    unap-square'
-      ( map-equiv (inv-equiv-ap-emb (emb-equiv e)) p) ∙
-    ap
-      ( λ p →
-        ap (map-inv-equiv e) p ∙
-        is-retraction-map-inv-equiv e y)
-      ( is-section-map-inv-equiv (equiv-ap e x y) p)
-```

From 43f1beb3a8bd5a07309b08f4a9088a7bef85199f Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Tue, 25 Mar 2025 18:08:45 +0100
Subject: [PATCH 32/33] =?UTF-8?q?Path=20induction=20=F0=9F=AA=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../functoriality-stuff.lagda.md              | 1107 ++---------------
 1 file changed, 109 insertions(+), 998 deletions(-)

diff --git a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
index 362cc80091..d4d462cd77 100644
--- a/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
+++ b/src/synthetic-homotopy-theory/functoriality-stuff.lagda.md
@@ -599,92 +599,6 @@ module _
       ( apd H p)
 ```
 
-```agda
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : UU l2}
-  {P : A → UU l3} {Q : B → UU l4}
-  (f : A → B) (sA : (a : A) → P a) (sB : (b : B) → Q b)
-  (f' : {a : A} → P a → Q (f a))
-  where
-
-  convenient-square : UU (l1 ⊔ l4)
-  convenient-square = sB ∘ f ~ f' ∘ sA
-
-  convenient-square' : UU (l1 ⊔ l4)
-  convenient-square' = f' ∘ sA ~ sB ∘ f
-
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4}
-  {P : C → UU l5} {Q : D → UU l6}
-  (f : A → B) (hA : A → C) (hB : B → D) (g : C → D)
-  (sA : (c : C) → P c) (sB : (d : D) → Q d) (f' : {c : C} → P c → Q (g c))
-  where
-
-  pasting-squares :
-    (H : coherence-square-maps hA f g hB) →
-    convenient-square g sA sB f' →
-    (a : A) → tr Q (H a) (sB (hB (f a))) ＝ f' (sA (hA a))
-  pasting-squares H K a =
-    apd sB (H a) ∙ K (hA a)
-
-  pasting-squares' :
-    (H : coherence-square-maps' hA f g hB) →
-    convenient-square' g sA sB f' →
-    (a : A) → tr Q (H a) (f' (sA (hA a))) ＝ sB (hB (f a))
-  pasting-squares' H K a =
-    ap (tr Q (H a)) (K (hA a)) ∙ apd sB (H a)
-```
-
-```agda
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3}
-  {A' : UU l4} {B' : UU l5} {C' : UU l6}
-  (f : A → C) (g : B → C) (h : A → B)
-  (f' : A' → C') (g' : B' → C') (h' : A' → B')
-  (hA : A → A') (hB : B → B') (hC : C → C')
-  (left : hC ∘ f ~ f' ∘ hA)
-  (right : hC ∘ g ~ g' ∘ hB)
-  (back : h' ∘ hA ~ hB ∘ h)
-  (bottom : f ~ g ∘ h)
-  (top : f' ~ g' ∘ h')
-  where
-
-  convenient-prism : UU (l1 ⊔ l6)
-  convenient-prism =
-    left ∙h (top ·r hA) ∙h (g' ·l back) ~
-    (hC ·l bottom) ∙h (right ·r h)
-```
-
-```agda
-module _
-  {l1 l2 l3 l4 l5 l6 : Level}
-  {A : UU l1} {B : UU l2} {C : UU l3}
-  {P : A → UU l4} {Q : B → UU l5} {R : C → UU l6}
-  (f : A → C) (g : B → C) (h : A → B)
-  (f' : {a : A} → P a → R (f a))
-  (g' : {b : B} → Q b → R (g b))
-  (h' : {a : A} → P a → Q (h a))
-  (sA : (a : A) → P a) (sB : (b : B) → Q b) (sC : (c : C) → R c)
-  (left : sC ∘ f ~ f' ∘ sA)
-  (right : sC ∘ g ~ g' ∘ sB)
-  (back : h' ∘ sA ~ sB ∘ h)
-  (bottom : f ~ g ∘ h)
-  (top : htpy-over R bottom f' (g' ∘ h'))
-  where
-
-  fiberwise-prism : UU (l1 ⊔ l6)
-  fiberwise-prism =
-    (a : A) →
-    ( ap (tr R (bottom a)) (left a) ∙
-      top (sA a) ∙
-      ap g' (back a)) ＝
-    ( apd sC (bottom a) ∙
-      right (h a))
-```
-
 TODO: this should be parameterized by a fiberwise map, not equivalence
 
 ```agda
@@ -843,91 +757,6 @@ module _
 ```
 
 ```agda
-module _
-  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
-  where
-  open import foundation.dependent-identifications
-
-  compute-inv-dependent-identification-inv :
-    {x y : A} (p : x ＝ y) {x' : B x} {y' : B y}
-    (q : y' ＝ tr B p x') →
-    inv-dependent-identification B p (inv q) ＝
-    map-eq-transpose-equiv-inv' (equiv-tr B p) q
-  compute-inv-dependent-identification-inv refl q = inv-inv q ∙ inv (right-unit ∙ ap-id q)
-
-module _
-  {l1 l2 : Level} {A : UU l1} {B : UU l2}
-  (e : A ≃ B)
-  where
-
-  compute-eq-transpose-equiv-inv-concat' :
-    {x : A} {b c : B} (p : b ＝ c) (q : c ＝ map-equiv e x) →
-    map-eq-transpose-equiv-inv' e (p ∙ q) ＝
-    ap (map-inv-equiv e) p ∙ map-eq-transpose-equiv-inv' e q
-  compute-eq-transpose-equiv-inv-concat' refl q = refl
-```
-
-```agda
-module _
-  {l1 l2 l3 l4 : Level} {A : UU l1} {B : A → UU l2} {X : UU l3} {Y : X → UU l4}
-  where
-  open import foundation.dependent-identifications
-
-  compute-left-whisk-dependent-identification-concat :
-    {s : X → A} (s' : (x : X) → Y x → B (s x)) →
-    {x y : X} (p : x ＝ y) →
-    {x' : Y x} {y' z' : Y y} (p' : dependent-identification Y p x' y') →
-    (q : y' ＝ z') →
-    left-whisk-dependent-identification {B' = B} (s' _) p (p' ∙ q) ＝
-    left-whisk-dependent-identification (s' _) p p' ∙ ap (s' y) q
-  compute-left-whisk-dependent-identification-concat s' refl p' q =
-    ap-concat (s' _) p' q
-
-  compute-left-whisk-dependent-identification-concat' :
-    {s : X → A} (s' : (x : X) → Y x → B (s x)) →
-    {x y : X} (p : x ＝ y) →
-    {x' w' : Y x} {y' : Y y} (p' : x' ＝ w') →
-    (q' : dependent-identification Y p w' y') →
-    left-whisk-dependent-identification {B' = B} (s' _) p (ap (tr Y p) p' ∙ q') ＝
-    ap (tr B (ap s p)) (ap (s' x) p') ∙
-    left-whisk-dependent-identification {B' = B} (s' _) p q'
-  compute-left-whisk-dependent-identification-concat' s' refl refl q' = refl
-```
-
-```agda
-module _
-  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
-  where
-  open import foundation.dependent-identifications
-
-  compute-right-concat-dependent-identification :
-    {x y : A} (p : x ＝ y)
-    {z : A} (q : y ＝ z)
-    {x' : B x} {y' : B y} (p' : dependent-identification B p x' y')
-    {z' : B z} (q' : dependent-identification B q y' z')
-    {w' : B z} (r : z' ＝ w') →
-    concat-dependent-identification B p q p' (q' ∙ r) ＝
-    concat-dependent-identification B p q p' q' ∙ r
-  compute-right-concat-dependent-identification refl q refl q' r = refl
-```
-
-```agda
-module _
-  {l1 l2 l3 l4 : Level} {I : UU l1} {A : I → UU l2} {J : UU l3} {B : J → UU l4}
-  {s : I → J} (s' : (i : I) → A i → B (s i))
-  where
-
-  concat-preserves-tr-left-whisk :
-    {i j : I} (p : i ＝ j) {x : A i} →
-    ap
-      ( tr B (ap s (inv p)))
-      ( inv (preserves-tr s' p x)) ∙
-    left-whisk-dependent-identification {B' = B} (s' _) (inv p)
-      ( is-retraction-map-inv-equiv (equiv-tr A p) x) ＝
-    substitution-law-tr B s (inv p) ∙
-    is-retraction-map-inv-equiv (equiv-tr (B ∘ s) p) (s' i x)
-  concat-preserves-tr-left-whisk refl = refl
-
 module _
   {l1 l2 l3 l4 : Level}
   {I : UU l1} {A : I → UU l2} {B : I → UU l3} {C : I → UU l4}
@@ -976,117 +805,97 @@ module _
   aaa refl x = refl
 
 module _
-  {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
+  {l1 l2 : Level} {A : UU l1} {B : UU l2}
+  (e : A ≃ B)
   where
 
-  ooo :
-    {x y : A} (p : x ＝ y) (b : B x) →
-    tr-concat p (inv p) b ∙ is-retraction-map-inv-equiv (equiv-tr B p) b ＝
-    ap (λ r → tr B r b) (right-inv p)
-  ooo refl b = refl
-
-  open import foundation.homotopy-algebra
-
-  xxx :
-    {l3 : Level} {C : UU l3} (f : C → A)
-    {x y : C} (p : x ＝ y) →
-    horizontal-concat-htpy
-      ( inv-htpy (λ b → substitution-law-tr B f (inv p) {b}))
-      ( inv-htpy (λ b → substitution-law-tr B f p {b})) ∙h
-    ( λ b →
-      ap
-        ( λ r → tr B r (tr B (ap f p) b))
-        ( ap-inv f p)) ∙h
-    is-retraction-map-inv-equiv (equiv-tr B (ap f p)) ~
-    is-retraction-map-inv-equiv (equiv-tr (B ∘ f) p)
-  xxx f refl x = refl
-
-  bbb :
-    {x y : A} (p : x ＝ y)
-    {z : A} (q : y ＝ z) →
-    is-section-map-inv-equiv (equiv-tr B (p ∙ q)) ~
-    horizontal-concat-htpy
-      ( tr-concat p q)
-      ( (λ b → ap (λ r → tr B r b) (distributive-inv-concat p q)) ∙h
-        tr-concat (inv q) (inv p)) ∙h
-    tr B q ·l (is-section-map-inv-equiv (equiv-tr B p)) ·r tr B (inv q) ∙h
-    is-section-map-inv-equiv (equiv-tr B q)
-  bbb refl refl x =
-    inv
-      ( ap
-        ( _∙ is-section-map-inv-equiv id-equiv x)
-        ( ap-id _ ∙ coherence-map-inv-equiv id-equiv x))
+  inv-coherence-map-inv-is-equiv :
+    (a : A) →
+    ap (map-equiv e) (inv (is-retraction-map-inv-equiv e a)) ＝
+    inv (is-section-map-inv-equiv e (map-equiv e a))
+  inv-coherence-map-inv-is-equiv a =
+    ap-inv (map-equiv e) (is-retraction-map-inv-equiv e a) ∙
+    ap inv (inv (coherence-map-inv-equiv e a))
 
-  open import foundation.dependent-identifications
-  bbb' :
-    {x y : A} (p : x ＝ y)
-    {z : A} (q : y ＝ z) →
-    (b : B z) →
-    concat-dependent-identification B p q
-      ( ap
-        ( tr B p)
-        ( ( ap
-            ( λ r → tr B r b)
-            ( distributive-inv-concat p q)) ∙
-          ( tr-concat (inv q) (inv p) b)) ∙
-        is-section-map-inv-equiv (equiv-tr B p) (tr B (inv q) b))
-      ( is-section-map-inv-equiv (equiv-tr B q) b) ＝
-    is-section-map-inv-equiv (equiv-tr B (p ∙ q)) b
-  bbb' refl refl b =
+  left-inv-is-retraction-map-inv-equiv :
+    (a : A) →
+    inv (is-section-map-inv-equiv e (map-equiv e a)) ∙
+    ap (map-equiv e) (is-retraction-map-inv-equiv e a) ＝
+    refl
+  left-inv-is-retraction-map-inv-equiv a =
     ap
-      ( _∙ is-section-map-inv-equiv id-equiv b)
-      ( ap-id _ ∙ coherence-map-inv-equiv id-equiv b)
-
-  ccc :
-    {l3 : Level} {C : UU l3} (f : C → A)
-    {x y : C} (p : x ＝ y) →
-    horizontal-concat-htpy
-      ( λ b → substitution-law-tr B f (inv p) {b})
-      ( λ b →
-        ap
-          ( λ r → tr B r b)
-          ( inv (ap-inv f (inv p)) ∙ ap (ap f) (inv-inv p)) ∙
-        substitution-law-tr B f p {b}) ∙h
-    is-retraction-map-inv-equiv (equiv-tr (B ∘ f) p) ~
-    is-section-map-inv-equiv (equiv-tr B (ap f (inv p)))
-  ccc f refl x = inv (coherence-map-inv-equiv id-equiv x)
+      ( inv (is-section-map-inv-equiv e (map-equiv e a)) ∙_)
+      ( inv (coherence-map-inv-equiv e a)) ∙
+    left-inv (is-section-map-inv-equiv e (map-equiv e a))
+
+opaque
+  priv-is-section :
+    {l1 l2 : Level} {A : UU l1} {B : UU l2}
+    (e : A ≃ B) → map-equiv e ∘ map-inv-equiv e ~ id
+  priv-is-section = is-section-map-inv-equiv
 
 module _
-  {l1 l2 l3 : Level} {A : UU l1} {B : A → UU l2} {C : UU l3} (f : C → A)
+  {l1 l2 l3 l4 l5 : Level} {A : UU l1} {B : A → UU l2} {C : UU l3} (f : C → A)
+  {D : C → UU l4} {D' : C → UU l5}
+  (f' : fam-equiv D D')
+  (g' : fam-equiv D' (B ∘ f))
+  (let
+    e' : (c : C) → D c → B (f c)
+    e' c = map-fam-equiv g' c ∘ map-fam-equiv f' c
+    inv-e' : (c : C) → B (f c) → D c
+    inv-e' c = map-inv-equiv (g' c ∘e f' c))
   where
+  open import foundation.dependent-identifications
+  abstract
 
-
-  bbb'' :
-    {x y : C} (p : x ＝ y)
-    {z : A} (q : z ＝ f y) →
-    {b : B (f x)} →
-    tr-concat q (ap f (inv p)) (tr B (inv (q ∙ ap f (inv p))) b) ∙
-    ap
-      ( tr B (ap f (inv p)))
-      ( ( ap
-          ( tr B q)
-          ( ( ap (λ r → tr B r b) (distributive-inv-concat _ _)) ∙
-            ( tr-concat _ _ b))) ∙
-        ( is-section-map-inv-equiv
-          ( equiv-tr B q)
-          ( tr B (inv (ap f (inv p))) b)) ∙
-        ( ap
-          ( λ r → tr B r b)
-          ( inv (ap-inv f (inv p)) ∙ ap (ap f) (inv-inv p))) ∙
-        ( substitution-law-tr B f p)) ∙
-    ( substitution-law-tr B f (inv p) ∙
-      is-retraction-map-inv-equiv
-        ( equiv-tr (B ∘ f) p)
-        ( b)) ＝
-    is-section-map-inv-equiv
-      ( equiv-tr B (q ∙ ap f (inv p)))
-      ( b)
-  bbb'' refl refl {b} =
-    ap
-      ( _∙ is-retraction-map-inv-equiv id-equiv b)
-      ( ap-id _ ∙ right-unit ∙ right-unit) ∙
-    right-unit
-
+    ccc'' :
+      {x y : C} (p : x ＝ y)
+      {z : A} (q : z ＝ f y) →
+      {d : D x} (let b = e' x d)
+      {b' : B z} (s : tr B (q ∙ ap f (inv p)) b' ＝ b) →
+      concat-dependent-identification B q (ap f (inv p))
+        ( inv (is-section-map-inv-equiv (g' y ∘e f' y) _))
+        ( left-whisk-dependent-identification (e' _) (inv p)
+          ( inv-dependent-identification D p
+            ( inv
+              ( ( ap
+                  ( inv-e' _ ∘ tr B q)
+                  ( inv
+                    ( is-retraction-map-inv-equiv (equiv-tr B (q ∙ ap f (inv p))) b') ∙
+                    ap
+                      ( tr B (inv (q ∙ ap f (inv p))))
+                      ( s))) ∙
+                ( ( ap
+                    ( inv-e' y)
+                    ( ( ap
+                        ( tr B q)
+                        ( ap (λ r → tr B r b) (distributive-inv-concat _ _) ∙
+                          ( tr-concat _ _ b))) ∙
+                      ( is-section-map-inv-equiv
+                        ( equiv-tr B q)
+                        ( tr B (inv (ap f (inv p))) b)) ∙
+                      ap
+                        ( λ r → tr B r b)
+                        ( inv (ap-inv f (inv p)) ∙ ap (ap f) (inv-inv p)) ∙
+                      substitution-law-tr B f p)) ∙
+                  ( map-eq-transpose-equiv-inv'
+                    ( g' y ∘e f' y)
+                    ( inv (preserves-tr e' p d)))))))) ＝
+      s
+    ccc'' refl refl {d = d} refl =
+      ap
+        ( λ r →
+          ap id (inv (is-section-map-inv-equiv (g' _ ∘e f' _) (e' _ d))) ∙
+          ap (e' _) r)
+        ( ( inv-inv _) ∙
+          ( ap
+            ( λ r →
+              ap (inv-e' _) r ∙ is-retraction-map-inv-equiv (g' _ ∘e f' _) _)
+            ( right-unit ∙ right-unit ∙ coherence-map-inv-equiv id-equiv _))) ∙
+      ap
+        ( _∙ ap (e' _) (is-retraction-map-inv-equiv (g' _ ∘e f' _) d))
+        ( ap-id _) ∙
+      left-inv-is-retraction-map-inv-equiv (g' _ ∘e f' _) d
 ```
 
 ```agda
@@ -1150,69 +959,6 @@ module _
 
 ```agda
 
-module _
-  {l1 l2 l3 l4 : Level}
-  {A : UU l1} {B : A → UU l2}
-  {X : UU l3} {Y : X → UU l4}
-  where
-
-  compute-left-whisker-transpose :
-    {s : A → X} (s' : {a : A} → B a → Y (s a))
-    {x y : A} (p : y ＝ x)
-    {x' : B x} {y' : B y} (p' : x' ＝ tr B p y') →
-    left-whisk-dependent-identification {B' = Y} s' (inv p)
-      ( map-eq-transpose-equiv-inv' (equiv-tr B p) p') ＝
-    ap
-      ( tr Y (ap s (inv p)))
-      ( ap s' p') ∙
-    left-whisk-dependent-identification {B' = Y} s' (inv p)
-      ( is-retraction-map-inv-equiv (equiv-tr B p) y')
-    -- ap
-    --   ( λ r → tr Y r (s' x'))
-    --   ( ap-inv s p) ∙
-    -- inv
-    --   ( map-eq-transpose-equiv
-    --     ( equiv-tr Y (ap s p))
-    --     ( left-whisk-dependent-identification {B' = Y} s' p
-    --       ( inv p')))
-  compute-left-whisker-transpose s' refl refl =
-    refl
-    -- inv (ap inv (compute-refl-eq-transpose-equiv id-equiv))
-
-module _
-  {l1 l2 : Level} {A : UU l1} {B : UU l2}
-  (e : A ≃ B)
-  where
-
-  inv-coherence-map-inv-is-equiv :
-    (a : A) →
-    ap (map-equiv e) (inv (is-retraction-map-inv-equiv e a)) ＝
-    inv (is-section-map-inv-equiv e (map-equiv e a))
-  inv-coherence-map-inv-is-equiv a =
-    ap-inv (map-equiv e) (is-retraction-map-inv-equiv e a) ∙
-    ap inv (inv (coherence-map-inv-equiv e a))
-
-  left-inv-is-retraction-map-inv-equiv :
-    (a : A) →
-    inv (is-section-map-inv-equiv e (map-equiv e a)) ∙
-    ap (map-equiv e) (is-retraction-map-inv-equiv e a) ＝
-    refl
-  left-inv-is-retraction-map-inv-equiv a =
-    ap
-      ( inv (is-section-map-inv-equiv e (map-equiv e a)) ∙_)
-      ( inv (coherence-map-inv-equiv e a)) ∙
-    left-inv (is-section-map-inv-equiv e (map-equiv e a))
-
-module _
-  {l1 l2 : Level} {A : UU l1} {B : UU l2}
-  (e : A ≃ B)
-  where
-
-  triangle-eq-transpose-equiv-inv'' :
-    {x : B} {y : A} (p : x ＝ map-equiv e y) →
-    inv (is-section-map-inv-equiv e x) ∙ ap (map-equiv e) (map-eq-transpose-equiv-inv' e p) ＝
-    p
-  triangle-eq-transpose-equiv-inv'' refl = left-inv-is-retraction-map-inv-equiv e _
 
 module _
   {l1 l2 : Level} {A : UU l1} {B : A → UU l2}
@@ -1241,7 +987,7 @@ module _
 
 open import synthetic-homotopy-theory.zigzags-sequential-diagrams
 module _
-  {l1 l2 l3 l4 l5 : Level}
+  {l1 l2 l3 l4 l5 l6 : Level}
   {A : sequential-diagram l1} {X : UU l2}
   {c : cocone-sequential-diagram A X}
   (up-c : universal-property-sequential-colimit c)
@@ -1254,7 +1000,7 @@ module _
     C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
   (P : X → UU l5)
   (let P' = descent-data-family-cocone-sequential-diagram c P)
-  (Q : Y → UU l5)
+  (Q : Y → UU l6)
   (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
   (e : fam-equiv P (Q ∘ f∞))
   where
@@ -1265,10 +1011,8 @@ module _
       ( map-zigzag-sequential-diagram z n a) →
     family-descent-data-sequential-colimit P' n a
   inv-map-over-diagram-equiv-zigzag' n a =
-    map-inv-fam-equiv e
-      ( map-cocone-sequential-diagram c n a) ∘
-    tr Q (inv (C n a))
-
+    map-inv-equiv
+      ( equiv-over-diagram-equiv-over-colimit up-c c' f P Q e n a)
 
   inv-map-over-diagram-equiv-zigzag :
     (n : ℕ) (b : family-sequential-diagram B n) →
@@ -1376,29 +1120,6 @@ module _
         ( preserves-tr
           ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
           ( upper-triangle-zigzag-sequential-diagram z n a))
-      -- pasting-vertical-coherence-square-maps
-      --   ( tr
-      --     ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-      --     ( upper-triangle-zigzag-sequential-diagram z n a))
-      --   ( map-fam-equiv e _)
-      --   ( map-fam-equiv e _)
-      --   ( tr
-      --     ( Q ∘ f∞ ∘ map-cocone-sequential-diagram c (succ-ℕ n))
-      --     ( upper-triangle-zigzag-sequential-diagram z n a))
-      --   ( tr Q (C (succ-ℕ n) _))
-      --   ( tr Q (C (succ-ℕ n) _))
-      --   ( tr
-      --     ( family-descent-data-sequential-colimit Q' (succ-ℕ n) ∘
-      --       map-zigzag-sequential-diagram z (succ-ℕ n))
-      --     ( upper-triangle-zigzag-sequential-diagram z n a))
-      --   ( inv-htpy
-      --     ( preserves-tr
-      --       ( map-fam-equiv e ∘ map-cocone-sequential-diagram c (succ-ℕ n))
-      --       ( upper-triangle-zigzag-sequential-diagram z n a)))
-      --   ( inv-htpy
-      --     ( preserves-tr
-      --       ( λ a → tr Q (C (succ-ℕ n) a))
-      --       ( upper-triangle-zigzag-sequential-diagram z n a)))
 
   opaque
     transpose-squares :
@@ -1417,10 +1138,8 @@ module _
         ( upper-triangle-zigzag-sequential-diagram z n a)
     transpose-squares n a p =
       map-eq-transpose-equiv-inv'
-        ( e _)
-        ( map-eq-transpose-equiv-inv'
-          ( equiv-tr Q (C (succ-ℕ n) _))
-          ( inv-transport-squares n a p))
+        ( equiv-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
+        ( inv-transport-squares n a p)
 
 
   opaque
@@ -1439,8 +1158,7 @@ module _
         ( upper-triangle-zigzag-sequential-diagram z n a)
     upper-triangle-over' n a p =
        ap
-        ( map-inv-fam-equiv e _ ∘
-          tr Q (inv (C (succ-ℕ n) _)))
+        ( inv-map-over-diagram-equiv-zigzag' (succ-ℕ n) _)
         ( internal-triangle-upper-triangle-over' n a
           ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a) p) ∙
           substitution-law-tr
@@ -1489,12 +1207,6 @@ module _
   upper-triangle-over n {a} p =
     inv (inv-upper-triangle-over n a p)
 
-
-  opaque
-    priv-is-section :
-      {l1 l2 : Level} {A : UU l1} {B : UU l2}
-      (e : A ≃ B) → map-equiv e ∘ map-inv-equiv e ~ id
-    priv-is-section = is-section-map-inv-equiv
   opaque
     lower-triangle-over' :
       (n : ℕ) (a : family-sequential-diagram A n)
@@ -1506,15 +1218,9 @@ module _
         ( inv-map-over-diagram-equiv-zigzag' n a q)
     lower-triangle-over' n a q =
       inv
-        ( priv-is-section -- is-section-map-inv-equiv
-          ( equiv-tr Q (C n a))
-          ( q)) ∙
-      ap
-        ( tr Q (C n a))
-        ( inv
-          ( priv-is-section -- is-section-map-inv-equiv
-            ( e (map-cocone-sequential-diagram c n a))
-            ( tr Q (inv (C n a)) q)))
+        ( is-section-map-inv-equiv
+          ( equiv-over-diagram-equiv-over-colimit up-c c' f P Q e n a)
+          ( q))
 
   lower-triangle-over :
     (n : ℕ) →
@@ -1525,8 +1231,6 @@ module _
       ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ ∘
         inv-map-over-diagram-equiv-zigzag n _)
   lower-triangle-over n {b} q =
-    -- this could change to alternatives
-    -- map-inv-eq-transpose-equiv-inv doesn't compute well
     lower-triangle-over'
       ( succ-ℕ n)
       ( inv-map-zigzag-sequential-diagram z n b)
@@ -1535,585 +1239,11 @@ module _
          ( lower-triangle-zigzag-sequential-diagram z n b)
          ( map-family-descent-data-sequential-colimit Q' n b q))
 
-  trivial-pasting :
-    (n : ℕ) →
-    htpy-over
-      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-      ( naturality-map-hom-diagram-zigzag-sequential-diagram z n)
-      ( tr
-        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-        ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n _)) ∘
-        map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-      ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-  trivial-pasting n =
-    concat-htpy-over
-      ( lower-triangle-zigzag-sequential-diagram z n ·r
-        ( map-zigzag-sequential-diagram z n))
-      ( ( map-zigzag-sequential-diagram z (succ-ℕ n)) ·l
-        ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n)))
-      ( λ p →
-        lower-triangle-over' (succ-ℕ n) _
-          ( tr
-            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-            ( lower-triangle-zigzag-sequential-diagram z n _)
-            ( tr
-              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-              ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n _))
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
-                ( map-sequential-diagram A n _)
-                ( p)))))
-      ( left-whisk-htpy-over
-        ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
-        ( λ p →
-          map-eq-transpose-equiv-inv'
-            ( equiv-tr
-              ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-              ( upper-triangle-zigzag-sequential-diagram z n _))
-            ( upper-triangle-over' n _ p))
-        ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _))
-
-  abstract opaque
-    unfolding lower-triangle-over' upper-triangle-over' inv-transport-squares
-      internal-triangle-upper-triangle-over'
-    open import foundation.dependent-identifications
-    is-trivial-trivial-pasting :
-      (n : ℕ) (a : family-sequential-diagram A n) →
-      trivial-pasting n {a} ~
-      is-section-map-inv-equiv
-        ( equiv-tr
-          ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-          ( naturality-map-hom-diagram-zigzag-sequential-diagram z n a)) ·r
-        map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) (map-sequential-diagram A n a)
-    is-trivial-trivial-pasting n a p =
-      ap
-        ( λ K' →
-          concat-dependent-identification _ _ _
-          ( lower-triangle-over' (succ-ℕ n) _ _)
-          ( K'))
-        ( ( ap
-            ( left-whisk-dependent-identification
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
-            ( compute-eq-transpose-equiv-inv-concat'
-              ( equiv-tr
-                ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                ( upper-triangle-zigzag-sequential-diagram z n a))
-              ( _)
-              ( transpose-squares n a p))) ∙
-          ( ( compute-left-whisk-dependent-identification-concat'
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
-              ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-              ( _)
-              ( map-eq-transpose-equiv-inv'
-                ( equiv-tr
-                  ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                  ( upper-triangle-zigzag-sequential-diagram z n a))
-                ( transpose-squares n a p))) ∙
-            ( ap
-              ( λ r →
-                ap
-                  ( tr
-                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                    ( ap
-                      ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                      ( inv (upper-triangle-zigzag-sequential-diagram z n a))))
-                  ( r) ∙
-                left-whisk-dependent-identification
-                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-                  ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-                  ( map-eq-transpose-equiv-inv'
-                    ( equiv-tr
-                      ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                      ( upper-triangle-zigzag-sequential-diagram z n a))
-                    ( transpose-squares n a p)))
-              ( inv
-                ( ap-comp
-                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-                  ( inv-map-over-diagram-equiv-zigzag' (succ-ℕ n) _)
-                  ( _)))))) ∙
-      compute-right-concat-dependent-identification
-        ( lower-triangle-zigzag-sequential-diagram z n
-          ( map-zigzag-sequential-diagram z n a))
-        ( ap
-          ( map-zigzag-sequential-diagram z (succ-ℕ n))
-          ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
-        ( _)
-        ( _)
-        ( _) ∙
-      ap
-        ( _∙
-          left-whisk-dependent-identification
-            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-            ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-            ( map-eq-transpose-equiv-inv'
-              ( equiv-tr
-                ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                ( upper-triangle-zigzag-sequential-diagram z n a))
-              ( transpose-squares n a p)))
-        ( inv
-          ( nat-concat-dependent-identification-id
-            ( lower-triangle-zigzag-sequential-diagram z n
-              ( map-zigzag-sequential-diagram z n a))
-            ( ap
-              ( map-zigzag-sequential-diagram z (succ-ℕ n))
-              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
-            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ ∘
-              inv-map-over-diagram-equiv-zigzag' (succ-ℕ n) _)
-            ( λ q →
-              lower-triangle-over' (succ-ℕ n)
-                ( inv-map-zigzag-sequential-diagram z n
-                  ( map-zigzag-sequential-diagram z n a))
-                ( q))
-            ( internal-triangle-upper-triangle-over' n a
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ p) ∙
-              substitution-law-tr
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                ( _)
-                ( upper-triangle-zigzag-sequential-diagram z n a))) ∙
-          compute-right-concat-dependent-identification
-            ( lower-triangle-zigzag-sequential-diagram z n
-              ( map-zigzag-sequential-diagram z n a))
-            ( ap
-              ( map-zigzag-sequential-diagram z (succ-ℕ n))
-              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
-            ( _)
-            ( refl)
-            ( _)) ∙
-      assoc _ _ _ ∙
-      ap
-        ( concat-dependent-identification
-          ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-          ( _)
-          ( _)
-          ( internal-triangle-upper-triangle-over' n a
-            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ p) ∙
-            substitution-law-tr
-              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-              ( _)
-              ( upper-triangle-zigzag-sequential-diagram z n a))
-          ( refl) ∙_)
-        ( ( ap
-            ( ap
-              ( tr
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                ( ap
-                  ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                  ( inv (upper-triangle-zigzag-sequential-diagram z n a))))
-              ( lower-triangle-over' (succ-ℕ n) _ _) ∙_)
-            ( compute-left-whisker-transpose
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-              ( upper-triangle-zigzag-sequential-diagram z n a)
-              ( transpose-squares n a p))) ∙
-          ( inv (assoc _ _ _)) ∙
-          ( ap
-            ( _∙
-              left-whisk-dependent-identification
-                ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-                ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-                ( is-retraction-map-inv-equiv
-                  ( equiv-tr
-                    ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                    ( upper-triangle-zigzag-sequential-diagram z n a))
-                  ( p)))
-            ( ( inv
-                ( ap-concat
-                  ( tr
-                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                    ( ap
-                      ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                      ( inv (upper-triangle-zigzag-sequential-diagram z n a))))
-                  ( lower-triangle-over' (succ-ℕ n) _ _)
-                  ( ap
-                    ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-                    ( transpose-squares n a p)))) ∙
-              ( ap
-                ( ap
-                  ( tr
-                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                    ( ap
-                      ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                      ( inv (upper-triangle-zigzag-sequential-diagram z n a)))))
-                ( [i] p)))) ∙
-          ( concat-preserves-tr-left-whisk
-            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n))
-            ( upper-triangle-zigzag-sequential-diagram z n a))) ∙
-      ap
-        ( _∙
-          ( ( substitution-law-tr
-              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-              ( map-zigzag-sequential-diagram z (succ-ℕ n))
-              ( inv (upper-triangle-zigzag-sequential-diagram z n a))) ∙
-            ( is-retraction-map-inv-equiv
-              ( equiv-tr
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n) ∘
-                  map-zigzag-sequential-diagram z (succ-ℕ n))
-                ( upper-triangle-zigzag-sequential-diagram z n a))
-              ( _))))
-        ( ( compute-concat-dependent-identification
-            ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-            ( lower-triangle-zigzag-sequential-diagram z n
-              ( map-zigzag-sequential-diagram z n a))
-            ( ap
-              ( map-zigzag-sequential-diagram z (succ-ℕ n))
-              ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
-            ( _)
-            ( _)) ∙
-          right-unit) ∙
-      bbb''
-        ( map-zigzag-sequential-diagram z (succ-ℕ n))
-        ( upper-triangle-zigzag-sequential-diagram z n a)
-        ( lower-triangle-zigzag-sequential-diagram z n
-          ( map-zigzag-sequential-diagram z n a))
-      where
-      opaque
-        unfolding lower-triangle-over' transpose-squares priv-is-section
-        [i] :
-          lower-triangle-over' (succ-ℕ n)
-            ( inv-map-zigzag-sequential-diagram z n
-              ( map-zigzag-sequential-diagram z n a)) ·r
-            ( ( tr
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n) ∘
-                  map-zigzag-sequential-diagram z (succ-ℕ n))
-                ( upper-triangle-zigzag-sequential-diagram z n a)) ∘
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n)
-                ( map-sequential-diagram A n a))) ∙h
-          map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _ ·l
-          transpose-squares n a ~
-          inv-transport-squares n a
-        [i] p =
-          assoc _ _ _ ∙
-          ap
-            ( inv
-              ( is-section-map-inv-equiv
-                ( equiv-tr Q
-                  ( C (succ-ℕ n) _))
-                ( _)) ∙_)
-            ( ( ap
-                ( ap
-                  ( tr Q (C (succ-ℕ n) _))
-                  ( inv
-                    ( is-section-map-inv-equiv
-                      ( e _)
-                      ( tr Q (inv (C (succ-ℕ n) _)) _))) ∙_)
-                ( ap-comp
-                  ( tr Q (C (succ-ℕ n) _))
-                  ( map-fam-equiv e _)
-                  ( transpose-squares n a p))) ∙
-              ( inv
-                ( ap-concat
-                  ( tr Q (C (succ-ℕ n) _))
-                  ( _)
-                  ( _))) ∙
-              ( ap
-                ( ap (tr Q (C (succ-ℕ n) _)))
-                ( triangle-eq-transpose-equiv-inv''
-                  ( e _)
-                  ( map-eq-transpose-equiv-inv'
-                    ( equiv-tr Q (C (succ-ℕ n) _))
-                    ( inv-transport-squares n a p))))) ∙
-          triangle-eq-transpose-equiv-inv''
-            ( equiv-tr Q (C (succ-ℕ n) _))
-            ( inv-transport-squares n a p)
-```
-
-```agda
-module _
-  {l1 l2 : Level} {A : UU l1} {B : UU l2}
-  (e : A ≃ B)
-  where
-  concat-inv-coherence-map-inv-is-equiv :
-    {x : A} {y : B} (p : map-equiv e x ＝ y) →
-    ap (map-equiv e) (inv (is-retraction-map-inv-equiv e x) ∙ ap (map-inv-equiv e) p) ＝
-    p ∙ inv (is-section-map-inv-equiv e y)
-  concat-inv-coherence-map-inv-is-equiv refl =
-    ap (ap (map-equiv e)) right-unit ∙ inv-coherence-map-inv-is-equiv e _
-
-module _
-  {l1 l2 l3 l4 l5 : Level}
-  {A : sequential-diagram l1} {X : UU l2}
-  {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  {B : sequential-diagram l3} {Y : UU l4}
-  (c' : cocone-sequential-diagram B Y)
-  (z : zigzag-sequential-diagram A B)
-  (let f = hom-diagram-zigzag-sequential-diagram z)
-  (let g = inv-hom-diagram-zigzag-sequential-diagram z)
-  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
-  (let
-    C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
-  (Q : Y → UU l5)
-  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
-  (let P = Q ∘ f∞)
-  (let P' = descent-data-family-cocone-sequential-diagram c P)
-  where
-
-  open import foundation.dependent-identifications
-
-  opaque
-    -- TODO: Maybe this goes through for general equivalences immediately?
-    -- I haven't tried yet
-    compute-square-over-zigzag-square-over-colimit-id :
-      (n : ℕ) (a : family-sequential-diagram A n) →
-      pasting-triangles-over
-        ( map-sequential-diagram A n)
-        ( map-hom-sequential-diagram B f n)
-        ( map-hom-sequential-diagram B f (succ-ℕ n))
-        ( map-sequential-diagram B n)
-        ( map-family-descent-data-sequential-colimit P' n _)
-        ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv n _)
-        ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) _)
-        ( map-family-descent-data-sequential-colimit Q' n _)
-        ( map-hom-sequential-diagram _ g n)
-        ( inv-map-over-diagram-equiv-zigzag up-c c' z P Q id-fam-equiv n _)
-        ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
-        ( lower-triangle-zigzag-sequential-diagram z n)
-        ( inv-htpy-over
-          ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-          ( upper-triangle-zigzag-sequential-diagram z n)
-          _ _
-          ( upper-triangle-over up-c c' z P Q id-fam-equiv n))
-        ( lower-triangle-over up-c c' z P Q id-fam-equiv n)
-        { a} ~
-      square-over-diagram-square-over-colimit up-c c' f P Q id-fam-equiv n a
-    compute-square-over-zigzag-square-over-colimit-id n a p =
-      compute-concat-dependent-identification
-        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-        _ _ _ _ ∙
-      ( ap
-        ( ( ( tr-concat
-              ( lower-triangle-zigzag-sequential-diagram z n _)
-              ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
-              ( _)) ∙
-            ( ap
-              ( tr (family-descent-data-sequential-colimit Q' (succ-ℕ n)) _)
-              ( lower-triangle-over up-c c' z (Q ∘ f∞) Q id-fam-equiv n _))) ∙_)
-        ( ( compute-left-whisk-dependent-identification
-            ( map-over-diagram-equiv-over-colimit up-c c' (hom-diagram-zigzag-sequential-diagram z) (Q ∘ f∞) Q id-fam-equiv (succ-ℕ n) _)
-            ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-            ( _)) ∙
-          ap
-            ( λ r →
-              substitution-law-tr
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                ( inv (upper-triangle-zigzag-sequential-diagram z n a)) ∙
-              inv
-                ( preserves-tr
-                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n))
-                  ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-                  ( _)) ∙
-              ap
-                ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
-                ( r))
-            ( ( compute-inv-dependent-identification-inv
-                ( upper-triangle-zigzag-sequential-diagram z n a)
-                ( inv-upper-triangle-over up-c c' z (Q ∘ f∞) Q id-fam-equiv n a p)) ∙
-              ( compute-eq-transpose-equiv-inv-concat'
-                ( equiv-tr
-                  ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                  ( upper-triangle-zigzag-sequential-diagram z n a))
-                ( _)
-                ( _))))) ∙
-      inv (assoc _ _ _) ∙
-      ap
-        ( ( tr-concat
-            ( lower-triangle-zigzag-sequential-diagram z n _)
-            ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
-            ( map-family-descent-data-sequential-colimit Q' n
-              ( map-zigzag-sequential-diagram z n a)
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv n a p)) ∙
-            ap
-              ( tr
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                ( ap _ (inv (upper-triangle-zigzag-sequential-diagram z n a))))
-              ( lower-triangle-over up-c c' z P Q id-fam-equiv n _) ∙
-            ( substitution-law-tr
-              ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-              ( map-zigzag-sequential-diagram z (succ-ℕ n))
-              ( inv (upper-triangle-zigzag-sequential-diagram z n a)) ∙
-              inv
-                ( preserves-tr
-                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n))
-                  ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-                  ( _)))) ∙_)
-        ( ap-concat
-          ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
-          ( _)
-          ( _) ∙
-          ap
-            (_∙
-              ap
-                ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
-                ( map-eq-transpose-equiv-inv'
-                  ( equiv-tr
-                    ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                    ( upper-triangle-zigzag-sequential-diagram z n a))
-                  ( upper-triangle-over' up-c c' z P Q id-fam-equiv n a _)))
-            ( inv
-              ( ap-comp
-                ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
-                ( tr
-                  ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                  ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
-                ( _)) ∙
-              inv
-                ( ap-comp
-                  ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a) ∘
-                    tr (family-descent-data-sequential-colimit P' (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
-                  ( tr Q
-                      ( inv (C (succ-ℕ n) _)) ∘
-                    tr
-                      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                      ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a)))
-                  ( _)))) ∙
-      inv (assoc _ _ _) ∙
-      ap
-        ( _∙
-          ap
-            ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) (map-sequential-diagram A n a))
-            ( map-eq-transpose-equiv-inv'
-              ( equiv-tr
-                ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                ( upper-triangle-zigzag-sequential-diagram z n a))
-              ( upper-triangle-over' up-c c' z P Q id-fam-equiv n a _)))
-        ( nat-htpy
-            ( λ (q : family-descent-data-sequential-colimit Q' (succ-ℕ n) (map-sequential-diagram B n (map-zigzag-sequential-diagram z n a))) →
-              tr-concat
-                ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-                ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
-                ( q) ∙
-              ap
-                ( tr
-                  ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                  ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a))))
-                ( lower-triangle-over' up-c c' z P Q id-fam-equiv (succ-ℕ n) _
-                  ( tr
-                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                    ( lower-triangle-zigzag-sequential-diagram z n
-                      ( map-zigzag-sequential-diagram z n a))
-                    ( q))) ∙
-              ( substitution-law-tr
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                ( inv (upper-triangle-zigzag-sequential-diagram z n a)) ∙
-                inv
-                  ( preserves-tr
-                    ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n))
-                    ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-                    ( inv-map-over-diagram-equiv-zigzag' up-c c' z P Q id-fam-equiv (succ-ℕ n)
-                      ( inv-map-zigzag-sequential-diagram z n
-                        ( map-zigzag-sequential-diagram z n a))
-                      ( tr
-                        ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                        ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-                        ( q))))))
-            ( _) ∙
-            ap
-              ( _∙
-                ( tr-concat _ _ _ ∙
-                  ap
-                    ( tr
-                      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                      ( ap
-                        ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                        ( inv (upper-triangle-zigzag-sequential-diagram z n a))))
-                    ( lower-triangle-over' up-c c' z P Q id-fam-equiv (succ-ℕ n) _ _)∙
-                  ( substitution-law-tr
-                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                    ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                    ( inv (upper-triangle-zigzag-sequential-diagram z n a)) ∙
-                    inv
-                      ( preserves-tr
-                        ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n))
-                        ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-                        ( inv-map-over-diagram-equiv-zigzag' up-c c' z P Q id-fam-equiv (succ-ℕ n)
-                          ( inv-map-zigzag-sequential-diagram z n
-                            ( map-zigzag-sequential-diagram z n a))
-                          ( _))))))
-              ( concat-inv-coherence-map-inv-is-equiv
-                ( equiv-tr
-                  ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                  ( naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
-                ( square-over-diagram-square-over-colimit up-c c' f P Q id-fam-equiv n a p))) ∙
-      assoc _ _ _ ∙
-      assoc _ _ _ ∙
-      ap
-        ( square-over-diagram-square-over-colimit up-c c' f P Q id-fam-equiv n a p ∙_)
-        ( ap
-          ( inv
-            ( is-section-map-inv-equiv
-              ( equiv-tr
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                ( naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
-              ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n)
-                ( map-sequential-diagram A n a)
-                ( map-family-descent-data-sequential-colimit P' n a p))) ∙_)
-          ( assoc _ _ _ ∙
-            inv
-              ( compute-concat-dependent-identification
-                ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-                ( ap (map-zigzag-sequential-diagram z (succ-ℕ n)) (inv (upper-triangle-zigzag-sequential-diagram z n a)))
-                ( lower-triangle-over' up-c c' z P Q id-fam-equiv (succ-ℕ n)
-                  ( inv-map-zigzag-sequential-diagram z n
-                    ( map-zigzag-sequential-diagram z n a))
-                  ( tr
-                    ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                    ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-                    ( tr
-                      ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                      ( inv (naturality-map-hom-diagram-zigzag-sequential-diagram z n a))
-                      ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n)
-                        ( map-sequential-diagram A n a)
-                        ( map-family-descent-data-sequential-colimit P' n a p)))))
-                ( _)) ∙
-              ap
-                ( concat-dependent-identification
-                  ( family-descent-data-sequential-colimit Q' (succ-ℕ n))
-                  ( lower-triangle-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-                  ( ap
-                    ( map-zigzag-sequential-diagram z (succ-ℕ n))
-                    ( inv (upper-triangle-zigzag-sequential-diagram z n a)))
-                  ( lower-triangle-over' up-c c' z P Q id-fam-equiv (succ-ℕ n)
-                    ( inv-map-zigzag-sequential-diagram z n (map-zigzag-sequential-diagram z n a))
-                    ( _)))
-                ( inv
-                  ( compute-left-whisk-dependent-identification
-                    ( map-over-diagram-equiv-over-colimit up-c c' f P Q id-fam-equiv (succ-ℕ n) _)
-                    ( inv (upper-triangle-zigzag-sequential-diagram z n a))
-                    ( map-eq-transpose-equiv-inv'
-                      ( equiv-tr
-                        ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-                        ( upper-triangle-zigzag-sequential-diagram z n a))
-                      ( upper-triangle-over' up-c c' z P Q id-fam-equiv n a
-                        ( map-family-descent-data-sequential-colimit P' n _ p))))) ∙
-              is-trivial-trivial-pasting up-c c' z P Q id-fam-equiv n a
-                ( map-family-descent-data-sequential-colimit P' n _ p)) ∙
-          ( left-inv _)) ∙
-      right-unit
-```
-
-```agda
-module _
-  {l1 l2 l3 l4 l5 : Level}
-  {A : sequential-diagram l1} {X : UU l2}
-  {c : cocone-sequential-diagram A X}
-  (up-c : universal-property-sequential-colimit c)
-  {B : sequential-diagram l3} {Y : UU l4}
-  (c' : cocone-sequential-diagram B Y)
-  (z : zigzag-sequential-diagram A B)
-  (let f = hom-diagram-zigzag-sequential-diagram z)
-  (let f∞ = map-sequential-colimit-hom-sequential-diagram up-c c' f)
-  (let
-    C = htpy-htpy-cocone-map-sequential-colimit-hom-sequential-diagram up-c c' f)
-  (P : X → UU l5)
-  (let P' = descent-data-family-cocone-sequential-diagram c P)
-  (Q : Y → UU l5)
-  (let Q' = descent-data-family-cocone-sequential-diagram c' Q)
-  (e : fam-equiv P (Q ∘ f∞))
-  where
-
   opaque
+    unfolding
+      lower-triangle-over' upper-triangle-over'
+      internal-triangle-upper-triangle-over' transpose-squares
+      inv-transport-squares
     compute-square-over-zigzag-square-over-colimit :
       (n : ℕ) (a : family-sequential-diagram A n) →
       pasting-triangles-over
@@ -2126,45 +1256,26 @@ module _
         ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
         ( map-family-descent-data-sequential-colimit Q' n _)
         ( inv-map-zigzag-sequential-diagram z n)
-        ( inv-map-over-diagram-equiv-zigzag up-c c' z P Q e n _)
+        ( inv-map-over-diagram-equiv-zigzag n _)
         ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
         ( lower-triangle-zigzag-sequential-diagram z n)
         ( inv-htpy-over
           ( family-descent-data-sequential-colimit P' (succ-ℕ n))
           ( upper-triangle-zigzag-sequential-diagram z n)
           _ _
-          ( upper-triangle-over up-c c' z P Q e n))
-        ( lower-triangle-over up-c c' z P Q e n)
+          ( upper-triangle-over n))
+        ( lower-triangle-over n)
         { a} ~
       square-over-diagram-square-over-colimit up-c c' f P Q e n a
-    compute-square-over-zigzag-square-over-colimit =
-      ind-fam-equiv'
-        ( λ P e →
-          let P' = descent-data-family-cocone-sequential-diagram c P in
-          (n : ℕ) (a : family-sequential-diagram A n) →
-          pasting-triangles-over
-            ( map-sequential-diagram A n)
-            ( map-hom-sequential-diagram B f n)
-            ( map-hom-sequential-diagram B f (succ-ℕ n))
-            ( map-sequential-diagram B n)
-            ( map-family-descent-data-sequential-colimit P' n _)
-            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e n _)
-            ( map-over-diagram-equiv-over-colimit up-c c' f P Q e (succ-ℕ n) _)
-            ( map-family-descent-data-sequential-colimit Q' n _)
-            ( inv-map-zigzag-sequential-diagram z n)
-            ( inv-map-over-diagram-equiv-zigzag up-c c' z P Q e n _)
-            ( inv-htpy (upper-triangle-zigzag-sequential-diagram z n))
-            ( lower-triangle-zigzag-sequential-diagram z n)
-            ( inv-htpy-over
-              ( family-descent-data-sequential-colimit P' (succ-ℕ n))
-              ( upper-triangle-zigzag-sequential-diagram z n)
-              _ _
-              ( upper-triangle-over up-c c' z P Q e n))
-            ( lower-triangle-over up-c c' z P Q e n)
-            { a} ~
-          square-over-diagram-square-over-colimit up-c c' f P Q e n a)
-        ( compute-square-over-zigzag-square-over-colimit-id up-c c' z Q)
-      ( e)
+    compute-square-over-zigzag-square-over-colimit n a p =
+      ccc''
+        ( map-zigzag-sequential-diagram z (succ-ℕ n))
+        ( λ a → e (map-cocone-sequential-diagram c (succ-ℕ n) a))
+        ( λ a → equiv-tr Q (C (succ-ℕ n) a))
+        ( upper-triangle-zigzag-sequential-diagram z n a)
+        ( lower-triangle-zigzag-sequential-diagram z n
+          ( map-zigzag-sequential-diagram z n a))
+        ( square-over-diagram-square-over-colimit up-c c' f P Q e n a p)
 ```
 
 ```agda

From 67ab1e9372f0993ed8fe5a096971b1be9107c240 Mon Sep 17 00:00:00 2001
From: VojtechStep <vojtechstepancik@outlook.com>
Date: Tue, 25 Mar 2025 18:24:16 +0100
Subject: [PATCH 33/33] Temporarily bump maximum heap size

Even macOS runners have 14GB of RAM, so this might just go through CI?
---
 Makefile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 1c7fca38cc..43ebf857d9 100644
--- a/Makefile
+++ b/Makefile
@@ -14,7 +14,9 @@ else
 	AGDA_MIN_HEAP ?= 4G
 endif
 
-AGDARTS := +RTS -H$(AGDA_MIN_HEAP) -M6G -RTS
+# Temporarily raise maximum heap size; should compile with the previous 6G
+# before merging
+AGDARTS := +RTS -H$(AGDA_MIN_HEAP) -M14G -RTS
 AGDAFILES := $(shell find src -name temp -prune -o -type f \( -name "*.lagda.md" -not -name "everything.lagda.md" \) -print)
 CONTRIBUTORS_FILE := CONTRIBUTORS.toml