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

full_name: CategoryTheory.Limits.isLimitMapConeBinaryFanEquiv
code: /--
The map of a binary fan is a limit iff the fork consisting of the mapped morphisms is a limit. This
essentially lets us commute `BinaryFan.mk` with `Functor.mapCone`.
-/
def isLimitMapConeBinaryFanEquiv :
    IsLimit (G.mapCone (BinaryFan.mk f g)) ≃ IsLimit (BinaryFan.mk (G.map f) (G.map g)) 
goal: CategoryTheory.Limits.IsLimit (G.mapCone (CategoryTheory.Limits.BinaryFan.mk f g)) ≃
  CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk (G.map f) (G.map g))

full_name: CategoryTheory.Limits.mapIsLimitOfPreservesOfIsLimit
code: /-- The property of preserving products expressed in terms of binary fans. -/
def mapIsLimitOfPreservesOfIsLimit [PreservesLimit (pair X Y) G] (l : IsLimit (BinaryFan.mk f g)) :
    IsLimit (BinaryFan.mk (G.map f) (G.map g)) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk (G.map f) (G.map g))

full_name: CategoryTheory.Limits.isLimitOfReflectsOfMapIsLimit
code: /-- The property of reflecting products expressed in terms of binary fans. -/
def isLimitOfReflectsOfMapIsLimit [ReflectsLimit (pair X Y) G]
    (l : IsLimit (BinaryFan.mk (G.map f) (G.map g))) : IsLimit (BinaryFan.mk f g) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk f g)

full_name: CategoryTheory.Limits.isLimitOfHasBinaryProductOfPreservesLimit
code: /-- If `G` preserves binary products and `C` has them, then the binary fan constructed of the mapped
morphisms of the binary product cone is a limit.
-/
def isLimitOfHasBinaryProductOfPreservesLimit [PreservesLimit (pair X Y) G] :
    IsLimit (BinaryFan.mk (G.map (Limits.prod.fst : X ⨯ Y ⟶ X)) (G.map Limits.prod.snd)) 
goal: CategoryTheory.Limits.IsLimit
  (CategoryTheory.Limits.BinaryFan.mk (G.map CategoryTheory.Limits.prod.fst) (G.map CategoryTheory.Limits.prod.snd))

full_name: CategoryTheory.Limits.PreservesLimitPair.ofIsoProdComparison
code: /-- If the product comparison map for `G` at `(X,Y)` is an isomorphism, then `G` preserves the
pair of `(X,Y)`.
-/
def PreservesLimitPair.ofIsoProdComparison [i : IsIso (prodComparison G X Y)] :
    PreservesLimit (pair X Y) G 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.pair X Y) G

full_name: CategoryTheory.Limits.PreservesLimitPair.iso
code: /-- If `G` preserves the product of `(X,Y)`, then the product comparison map for `G` at `(X,Y)` is
an isomorphism.
-/
def PreservesLimitPair.iso : G.obj (X ⨯ Y) ≅ G.obj X ⨯ G.obj Y 
goal: G.obj (X ⨯ Y) ≅ G.obj X ⨯ G.obj Y

full_name: CategoryTheory.Limits.PreservesLimitPair.iso_hom
code: @[simp]
theorem PreservesLimitPair.iso_hom : (PreservesLimitPair.iso G X Y).hom = prodComparison G X Y 
goal: (CategoryTheory.Limits.PreservesLimitPair.iso G X Y).hom = CategoryTheory.Limits.prodComparison G X Y

full_name: CategoryTheory.Limits.PreservesLimitPair.iso_inv_fst
code: @[simp]
theorem PreservesLimitPair.iso_inv_fst :
    (PreservesLimitPair.iso G X Y).inv ≫ G.map prod.fst = prod.fst 
goal: (CategoryTheory.Limits.PreservesLimitPair.iso G X Y).inv ≫ G.map CategoryTheory.Limits.prod.fst =
  CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.PreservesLimitPair.iso_inv_snd
code: @[simp]
theorem PreservesLimitPair.iso_inv_snd :
    (PreservesLimitPair.iso G X Y).inv ≫ G.map prod.snd = prod.snd 
goal: (CategoryTheory.Limits.PreservesLimitPair.iso G X Y).inv ≫ G.map CategoryTheory.Limits.prod.snd =
  CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Limits.instIsIsoProdComparison
code: instance : IsIso (prodComparison G X Y) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.prodComparison G X Y)

full_name: CategoryTheory.Limits.isColimitMapCoconeBinaryCofanEquiv
code: /-- The map of a binary cofan is a colimit iff
the cofork consisting of the mapped morphisms is a colimit.
This essentially lets us commute `BinaryCofan.mk` with `Functor.mapCocone`.
-/
def isColimitMapCoconeBinaryCofanEquiv :
    IsColimit (Functor.mapCocone G (BinaryCofan.mk f g))
    ≃ IsColimit (BinaryCofan.mk (G.map f) (G.map g)) 
goal: CategoryTheory.Limits.IsColimit (G.mapCocone (CategoryTheory.Limits.BinaryCofan.mk f g)) ≃
  CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk (G.map f) (G.map g))

full_name: CategoryTheory.Limits.mapIsColimitOfPreservesOfIsColimit
code: /-- The property of preserving coproducts expressed in terms of binary cofans. -/
def mapIsColimitOfPreservesOfIsColimit [PreservesColimit (pair X Y) G]
    (l : IsColimit (BinaryCofan.mk f g)) : IsColimit (BinaryCofan.mk (G.map f) (G.map g)) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk (G.map f) (G.map g))

full_name: CategoryTheory.Limits.isColimitOfReflectsOfMapIsColimit
code: /-- The property of reflecting coproducts expressed in terms of binary cofans. -/
def isColimitOfReflectsOfMapIsColimit [ReflectsColimit (pair X Y) G]
    (l : IsColimit (BinaryCofan.mk (G.map f) (G.map g))) : IsColimit (BinaryCofan.mk f g) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk f g)

full_name: CategoryTheory.Limits.isColimitOfHasBinaryCoproductOfPreservesColimit
code: /--
If `G` preserves binary coproducts and `C` has them, then the binary cofan constructed of the mapped
morphisms of the binary product cocone is a colimit.
-/
def isColimitOfHasBinaryCoproductOfPreservesColimit [PreservesColimit (pair X Y) G] :
    IsColimit (BinaryCofan.mk (G.map (Limits.coprod.inl : X ⟶ X ⨿ Y)) (G.map Limits.coprod.inr)) 
goal: CategoryTheory.Limits.IsColimit
  (CategoryTheory.Limits.BinaryCofan.mk (G.map CategoryTheory.Limits.coprod.inl)
    (G.map CategoryTheory.Limits.coprod.inr))

full_name: CategoryTheory.Limits.PreservesColimitPair.ofIsoCoprodComparison
code: /-- If the coproduct comparison map for `G` at `(X,Y)` is an isomorphism, then `G` preserves the
pair of `(X,Y)`.
-/
def PreservesColimitPair.ofIsoCoprodComparison [i : IsIso (coprodComparison G X Y)] :
    PreservesColimit (pair X Y) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.pair X Y) G

full_name: CategoryTheory.Limits.PreservesColimitPair.iso
code: /--
If `G` preserves the coproduct of `(X,Y)`, then the coproduct comparison map for `G` at `(X,Y)` is
an isomorphism.
-/
def PreservesColimitPair.iso : G.obj X ⨿ G.obj Y ≅ G.obj (X ⨿ Y) 
goal: G.obj X ⨿ G.obj Y ≅ G.obj (X ⨿ Y)

full_name: CategoryTheory.Limits.PreservesColimitPair.iso_hom
code: @[simp]
theorem PreservesColimitPair.iso_hom :
    (PreservesColimitPair.iso G X Y).hom = coprodComparison G X Y 
goal: (CategoryTheory.Limits.PreservesColimitPair.iso G X Y).hom = CategoryTheory.Limits.coprodComparison G X Y

full_name: CategoryTheory.Limits.instIsIsoCoprodComparison
code: instance : IsIso (coprodComparison G X Y) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.coprodComparison G X Y)