File: Mathlib/CategoryTheory/CatCommSq.lean

full_name: CategoryTheory.CatCommSq.iso'
code: /-- `CatCommSq T L R B` expresses that there is a 2-commutative square of functors, where
the functors `T`, `L`, `R` and `B` are respectively the left, top, right and bottom functors
of the square. -/
@[ext]
class CatCommSq where
  /-- the isomorphism corresponding to a 2-commutative diagram -/
  iso' : T ⋙ R ≅ L ⋙ B
goal: T.comp R ≅ L.comp B

full_name: CategoryTheory.CatCommSq
code: /-- `CatCommSq T L R B` expresses that there is a 2-commutative square of functors, where
the functors `T`, `L`, `R` and `B` are respectively the left, top, right and bottom functors
of the square. -/
@[ext]
class CatCommSq where
  /-- the isomorphism corresponding to a 2-commutative diagram -/
  iso' : T ⋙ R ≅ L ⋙ B
goal: Type (max u_1 u_10)

full_name: CategoryTheory.CatCommSq.iso
code: /-- Assuming `[CatCommSq T L R B]`, `iso T L R B` is the isomorphism `T ⋙ R ≅ L ⋙ B`
given by the 2-commutative square. -/
def iso [h : CatCommSq T L R B] : T ⋙ R ≅ L ⋙ B 
goal: T.comp R ≅ L.comp B

full_name: CategoryTheory.CatCommSq.hComp
code: /-- Horizontal composition of 2-commutative squares -/
@[simps! iso'_hom_app iso'_inv_app]
def hComp (T₁ : C₁ ⥤ C₂) (T₂ : C₂ ⥤ C₃) (V₁ : C₁ ⥤ C₄) (V₂ : C₂ ⥤ C₅) (V₃ : C₃ ⥤ C₆)
    (B₁ : C₄ ⥤ C₅) (B₂ : C₅ ⥤ C₆) [CatCommSq T₁ V₁ V₂ B₁] [CatCommSq T₂ V₂ V₃ B₂] :
    CatCommSq (T₁ ⋙ T₂) V₁ V₃ (B₁ ⋙ B₂) 
goal: CategoryTheory.CatCommSq (T₁.comp T₂) V₁ V₃ (B₁.comp B₂)

full_name: CategoryTheory.CatCommSq.hComp_iso'_inv_app
code: /-- Horizontal composition of 2-commutative squares -/
@[simps! iso'_hom_app iso'_inv_app]
def hComp (T₁ : C₁ ⥤ C₂) (T₂ : C₂ ⥤ C₃) (V₁ : C₁ ⥤ C₄) (V₂ : C₂ ⥤ C₅) (V₃ : C₃ ⥤ C₆)
    (B₁ : C₄ ⥤ C₅) (B₂ : C₅ ⥤ C₆) [CatCommSq T₁ V₁ V₂ B₁] [CatCommSq T₂ V₂ V₃ B₂] :
    CatCommSq (T₁ ⋙ T₂) V₁ V₃ (B₁ ⋙ B₂) 
goal: CategoryTheory.CatCommSq.iso'.inv.app X =
  CategoryTheory.CategoryStruct.comp (B₂.map ((CategoryTheory.CatCommSq.iso T₁ V₁ V₂ B₁).inv.app X))
    ((CategoryTheory.CatCommSq.iso T₂ V₂ V₃ B₂).inv.app (T₁.obj X))

full_name: CategoryTheory.CatCommSq.hComp_iso'_hom_app
code: /-- Horizontal composition of 2-commutative squares -/
@[simps! iso'_hom_app iso'_inv_app]
def hComp (T₁ : C₁ ⥤ C₂) (T₂ : C₂ ⥤ C₃) (V₁ : C₁ ⥤ C₄) (V₂ : C₂ ⥤ C₅) (V₃ : C₃ ⥤ C₆)
    (B₁ : C₄ ⥤ C₅) (B₂ : C₅ ⥤ C₆) [CatCommSq T₁ V₁ V₂ B₁] [CatCommSq T₂ V₂ V₃ B₂] :
    CatCommSq (T₁ ⋙ T₂) V₁ V₃ (B₁ ⋙ B₂) 
goal: CategoryTheory.CatCommSq.iso'.hom.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.CatCommSq.iso T₂ V₂ V₃ B₂).hom.app (T₁.obj X))
    (B₂.map ((CategoryTheory.CatCommSq.iso T₁ V₁ V₂ B₁).hom.app X))

full_name: CategoryTheory.CatCommSq.vComp_iso'_inv_app
code: /-- Vertical composition of 2-commutative squares -/
@[simps! iso'_hom_app iso'_inv_app]
def vComp (L₁ : C₁ ⥤ C₂) (L₂ : C₂ ⥤ C₃) (H₁ : C₁ ⥤ C₄) (H₂ : C₂ ⥤ C₅) (H₃ : C₃ ⥤ C₆)
    (R₁ : C₄ ⥤ C₅) (R₂ : C₅ ⥤ C₆) [CatCommSq H₁ L₁ R₁ H₂] [CatCommSq H₂ L₂ R₂ H₃] :
    CatCommSq H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃ 
goal: CategoryTheory.CatCommSq.iso'.inv.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.CatCommSq.iso H₂ L₂ R₂ H₃).inv.app (L₁.obj X))
    (R₂.map ((CategoryTheory.CatCommSq.iso H₁ L₁ R₁ H₂).inv.app X))

full_name: CategoryTheory.CatCommSq.vComp
code: /-- Vertical composition of 2-commutative squares -/
@[simps! iso'_hom_app iso'_inv_app]
def vComp (L₁ : C₁ ⥤ C₂) (L₂ : C₂ ⥤ C₃) (H₁ : C₁ ⥤ C₄) (H₂ : C₂ ⥤ C₅) (H₃ : C₃ ⥤ C₆)
    (R₁ : C₄ ⥤ C₅) (R₂ : C₅ ⥤ C₆) [CatCommSq H₁ L₁ R₁ H₂] [CatCommSq H₂ L₂ R₂ H₃] :
    CatCommSq H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃ 
goal: CategoryTheory.CatCommSq H₁ (L₁.comp L₂) (R₁.comp R₂) H₃

full_name: CategoryTheory.CatCommSq.vComp_iso'_hom_app
code: /-- Vertical composition of 2-commutative squares -/
@[simps! iso'_hom_app iso'_inv_app]
def vComp (L₁ : C₁ ⥤ C₂) (L₂ : C₂ ⥤ C₃) (H₁ : C₁ ⥤ C₄) (H₂ : C₂ ⥤ C₅) (H₃ : C₃ ⥤ C₆)
    (R₁ : C₄ ⥤ C₅) (R₂ : C₅ ⥤ C₆) [CatCommSq H₁ L₁ R₁ H₂] [CatCommSq H₂ L₂ R₂ H₃] :
    CatCommSq H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃ 
goal: CategoryTheory.CatCommSq.iso'.hom.app X =
  CategoryTheory.CategoryStruct.comp (R₂.map ((CategoryTheory.CatCommSq.iso H₁ L₁ R₁ H₂).hom.app X))
    ((CategoryTheory.CatCommSq.iso H₂ L₂ R₂ H₃).hom.app (L₁.obj X))

full_name: CategoryTheory.CatCommSq.hInv_iso'_hom_app
code: /-- Horizontal inverse of a 2-commutative square -/
@[simps! iso'_hom_app iso'_inv_app]
def hInv (_ : CatCommSq T.functor L R B.functor) : CatCommSq T.inverse R L B.inverse 
goal: ∀ (x : CategoryTheory.CatCommSq T.functor L R B.functor) (X : C₂),
  CategoryTheory.CatCommSq.iso'.hom.app X =
    CategoryTheory.CategoryStruct.comp (B.unitIso.hom.app (L.obj (T.inverse.obj X)))
      (CategoryTheory.CategoryStruct.comp
        (B.inverse.map ((CategoryTheory.CatCommSq.iso T.functor L R B.functor).inv.app (T.inverse.obj X)))
        (B.inverse.map (R.map (T.counitIso.hom.app X))))

full_name: CategoryTheory.CatCommSq.hInv
code: /-- Horizontal inverse of a 2-commutative square -/
@[simps! iso'_hom_app iso'_inv_app]
def hInv (_ : CatCommSq T.functor L R B.functor) : CatCommSq T.inverse R L B.inverse 
goal: CategoryTheory.CatCommSq T.functor L R B.functor → CategoryTheory.CatCommSq T.inverse R L B.inverse

full_name: CategoryTheory.CatCommSq.hInv_iso'_inv_app
code: /-- Horizontal inverse of a 2-commutative square -/
@[simps! iso'_hom_app iso'_inv_app]
def hInv (_ : CatCommSq T.functor L R B.functor) : CatCommSq T.inverse R L B.inverse 
goal: ∀ (x : CategoryTheory.CatCommSq T.functor L R B.functor) (X : C₂),
  CategoryTheory.CatCommSq.iso'.inv.app X =
    CategoryTheory.CategoryStruct.comp (B.inverse.map (R.map (T.counitIso.inv.app X)))
      (CategoryTheory.CategoryStruct.comp
        (B.inverse.map ((CategoryTheory.CatCommSq.iso T.functor L R B.functor).hom.app (T.inverse.obj X)))
        (B.unitIso.inv.app (L.obj (T.inverse.obj X))))

full_name: CategoryTheory.CatCommSq.hInv_hInv
code: lemma hInv_hInv (h : CatCommSq T.functor L R B.functor) :
    hInv T.symm R L B.symm (hInv T L R B h) = h 
goal: CategoryTheory.CatCommSq.hInv T.symm R L B.symm (CategoryTheory.CatCommSq.hInv T L R B h) = h

full_name: CategoryTheory.CatCommSq.hInvEquiv
code: /-- In a square of categories, when the top and bottom functors are part
of equivalence of categories, it is equivalent to show 2-commutativity for
the functors of these equivalences or for their inverses. -/
def hInvEquiv : CatCommSq T.functor L R B.functor ≃ CatCommSq T.inverse R L B.inverse 
goal: CategoryTheory.CatCommSq T.functor L R B.functor ≃ CategoryTheory.CatCommSq T.inverse R L B.inverse

full_name: CategoryTheory.CatCommSq.vInv_iso'_hom_app
code: /-- Vertical inverse of a 2-commutative square -/
@[simps! iso'_hom_app iso'_inv_app]
def vInv (_ : CatCommSq T L.functor R.functor B) : CatCommSq B L.inverse R.inverse T 
goal: ∀ (x : CategoryTheory.CatCommSq T L.functor R.functor B) (X : C₃),
  CategoryTheory.CatCommSq.iso'.hom.app X =
    CategoryTheory.CategoryStruct.comp (R.inverse.map (B.map (L.counitIso.inv.app X)))
      (CategoryTheory.CategoryStruct.comp
        (R.inverse.map ((CategoryTheory.CatCommSq.iso T L.functor R.functor B).inv.app (L.inverse.obj X)))
        (R.unitIso.inv.app (T.obj (L.inverse.obj X))))

full_name: CategoryTheory.CatCommSq.vInv
code: /-- Vertical inverse of a 2-commutative square -/
@[simps! iso'_hom_app iso'_inv_app]
def vInv (_ : CatCommSq T L.functor R.functor B) : CatCommSq B L.inverse R.inverse T 
goal: CategoryTheory.CatCommSq T L.functor R.functor B → CategoryTheory.CatCommSq B L.inverse R.inverse T

full_name: CategoryTheory.CatCommSq.vInv_iso'_inv_app
code: /-- Vertical inverse of a 2-commutative square -/
@[simps! iso'_hom_app iso'_inv_app]
def vInv (_ : CatCommSq T L.functor R.functor B) : CatCommSq B L.inverse R.inverse T 
goal: ∀ (x : CategoryTheory.CatCommSq T L.functor R.functor B) (X : C₃),
  CategoryTheory.CatCommSq.iso'.inv.app X =
    CategoryTheory.CategoryStruct.comp (R.unitIso.hom.app (T.obj (L.inverse.obj X)))
      (CategoryTheory.CategoryStruct.comp
        (R.inverse.map ((CategoryTheory.CatCommSq.iso T L.functor R.functor B).hom.app (L.inverse.obj X)))
        (R.inverse.map (B.map (L.counitIso.hom.app X))))

full_name: CategoryTheory.CatCommSq.vInv_vInv
code: lemma vInv_vInv (h : CatCommSq T L.functor R.functor B) :
    vInv B L.symm R.symm T (vInv T L R B h) = h 
goal: CategoryTheory.CatCommSq.vInv B L.symm R.symm T (CategoryTheory.CatCommSq.vInv T L R B h) = h

full_name: CategoryTheory.CatCommSq.vInvEquiv
code: /-- In a square of categories, when the left and right functors are part
of equivalence of categories, it is equivalent to show 2-commutativity for
the functors of these equivalences or for their inverses. -/
def vInvEquiv : CatCommSq T L.functor R.functor B ≃ CatCommSq B L.inverse R.inverse T 
goal: CategoryTheory.CatCommSq T L.functor R.functor B ≃ CategoryTheory.CatCommSq B L.inverse R.inverse T