Documentation

Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc

Associativity of pullbacks #

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

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ā‚ƒ).

Equations
    Instances For
      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ā‚ƒ).

      Equations
        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ā‚‚)
          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ā‚ƒ).

          Equations
            Instances For
              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ā‚ƒ.

              Equations
                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ā‚ƒ).

                  Equations
                    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)
                      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ā‚ƒ).

                      Equations
                        Instances For
                          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ā‚ƒ).

                          Equations
                            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ā‚„))
                              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ā‚ƒ).

                              Equations
                                Instances For
                                  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ā‚ƒ.

                                  Equations
                                    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ā‚ƒ).

                                      Equations
                                        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)