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

full_name: CategoryTheory.Limits.PullbackCone.map
code: /-- The image of a pullback cone by a functor. -/
abbrev map : PullbackCone (G.map f) (G.map g) 
goal: CategoryTheory.Limits.PullbackCone (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PullbackCone.isLimitMapConeEquiv
code: /-- The map (as a cone) of a pullback cone is limit iff
the map (as a pullback cone) is limit. -/
def isLimitMapConeEquiv :
    IsLimit (mapCone G c) ≃ IsLimit (c.map G) 
goal: CategoryTheory.Limits.IsLimit (G.mapCone c) ≃ CategoryTheory.Limits.IsLimit (c.map G)

full_name: CategoryTheory.Limits.isLimitMapConePullbackConeEquiv
code: /-- The map of a pullback cone is a limit iff the fork consisting of the mapped morphisms is a
limit. This essentially lets us commute `PullbackCone.mk` with `Functor.mapCone`. -/
def isLimitMapConePullbackConeEquiv :
    IsLimit (mapCone G (PullbackCone.mk h k comm)) ≃
      IsLimit
        (PullbackCone.mk (G.map h) (G.map k) (by simp only [← G.map_comp, comm]) :
          PullbackCone (G.map f) (G.map g)) 
goal: CategoryTheory.Limits.IsLimit (G.mapCone (CategoryTheory.Limits.PullbackCone.mk h k comm)) ≃
  CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk (G.map h) (G.map k) ⋯)

full_name: CategoryTheory.Limits.isLimitPullbackConeMapOfIsLimit
code: /-- The property of preserving pullbacks expressed in terms of binary fans. -/
def isLimitPullbackConeMapOfIsLimit [PreservesLimit (cospan f g) G]
    (l : IsLimit (PullbackCone.mk h k comm)) :
    have : G.map h ≫ G.map f = G.map k ≫ G.map g := by rw [← G.map_comp, ← G.map_comp,comm]
    IsLimit (PullbackCone.mk (G.map h) (G.map k) this) 
goal: let_fun this := ⋯;
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk (G.map h) (G.map k) this)

full_name: CategoryTheory.Limits.isLimitOfIsLimitPullbackConeMap
code: /-- The property of reflecting pullbacks expressed in terms of binary fans. -/
def isLimitOfIsLimitPullbackConeMap [ReflectsLimit (cospan f g) G]
    (l : IsLimit (PullbackCone.mk (G.map h) (G.map k) (show G.map h ≫ G.map f = G.map k ≫ G.map g
    from by simp only [← G.map_comp,comm]))) : IsLimit (PullbackCone.mk h k comm) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk h k comm)

full_name: CategoryTheory.Limits.isLimitOfHasPullbackOfPreservesLimit
code: /-- If `G` preserves pullbacks and `C` has them, then the pullback cone constructed of the mapped
morphisms of the pullback cone is a limit. -/
def isLimitOfHasPullbackOfPreservesLimit [HasPullback f g] :
    have : G.map (pullback.fst f g) ≫ G.map f = G.map (pullback.snd f g) ≫ G.map g := by
      simp only [← G.map_comp, pullback.condition]
    IsLimit (PullbackCone.mk (G.map (pullback.fst f g)) (G.map (pullback.snd f g)) this) 
goal: let_fun this := ⋯;
CategoryTheory.Limits.IsLimit
  (CategoryTheory.Limits.PullbackCone.mk (G.map (CategoryTheory.Limits.pullback.fst f g))
    (G.map (CategoryTheory.Limits.pullback.snd f g)) this)

full_name: CategoryTheory.Limits.preservesPullbackSymmetry
code: /-- If `F` preserves the pullback of `f, g`, it also preserves the pullback of `g, f`. -/
def preservesPullbackSymmetry : PreservesLimit (cospan g f) G 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan g f) G

full_name: CategoryTheory.Limits.hasPullback_of_preservesPullback
code: theorem hasPullback_of_preservesPullback [HasPullback f g] : HasPullback (G.map f) (G.map g) 
goal: CategoryTheory.Limits.HasPullback (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PreservesPullback.iso
code: /-- If `G` preserves the pullback of `(f,g)`, then the pullback comparison map for `G` at `(f,g)` is
an isomorphism. -/
def PreservesPullback.iso : G.obj (pullback f g) ≅ pullback (G.map f) (G.map g) 
goal: G.obj (CategoryTheory.Limits.pullback f g) ≅ CategoryTheory.Limits.pullback (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PreservesPullback.iso_hom
code: @[simp]
theorem PreservesPullback.iso_hom : (PreservesPullback.iso G f g).hom = pullbackComparison G f g 
goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).hom = CategoryTheory.Limits.pullbackComparison G f g

full_name: CategoryTheory.Limits.PreservesPullback.iso_hom_fst
code: @[reassoc]
theorem PreservesPullback.iso_hom_fst :
    (PreservesPullback.iso G f g).hom ≫ pullback.fst _ _ = G.map (pullback.fst f g) 
goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).hom ≫ CategoryTheory.Limits.pullback.fst (G.map f) (G.map g) =
  G.map (CategoryTheory.Limits.pullback.fst f g)

full_name: CategoryTheory.Limits.PreservesPullback.iso_hom_snd
code: @[reassoc]
theorem PreservesPullback.iso_hom_snd :
    (PreservesPullback.iso G f g).hom ≫ pullback.snd _ _ = G.map (pullback.snd f g) 
goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).hom ≫ CategoryTheory.Limits.pullback.snd (G.map f) (G.map g) =
  G.map (CategoryTheory.Limits.pullback.snd f g)

full_name: CategoryTheory.Limits.PreservesPullback.iso_inv_fst
code: @[reassoc (attr := simp)]
theorem PreservesPullback.iso_inv_fst :
    (PreservesPullback.iso G f g).inv ≫ G.map (pullback.fst f g) = pullback.fst _ _ 
goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).inv ≫ G.map (CategoryTheory.Limits.pullback.fst f g) =
  CategoryTheory.Limits.pullback.fst (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PreservesPullback.iso_inv_snd
code: @[reassoc (attr := simp)]
theorem PreservesPullback.iso_inv_snd :
    (PreservesPullback.iso G f g).inv ≫ G.map (pullback.snd f g) = pullback.snd _ _ 
goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).inv ≫ G.map (CategoryTheory.Limits.pullback.snd f g) =
  CategoryTheory.Limits.pullback.snd (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PullbackCone.isLimitCoyonedaEquiv
code: /-- A pullback cone in `C` is limit iff if it is so after the application
of `coyoneda.obj X` for all `X : Cᵒᵖ`. -/
def PullbackCone.isLimitCoyonedaEquiv (c : PullbackCone f g) :
    IsLimit c ≃ ∀ (X : Cᵒᵖ), IsLimit (c.map (coyoneda.obj X)) 
goal: CategoryTheory.Limits.IsLimit c ≃
  ((X_1 : Cᵒᵖ) → CategoryTheory.Limits.IsLimit (c.map (CategoryTheory.coyoneda.obj X_1)))

full_name: CategoryTheory.Limits.PushoutCocone.map
code: /-- The image of a pullback cone by a functor. -/
abbrev map : PushoutCocone (G.map f) (G.map g) 
goal: CategoryTheory.Limits.PushoutCocone (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PushoutCocone.isColimitMapCoconeEquiv
code: /-- The map (as a cocone) of a pushout cocone is colimit iff
the map (as a pushout cocone) is limit. -/
def isColimitMapCoconeEquiv :
    IsColimit (mapCocone G c) ≃ IsColimit (c.map G) 
goal: CategoryTheory.Limits.IsColimit (G.mapCocone c) ≃ CategoryTheory.Limits.IsColimit (c.map G)

full_name: CategoryTheory.Limits.isColimitMapCoconePushoutCoconeEquiv
code: /-- The map of a pushout cocone is a colimit iff the cofork consisting of the mapped morphisms is a
colimit. This essentially lets us commute `PushoutCocone.mk` with `Functor.mapCocone`. -/
def isColimitMapCoconePushoutCoconeEquiv :
    IsColimit (mapCocone G (PushoutCocone.mk h k comm)) ≃
      IsColimit
        (PushoutCocone.mk (G.map h) (G.map k) (by simp only [← G.map_comp, comm]) :
          PushoutCocone (G.map f) (G.map g)) 
goal: CategoryTheory.Limits.IsColimit (G.mapCocone (CategoryTheory.Limits.PushoutCocone.mk h k comm)) ≃
  CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.PushoutCocone.mk (G.map h) (G.map k) ⋯)

full_name: CategoryTheory.Limits.isColimitPushoutCoconeMapOfIsColimit
code: /-- The property of preserving pushouts expressed in terms of binary cofans. -/
def isColimitPushoutCoconeMapOfIsColimit [PreservesColimit (span f g) G]
    (l : IsColimit (PushoutCocone.mk h k comm)) :
    IsColimit (PushoutCocone.mk (G.map h) (G.map k) (show G.map f ≫ G.map h = G.map g ≫ G.map k
      from by simp only [← G.map_comp,comm] )) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.PushoutCocone.mk (G.map h) (G.map k) ⋯)

full_name: CategoryTheory.Limits.isColimitOfIsColimitPushoutCoconeMap
code: /-- The property of reflecting pushouts expressed in terms of binary cofans. -/
def isColimitOfIsColimitPushoutCoconeMap [ReflectsColimit (span f g) G]
    (l : IsColimit (PushoutCocone.mk (G.map h) (G.map k) (show G.map f ≫ G.map h =
      G.map g ≫ G.map k from by simp only [← G.map_comp,comm]))) :
    IsColimit (PushoutCocone.mk h k comm) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.PushoutCocone.mk h k comm)

full_name: CategoryTheory.Limits.isColimitOfHasPushoutOfPreservesColimit
code: /-- If `G` preserves pushouts and `C` has them, then the pushout cocone constructed of the mapped
morphisms of the pushout cocone is a colimit. -/
def isColimitOfHasPushoutOfPreservesColimit [i : HasPushout f g] :
    IsColimit (PushoutCocone.mk (G.map (pushout.inl _ _)) (G.map (@pushout.inr _ _ _ _ _ f g i))
    (show G.map f ≫ G.map (pushout.inl _ _) = G.map g ≫ G.map (pushout.inr _ _) from by
      simp only [← G.map_comp, pushout.condition])) 
goal: CategoryTheory.Limits.IsColimit
  (CategoryTheory.Limits.PushoutCocone.mk (G.map (CategoryTheory.Limits.pushout.inl f g))
    (G.map (CategoryTheory.Limits.pushout.inr f g)) ⋯)

full_name: CategoryTheory.Limits.preservesPushoutSymmetry
code: /-- If `F` preserves the pushout of `f, g`, it also preserves the pushout of `g, f`. -/
def preservesPushoutSymmetry : PreservesColimit (span g f) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span g f) G

full_name: CategoryTheory.Limits.hasPushout_of_preservesPushout
code: theorem hasPushout_of_preservesPushout [HasPushout f g] : HasPushout (G.map f) (G.map g) 
goal: CategoryTheory.Limits.HasPushout (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PreservesPushout.iso
code: /-- If `G` preserves the pushout of `(f,g)`, then the pushout comparison map for `G` at `(f,g)` is
an isomorphism. -/
def PreservesPushout.iso : pushout (G.map f) (G.map g) ≅ G.obj (pushout f g) 
goal: CategoryTheory.Limits.pushout (G.map f) (G.map g) ≅ G.obj (CategoryTheory.Limits.pushout f g)

full_name: CategoryTheory.Limits.PreservesPushout.iso_hom
code: @[simp]
theorem PreservesPushout.iso_hom : (PreservesPushout.iso G f g).hom = pushoutComparison G f g 
goal: (CategoryTheory.Limits.PreservesPushout.iso G f g).hom = CategoryTheory.Limits.pushoutComparison G f g

full_name: CategoryTheory.Limits.PreservesPushout.inl_iso_hom
code: @[reassoc]
theorem PreservesPushout.inl_iso_hom :
    pushout.inl _ _ ≫ (PreservesPushout.iso G f g).hom = G.map (pushout.inl _ _) 
goal: CategoryTheory.Limits.pushout.inl (G.map f) (G.map g) ≫ (CategoryTheory.Limits.PreservesPushout.iso G f g).hom =
  G.map (CategoryTheory.Limits.pushout.inl f g)

full_name: CategoryTheory.Limits.PreservesPushout.inr_iso_hom
code: @[reassoc]
theorem PreservesPushout.inr_iso_hom :
    pushout.inr _ _ ≫ (PreservesPushout.iso G f g).hom = G.map (pushout.inr _ _) 
goal: CategoryTheory.Limits.pushout.inr (G.map f) (G.map g) ≫ (CategoryTheory.Limits.PreservesPushout.iso G f g).hom =
  G.map (CategoryTheory.Limits.pushout.inr f g)

full_name: CategoryTheory.Limits.PreservesPushout.inl_iso_inv
code: @[reassoc (attr := simp)]
theorem PreservesPushout.inl_iso_inv :
    G.map (pushout.inl _ _) ≫ (PreservesPushout.iso G f g).inv = pushout.inl _ _ 
goal: G.map (CategoryTheory.Limits.pushout.inl f g) ≫ (CategoryTheory.Limits.PreservesPushout.iso G f g).inv =
  CategoryTheory.Limits.pushout.inl (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PreservesPushout.inr_iso_inv
code: @[reassoc (attr := simp)]
theorem PreservesPushout.inr_iso_inv :
    G.map (pushout.inr _ _) ≫ (PreservesPushout.iso G f g).inv = pushout.inr _ _ 
goal: G.map (CategoryTheory.Limits.pushout.inr f g) ≫ (CategoryTheory.Limits.PreservesPushout.iso G f g).inv =
  CategoryTheory.Limits.pushout.inr (G.map f) (G.map g)

full_name: CategoryTheory.Limits.PreservesPullback.ofIsoComparison
code: /-- If the pullback comparison map for `G` at `(f,g)` is an isomorphism, then `G` preserves the
pullback of `(f,g)`. -/
def PreservesPullback.ofIsoComparison [i : IsIso (pullbackComparison G f g)] :
    PreservesLimit (cospan f g) G 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G

full_name: CategoryTheory.Limits.instIsIsoPullbackComparison
code: instance : IsIso (pullbackComparison G f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.pullbackComparison G f g)

full_name: CategoryTheory.Limits.PreservesPushout.ofIsoComparison
code: /-- If the pushout comparison map for `G` at `(f,g)` is an isomorphism, then `G` preserves the
pushout of `(f,g)`. -/
def PreservesPushout.ofIsoComparison [i : IsIso (pushoutComparison G f g)] :
    PreservesColimit (span f g) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) G

full_name: CategoryTheory.Limits.instIsIsoPushoutComparison
code: instance : IsIso (pushoutComparison G f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.pushoutComparison G f g)

full_name: CategoryTheory.Limits.PushoutCocone.isColimitYonedaEquiv
code: /-- A pushout cocone in `C` is colimit iff it becomes limit
after the application of `yoneda.obj X` for all `X : C`. -/
def PushoutCocone.isColimitYonedaEquiv (c : PushoutCocone f g) :
    IsColimit c ≃ ∀ (X : C), IsLimit (c.op.map (yoneda.obj X)) 
goal: CategoryTheory.Limits.IsColimit c ≃
  ((X_1 : C) → CategoryTheory.Limits.IsLimit (c.op.map (CategoryTheory.yoneda.obj X_1)))