Documentation

Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc

Associativity of pullbacks #

This file shows that pullbacks (and pushouts) are associative up to natural isomorphism.

noncomputable def CategoryTheory.Limits.pullbackPullbackLeftIsPullback {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] :
IsLimit (PullbackCone.mk (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (pullback.lift (CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (pullback.snd f₁ fā‚‚)) (pullback.snd (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) ⋯) ⋯)

(X₁ Ɨ[Y₁] Xā‚‚) Ɨ[Yā‚‚] Xā‚ƒ is the pullback (X₁ Ɨ[Y₁] Xā‚‚) Ɨ[Xā‚‚] (Xā‚‚ Ɨ[Yā‚‚] Xā‚ƒ).

Instances For
    noncomputable def CategoryTheory.Limits.pullbackAssocIsPullback {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] :
    IsLimit (PullbackCone.mk (CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (pullback.fst f₁ fā‚‚)) (pullback.lift (CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (pullback.snd f₁ fā‚‚)) (pullback.snd (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) ⋯) ⋯)

    (X₁ Ɨ[Y₁] Xā‚‚) Ɨ[Yā‚‚] Xā‚ƒ is the pullback X₁ Ɨ[Y₁] (Xā‚‚ Ɨ[Yā‚‚] Xā‚ƒ).

    Instances For
      theorem CategoryTheory.Limits.hasPullback_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] :
      HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)
      noncomputable def CategoryTheory.Limits.pullbackPullbackRightIsPullback {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
      IsLimit (PullbackCone.mk (pullback.lift (pullback.fst f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (pullback.fst fā‚ƒ fā‚„)) ⋯) (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) ⋯)

      X₁ Ɨ[Y₁] (Xā‚‚ Ɨ[Yā‚‚] Xā‚ƒ) is the pullback (X₁ Ɨ[Y₁] Xā‚‚) Ɨ[Xā‚‚] (Xā‚‚ Ɨ[Yā‚‚] Xā‚ƒ).

      Instances For
        noncomputable def CategoryTheory.Limits.pullbackAssocSymmIsPullback {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
        IsLimit (PullbackCone.mk (pullback.lift (pullback.fst f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (pullback.fst fā‚ƒ fā‚„)) ⋯) (CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (pullback.snd fā‚ƒ fā‚„)) ⋯)

        X₁ Ɨ[Y₁] (Xā‚‚ Ɨ[Yā‚‚] Xā‚ƒ) is the pullback (X₁ Ɨ[Y₁] Xā‚‚) Ɨ[Yā‚‚] Xā‚ƒ.

        Instances For
          theorem CategoryTheory.Limits.hasPullback_assoc_symm {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
          HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„
          noncomputable def CategoryTheory.Limits.pullbackAssoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
          pullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„ ≅ pullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)

          The canonical isomorphism (X₁ Ɨ[Y₁] Xā‚‚) Ɨ[Yā‚‚] Xā‚ƒ ≅ X₁ Ɨ[Y₁] (Xā‚‚ Ɨ[Yā‚‚] Xā‚ƒ).

          Instances For
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_inv_fst_fst {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).inv (CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (pullback.fst f₁ fā‚‚)) = pullback.fst f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_inv_fst_fst_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] {Z : C} (h : X₁ ⟶ Z) :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).inv (CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (CategoryStruct.comp (pullback.fst f₁ fā‚‚) h)) = CategoryStruct.comp (pullback.fst f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) h
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_hom_fst {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).hom (pullback.fst f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) = CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (pullback.fst f₁ fā‚‚)
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_hom_fst_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] {Z : C} (h : X₁ ⟶ Z) :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).hom (CategoryStruct.comp (pullback.fst f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) h) = CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (CategoryStruct.comp (pullback.fst f₁ fā‚‚) h)
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_hom_snd_fst {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).hom (CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (pullback.fst fā‚ƒ fā‚„)) = CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (pullback.snd f₁ fā‚‚)
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_hom_snd_fst_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] {Z : C} (h : Xā‚‚ ⟶ Z) :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).hom (CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) h)) = CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (CategoryStruct.comp (pullback.snd f₁ fā‚‚) h)
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_hom_snd_snd {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).hom (CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (pullback.snd fā‚ƒ fā‚„)) = pullback.snd (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_hom_snd_snd_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] {Z : C} (h : Xā‚ƒ ⟶ Z) :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).hom (CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (CategoryStruct.comp (pullback.snd fā‚ƒ fā‚„) h)) = CategoryStruct.comp (pullback.snd (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) h
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_inv_fst_snd {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).inv (CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (pullback.snd f₁ fā‚‚)) = CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (pullback.fst fā‚ƒ fā‚„)
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_inv_fst_snd_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] {Z : C} (h : Xā‚‚ ⟶ Z) :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).inv (CategoryStruct.comp (pullback.fst (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) (CategoryStruct.comp (pullback.snd f₁ fā‚‚) h)) = CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) h)
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_inv_snd {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).inv (pullback.snd (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) = CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (pullback.snd fā‚ƒ fā‚„)
            @[simp]
            theorem CategoryTheory.Limits.pullbackAssoc_inv_snd_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Y₁ Yā‚‚ : C} (f₁ : X₁ ⟶ Y₁) (fā‚‚ : Xā‚‚ ⟶ Y₁) (fā‚ƒ : Xā‚‚ ⟶ Yā‚‚) (fā‚„ : Xā‚ƒ ⟶ Yā‚‚) [HasPullback f₁ fā‚‚] [HasPullback fā‚ƒ fā‚„] [HasPullback (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„] [HasPullback f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)] {Z : C} (h : Xā‚ƒ ⟶ Z) :
            CategoryStruct.comp (pullbackAssoc f₁ fā‚‚ fā‚ƒ fā‚„).inv (CategoryStruct.comp (pullback.snd (CategoryStruct.comp (pullback.snd f₁ fā‚‚) fā‚ƒ) fā‚„) h) = CategoryStruct.comp (pullback.snd f₁ (CategoryStruct.comp (pullback.fst fā‚ƒ fā‚„) fā‚‚)) (CategoryStruct.comp (pullback.snd fā‚ƒ fā‚„) h)
            noncomputable def CategoryTheory.Limits.pushoutPushoutLeftIsPushout {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] :
            IsColimit (PushoutCocone.mk (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) (pushout.desc (CategoryStruct.comp (pushout.inr g₁ gā‚‚) (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„)) (pushout.inr (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) ⋯) ⋯)

            (X₁ ⨿[Z₁] Xā‚‚) ⨿[Zā‚‚] Xā‚ƒ is the pushout (X₁ ⨿[Z₁] Xā‚‚) Ɨ[Xā‚‚] (Xā‚‚ ⨿[Zā‚‚] Xā‚ƒ).

            Instances For
              noncomputable def CategoryTheory.Limits.pushoutAssocIsPushout {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] :
              IsColimit (PushoutCocone.mk (CategoryStruct.comp (pushout.inl g₁ gā‚‚) (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„)) (pushout.desc (CategoryStruct.comp (pushout.inr g₁ gā‚‚) (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„)) (pushout.inr (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) ⋯) ⋯)

              (X₁ ⨿[Z₁] Xā‚‚) ⨿[Zā‚‚] Xā‚ƒ is the pushout X₁ ⨿[Z₁] (Xā‚‚ ⨿[Zā‚‚] Xā‚ƒ).

              Instances For
                theorem CategoryTheory.Limits.hasPushout_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] :
                HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))
                noncomputable def CategoryTheory.Limits.pushoutPushoutRightIsPushout {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                IsColimit (PushoutCocone.mk (pushout.desc (pushout.inl g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) (CategoryStruct.comp (pushout.inl gā‚ƒ gā‚„) (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„)))) ⋯) (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) ⋯)

                X₁ ⨿[Z₁] (Xā‚‚ ⨿[Zā‚‚] Xā‚ƒ) is the pushout (X₁ ⨿[Z₁] Xā‚‚) Ɨ[Xā‚‚] (Xā‚‚ ⨿[Zā‚‚] Xā‚ƒ).

                Instances For
                  noncomputable def CategoryTheory.Limits.pushoutAssocSymmIsPushout {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                  IsColimit (PushoutCocone.mk (pushout.desc (pushout.inl g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) (CategoryStruct.comp (pushout.inl gā‚ƒ gā‚„) (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„)))) ⋯) (CategoryStruct.comp (pushout.inr gā‚ƒ gā‚„) (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„)))) ⋯)

                  X₁ ⨿[Z₁] (Xā‚‚ ⨿[Zā‚‚] Xā‚ƒ) is the pushout (X₁ ⨿[Z₁] Xā‚‚) ⨿[Zā‚‚] Xā‚ƒ.

                  Instances For
                    theorem CategoryTheory.Limits.hasPushout_assoc_symm {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                    HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„
                    noncomputable def CategoryTheory.Limits.pushoutAssoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                    pushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„ ≅ pushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))

                    The canonical isomorphism (X₁ ⨿[Z₁] Xā‚‚) ⨿[Zā‚‚] Xā‚ƒ ≅ X₁ ⨿[Z₁] (Xā‚‚ ⨿[Zā‚‚] Xā‚ƒ).

                    Instances For
                      @[simp]
                      theorem CategoryTheory.Limits.inl_inl_pushoutAssoc_hom {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                      CategoryStruct.comp (pushout.inl g₁ gā‚‚) (CategoryStruct.comp (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).hom) = pushout.inl g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))
                      @[simp]
                      theorem CategoryTheory.Limits.inl_inl_pushoutAssoc_hom_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] {Z : C} (h : pushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„)) ⟶ Z) :
                      CategoryStruct.comp (pushout.inl g₁ gā‚‚) (CategoryStruct.comp (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) (CategoryStruct.comp (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).hom h)) = CategoryStruct.comp (pushout.inl g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) h
                      @[simp]
                      theorem CategoryTheory.Limits.inr_inl_pushoutAssoc_hom {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                      CategoryStruct.comp (pushout.inr g₁ gā‚‚) (CategoryStruct.comp (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).hom) = CategoryStruct.comp (pushout.inl gā‚ƒ gā‚„) (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„)))
                      @[simp]
                      theorem CategoryTheory.Limits.inr_inl_pushoutAssoc_hom_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] {Z : C} (h : pushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„)) ⟶ Z) :
                      CategoryStruct.comp (pushout.inr g₁ gā‚‚) (CategoryStruct.comp (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) (CategoryStruct.comp (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).hom h)) = CategoryStruct.comp (pushout.inl gā‚ƒ gā‚„) (CategoryStruct.comp (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) h)
                      @[simp]
                      theorem CategoryTheory.Limits.inr_inr_pushoutAssoc_inv {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                      CategoryStruct.comp (pushout.inr gā‚ƒ gā‚„) (CategoryStruct.comp (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).inv) = pushout.inr (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„
                      @[simp]
                      theorem CategoryTheory.Limits.inr_inr_pushoutAssoc_inv_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] {Z : C} (h : pushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„ ⟶ Z) :
                      CategoryStruct.comp (pushout.inr gā‚ƒ gā‚„) (CategoryStruct.comp (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) (CategoryStruct.comp (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).inv h)) = CategoryStruct.comp (pushout.inr (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) h
                      @[simp]
                      theorem CategoryTheory.Limits.inl_pushoutAssoc_inv {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                      CategoryStruct.comp (pushout.inl g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).inv = CategoryStruct.comp (pushout.inl g₁ gā‚‚) (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„)
                      @[simp]
                      theorem CategoryTheory.Limits.inl_pushoutAssoc_inv_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] {Z : C} (h : pushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„ ⟶ Z) :
                      CategoryStruct.comp (pushout.inl g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) (CategoryStruct.comp (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).inv h) = CategoryStruct.comp (pushout.inl g₁ gā‚‚) (CategoryStruct.comp (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) h)
                      @[simp]
                      theorem CategoryTheory.Limits.inl_inr_pushoutAssoc_inv {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                      CategoryStruct.comp (pushout.inl gā‚ƒ gā‚„) (CategoryStruct.comp (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).inv) = CategoryStruct.comp (pushout.inr g₁ gā‚‚) (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„)
                      @[simp]
                      theorem CategoryTheory.Limits.inl_inr_pushoutAssoc_inv_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] {Z : C} (h : pushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„ ⟶ Z) :
                      CategoryStruct.comp (pushout.inl gā‚ƒ gā‚„) (CategoryStruct.comp (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) (CategoryStruct.comp (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).inv h)) = CategoryStruct.comp (pushout.inr g₁ gā‚‚) (CategoryStruct.comp (pushout.inl (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) h)
                      @[simp]
                      theorem CategoryTheory.Limits.inr_pushoutAssoc_hom {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] :
                      CategoryStruct.comp (pushout.inr (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).hom = CategoryStruct.comp (pushout.inr gā‚ƒ gā‚„) (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„)))
                      @[simp]
                      theorem CategoryTheory.Limits.inr_pushoutAssoc_hom_assoc {C : Type u} [Category.{v, u} C] {X₁ Xā‚‚ Xā‚ƒ Z₁ Zā‚‚ : C} (g₁ : Z₁ ⟶ X₁) (gā‚‚ : Z₁ ⟶ Xā‚‚) (gā‚ƒ : Zā‚‚ ⟶ Xā‚‚) (gā‚„ : Zā‚‚ ⟶ Xā‚ƒ) [HasPushout g₁ gā‚‚] [HasPushout gā‚ƒ gā‚„] [HasPushout (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„] [HasPushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))] {Z : C} (h : pushout g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„)) ⟶ Z) :
                      CategoryStruct.comp (pushout.inr (CategoryStruct.comp gā‚ƒ (pushout.inr g₁ gā‚‚)) gā‚„) (CategoryStruct.comp (pushoutAssoc g₁ gā‚‚ gā‚ƒ gā‚„).hom h) = CategoryStruct.comp (pushout.inr gā‚ƒ gā‚„) (CategoryStruct.comp (pushout.inr g₁ (CategoryStruct.comp gā‚‚ (pushout.inl gā‚ƒ gā‚„))) h)