File: Mathlib/CategoryTheory/Limits/Preserves/Limits.lean

full_name: CategoryTheory.preserves_lift_mapCone
code: @[simp]
theorem preserves_lift_mapCone (c₁ c₂ : Cone F) (t : IsLimit c₁) :
    (PreservesLimit.preserves t).lift (G.mapCone c₂) = G.map (t.lift c₂) 
goal: (CategoryTheory.Limits.PreservesLimit.preserves t).lift (G.mapCone c₂) = G.map (t.lift c₂)

full_name: CategoryTheory.preservesLimitIso
code: /-- If `G` preserves limits, we have an isomorphism from the image of the limit of a functor `F`
to the limit of the functor `F ⋙ G`.
-/
def preservesLimitIso : G.obj (limit F) ≅ limit (F ⋙ G) 
goal: G.obj (CategoryTheory.Limits.limit F) ≅ CategoryTheory.Limits.limit (F.comp G)

full_name: CategoryTheory.preservesLimitsIso_hom_π
code: @[reassoc (attr := simp)]
theorem preservesLimitsIso_hom_π (j) :
    (preservesLimitIso G F).hom ≫ limit.π _ j = G.map (limit.π F j) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.preservesLimitIso G F).hom
    (CategoryTheory.Limits.limit.π (F.comp G) j) =
  G.map (CategoryTheory.Limits.limit.π F j)

full_name: CategoryTheory.preservesLimitsIso_inv_π
code: @[reassoc (attr := simp)]
theorem preservesLimitsIso_inv_π (j) :
    (preservesLimitIso G F).inv ≫ G.map (limit.π F j) = limit.π _ j 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.preservesLimitIso G F).inv
    (G.map (CategoryTheory.Limits.limit.π F j)) =
  CategoryTheory.Limits.limit.π (F.comp G) j

full_name: CategoryTheory.lift_comp_preservesLimitsIso_hom
code: @[reassoc (attr := simp)]
theorem lift_comp_preservesLimitsIso_hom (t : Cone F) :
    G.map (limit.lift _ t) ≫ (preservesLimitIso G F).hom =
    limit.lift (F ⋙ G) (G.mapCone _) 
goal: CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Limits.limit.lift F t))
    (CategoryTheory.preservesLimitIso G F).hom =
  CategoryTheory.Limits.limit.lift (F.comp G) (G.mapCone t)

full_name: CategoryTheory.instIsIsoPost
code: instance : IsIso (limit.post F G) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.limit.post F G)

full_name: CategoryTheory.preservesLimitNatIso_inv_app
code: /-- If `C, D` has all limits of shape `J`, and `G` preserves them, then `preservesLimitsIso` is
functorial wrt `F`. -/
@[simps!]
def preservesLimitNatIso : lim ⋙ G ≅ (whiskeringRight J C D).obj G ⋙ lim 
goal: (CategoryTheory.preservesLimitNatIso G).inv.app X = (CategoryTheory.preservesLimitIso G X).inv

full_name: CategoryTheory.preservesLimitNatIso
code: /-- If `C, D` has all limits of shape `J`, and `G` preserves them, then `preservesLimitsIso` is
functorial wrt `F`. -/
@[simps!]
def preservesLimitNatIso : lim ⋙ G ≅ (whiskeringRight J C D).obj G ⋙ lim 
goal: CategoryTheory.Limits.lim.comp G ≅ ((CategoryTheory.whiskeringRight J C D).obj G).comp CategoryTheory.Limits.lim

full_name: CategoryTheory.preservesLimitNatIso_hom_app
code: /-- If `C, D` has all limits of shape `J`, and `G` preserves them, then `preservesLimitsIso` is
functorial wrt `F`. -/
@[simps!]
def preservesLimitNatIso : lim ⋙ G ≅ (whiskeringRight J C D).obj G ⋙ lim 
goal: (CategoryTheory.preservesLimitNatIso G).hom.app X = (CategoryTheory.preservesLimitIso G X).hom

full_name: CategoryTheory.preservesLimitOfIsIsoPost
code: /-- If the comparison morphism `G.obj (limit F) ⟶ limit (F ⋙ G)` is an isomorphism, then `G`
    preserves limits of `F`. -/
def preservesLimitOfIsIsoPost [IsIso (limit.post F G)] : PreservesLimit F G 
goal: CategoryTheory.Limits.PreservesLimit F G

full_name: CategoryTheory.preserves_desc_mapCocone
code: @[simp]
theorem preserves_desc_mapCocone (c₁ c₂ : Cocone F) (t : IsColimit c₁) :
    (PreservesColimit.preserves t).desc (G.mapCocone _) = G.map (t.desc c₂) 
goal: (CategoryTheory.Limits.PreservesColimit.preserves t).desc (G.mapCocone c₂) = G.map (t.desc c₂)

full_name: CategoryTheory.preservesColimitIso
code: /-- If `G` preserves colimits, we have an isomorphism from the image of the colimit of a functor `F`
to the colimit of the functor `F ⋙ G`.
-/
def preservesColimitIso : G.obj (colimit F) ≅ colimit (F ⋙ G) 
goal: G.obj (CategoryTheory.Limits.colimit F) ≅ CategoryTheory.Limits.colimit (F.comp G)

full_name: CategoryTheory.ι_preservesColimitsIso_inv
code: @[reassoc (attr := simp)]
theorem ι_preservesColimitsIso_inv (j : J) :
    colimit.ι _ j ≫ (preservesColimitIso G F).inv = G.map (colimit.ι F j) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι (F.comp G) j)
    (CategoryTheory.preservesColimitIso G F).inv =
  G.map (CategoryTheory.Limits.colimit.ι F j)

full_name: CategoryTheory.ι_preservesColimitsIso_hom
code: @[reassoc (attr := simp)]
theorem ι_preservesColimitsIso_hom (j : J) :
    G.map (colimit.ι F j) ≫ (preservesColimitIso G F).hom = colimit.ι (F ⋙ G) j 
goal: CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Limits.colimit.ι F j))
    (CategoryTheory.preservesColimitIso G F).hom =
  CategoryTheory.Limits.colimit.ι (F.comp G) j

full_name: CategoryTheory.preservesColimitsIso_inv_comp_desc
code: @[reassoc (attr := simp)]
theorem preservesColimitsIso_inv_comp_desc (t : Cocone F) :
    (preservesColimitIso G F).inv ≫ G.map (colimit.desc _ t) =
    colimit.desc _ (G.mapCocone t) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.preservesColimitIso G F).inv
    (G.map (CategoryTheory.Limits.colimit.desc F t)) =
  CategoryTheory.Limits.colimit.desc (F.comp G) (G.mapCocone t)

full_name: CategoryTheory.instIsIsoPost_1
code: instance : IsIso (colimit.post F G) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.colimit.post F G)

full_name: CategoryTheory.preservesColimitNatIso
code: /-- If `C, D` has all colimits of shape `J`, and `G` preserves them, then `preservesColimitIso`
is functorial wrt `F`. -/
@[simps!]
def preservesColimitNatIso : colim ⋙ G ≅ (whiskeringRight J C D).obj G ⋙ colim 
goal: CategoryTheory.Limits.colim.comp G ≅ ((CategoryTheory.whiskeringRight J C D).obj G).comp CategoryTheory.Limits.colim

full_name: CategoryTheory.preservesColimitNatIso_inv_app
code: /-- If `C, D` has all colimits of shape `J`, and `G` preserves them, then `preservesColimitIso`
is functorial wrt `F`. -/
@[simps!]
def preservesColimitNatIso : colim ⋙ G ≅ (whiskeringRight J C D).obj G ⋙ colim 
goal: (CategoryTheory.preservesColimitNatIso G).inv.app X = (CategoryTheory.preservesColimitIso G X).inv

full_name: CategoryTheory.preservesColimitNatIso_hom_app
code: /-- If `C, D` has all colimits of shape `J`, and `G` preserves them, then `preservesColimitIso`
is functorial wrt `F`. -/
@[simps!]
def preservesColimitNatIso : colim ⋙ G ≅ (whiskeringRight J C D).obj G ⋙ colim 
goal: (CategoryTheory.preservesColimitNatIso G).hom.app X = (CategoryTheory.preservesColimitIso G X).hom

full_name: CategoryTheory.preservesColimitOfIsIsoPost
code: /-- If the comparison morphism `colimit (F ⋙ G) ⟶ G.obj (colimit F)` is an isomorphism, then `G`
    preserves colimits of `F`. -/
def preservesColimitOfIsIsoPost [IsIso (colimit.post F G)] : PreservesColimit F G 
goal: CategoryTheory.Limits.PreservesColimit F G