ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.image.compIso_inv_comp_image_ι
@[reassoc (attr := simp)]
theorem image.compIso_inv_comp_image_ι [HasImage f] [IsIso g] :
    (image.compIso f g).inv ≫ image.ι f = image.ι (f ≫ g) ≫ inv g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) {Z : C} (g : Y ⟶ Z) [CategoryTheory.Limits.HasEqualizers C] [CategoryTheory.Limits.HasImage f] [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.image.compIso f g).inv ≫ CategoryTheory.Limits.image.ι f =
  CategoryTheory.Limits.image.ι (f ≫ g) ≫ CategoryTheory.inv g
-- CategoryTheory.Limits.ImageMap.map_ι
structure ImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) where
  map : image f.hom ⟶ image g.hom
  map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g} (self : CategoryTheory.Limits.ImageMap sq)
Goal: self.map ≫ CategoryTheory.Limits.image.ι g.hom = CategoryTheory.Limits.image.ι f.hom ≫ sq.right
-- CategoryTheory.Limits.ImageMap.factor_map
@[reassoc (attr := simp)]
theorem ImageMap.factor_map {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g)
    (m : ImageMap sq) : factorThruImage f.hom ≫ m.map = sq.left ≫ factorThruImage g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] (sq : f ⟶ g) (m : CategoryTheory.Limits.ImageMap sq)
Goal: CategoryTheory.Limits.factorThruImage f.hom ≫ m.map = sq.left ≫ CategoryTheory.Limits.factorThruImage g.hom
-- CategoryTheory.Limits.HasImageMap.has_image_map
class HasImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) : Prop where
mk' ::
  has_image_map : Nonempty (ImageMap sq)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g} [self : CategoryTheory.Limits.HasImageMap sq]
Goal: Nonempty (CategoryTheory.Limits.ImageMap sq)
-- CategoryTheory.Limits.HasImageMap.mk
theorem HasImageMap.mk {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] {sq : f ⟶ g}
    (m : ImageMap sq) : HasImageMap sq 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g} (m : CategoryTheory.Limits.ImageMap sq)
Goal: CategoryTheory.Limits.HasImageMap sq
-- CategoryTheory.Limits.HasImageMap.transport
theorem HasImageMap.transport {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g)
    (F : MonoFactorisation f.hom) {F' : MonoFactorisation g.hom} (hF' : IsImage F')
    (map : F.I ⟶ F'.I) (map_ι : map ≫ F'.m = F.m ≫ sq.right) : HasImageMap sq 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] (sq : f ⟶ g) (F : CategoryTheory.Limits.MonoFactorisation f.hom) {F' : CategoryTheory.Limits.MonoFactorisation g.hom} (hF' : CategoryTheory.Limits.IsImage F') (map : F.I ⟶ F'.I) (map_ι : map ≫ F'.m = F.m ≫ sq.right)
Goal: CategoryTheory.Limits.HasImageMap sq
-- CategoryTheory.Limits.ImageMap.map_uniq_aux
theorem ImageMap.map_uniq_aux {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] {sq : f ⟶ g}
    (map : image f.hom ⟶ image g.hom)
    (map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop_cat)
    (map' : image f.hom ⟶ image g.hom)
    (map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) : (map = map') 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g} (map : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom) (map_ι : map ≫ CategoryTheory.Limits.image.ι g.hom = CategoryTheory.Limits.image.ι f.hom ≫ sq.right := by aesop_cat) (map' : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom) (map_ι' : map' ≫ CategoryTheory.Limits.image.ι g.hom = CategoryTheory.Limits.image.ι f.hom ≫ sq.right)
Goal: map = map'
-- CategoryTheory.Limits.ImageMap.map_uniq
theorem ImageMap.map_uniq {f g : Arrow C} [HasImage f.hom] [HasImage g.hom]
    {sq : f ⟶ g} (F G : ImageMap sq) : F.map = G.map 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g} (F G : CategoryTheory.Limits.ImageMap sq)
Goal: F.map = G.map
-- CategoryTheory.Limits.ImageMap.mk.injEq'
@[simp]
theorem ImageMap.mk.injEq' {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] {sq : f ⟶ g}
    (map : image f.hom ⟶ image g.hom)
    (map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop_cat)
    (map' : image f.hom ⟶ image g.hom)
    (map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) : (map = map') = True 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g} (map : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom) (map_ι : map ≫ CategoryTheory.Limits.image.ι g.hom = CategoryTheory.Limits.image.ι f.hom ≫ sq.right := by aesop_cat) (map' : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom) (map_ι' : map' ≫ CategoryTheory.Limits.image.ι g.hom = CategoryTheory.Limits.image.ι f.hom ≫ sq.right)
Goal: (map = map') = True
-- CategoryTheory.Limits.image.factor_map
theorem image.factor_map :
    factorThruImage f.hom ≫ image.map sq = sq.left ≫ factorThruImage g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] (sq : f ⟶ g) [CategoryTheory.Limits.HasImageMap sq]
Goal: CategoryTheory.Limits.factorThruImage f.hom ≫ CategoryTheory.Limits.image.map sq =
  sq.left ≫ CategoryTheory.Limits.factorThruImage g.hom
-- CategoryTheory.Limits.image.map_ι
theorem image.map_ι : image.map sq ≫ image.ι g.hom = image.ι f.hom ≫ sq.right 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] (sq : f ⟶ g) [CategoryTheory.Limits.HasImageMap sq]
Goal: CategoryTheory.Limits.image.map sq ≫ CategoryTheory.Limits.image.ι g.hom =
  CategoryTheory.Limits.image.ι f.hom ≫ sq.right
-- CategoryTheory.Limits.image.map_homMk'_ι
theorem image.map_homMk'_ι {X Y P Q : C} {k : X ⟶ Y} [HasImage k] {l : P ⟶ Q} [HasImage l]
    {m : X ⟶ P} {n : Y ⟶ Q} (w : m ≫ l = k ≫ n) [HasImageMap (Arrow.homMk' w)] :
    image.map (Arrow.homMk' w) ≫ image.ι l = image.ι k ≫ n 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y P Q : C} {k : X ⟶ Y} [CategoryTheory.Limits.HasImage k] {l : P ⟶ Q} [CategoryTheory.Limits.HasImage l] {m : X ⟶ P} {n : Y ⟶ Q} (w : m ≫ l = k ≫ n) [CategoryTheory.Limits.HasImageMap (CategoryTheory.Arrow.homMk' w)]
Goal: CategoryTheory.Limits.image.map (CategoryTheory.Arrow.homMk' w) ≫ CategoryTheory.Limits.image.ι l =
  CategoryTheory.Limits.image.ι k ≫ n
-- CategoryTheory.Limits.image.map_comp
@[simp]
theorem image.map_comp [HasImageMap (sq ≫ sq')] :
    image.map (sq ≫ sq') = image.map sq ≫ image.map sq' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImage g.hom] (sq : f ⟶ g) [CategoryTheory.Limits.HasImageMap sq] {h : CategoryTheory.Arrow C} [CategoryTheory.Limits.HasImage h.hom] (sq' : g ⟶ h) [CategoryTheory.Limits.HasImageMap sq'] [CategoryTheory.Limits.HasImageMap (sq ≫ sq')]
Goal: CategoryTheory.Limits.image.map (sq ≫ sq') = CategoryTheory.Limits.image.map sq ≫ CategoryTheory.Limits.image.map sq'
-- CategoryTheory.Limits.image.map_id
@[simp]
theorem image.map_id [HasImageMap (𝟙 f)] : image.map (𝟙 f) = 𝟙 (image f.hom) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [CategoryTheory.Limits.HasImage f.hom] [CategoryTheory.Limits.HasImageMap (𝟙 f)]
Goal: CategoryTheory.Limits.image.map (𝟙 f) = 𝟙 (CategoryTheory.Limits.image f.hom)
-- CategoryTheory.Limits.HasImageMaps.has_image_map
class HasImageMaps : Prop where
  has_image_map : ∀ {f g : Arrow C} (st : f ⟶ g), HasImageMap st
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasImages C] [self : CategoryTheory.Limits.HasImageMaps C] {f g : CategoryTheory.Arrow C} (st : f ⟶ g)
Goal: CategoryTheory.Limits.HasImageMap st
-- CategoryTheory.Limits.im_map
@[simps]
def im : Arrow C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasImages C] [CategoryTheory.Limits.HasImageMaps C]
Goal: ∀ {X Y : CategoryTheory.Arrow C} (st : X ⟶ Y), CategoryTheory.Limits.im.map st = CategoryTheory.Limits.image.map st
-- CategoryTheory.Limits.im_obj
@[simps]
def im : Arrow C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasImages C] [CategoryTheory.Limits.HasImageMaps C] (f : CategoryTheory.Arrow C)
Goal: CategoryTheory.Limits.im.obj f = CategoryTheory.Limits.image f.hom
-- CategoryTheory.Limits.StrongEpiMonoFactorisation.e_strong_epi
structure StrongEpiMonoFactorisation {X Y : C} (f : X ⟶ Y) extends MonoFactorisation f where
  [e_strong_epi : StrongEpi e]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (self : CategoryTheory.Limits.StrongEpiMonoFactorisation f)
Goal: CategoryTheory.StrongEpi self.e
-- CategoryTheory.Limits.HasStrongEpiMonoFactorisations.has_fac
class HasStrongEpiMonoFactorisations : Prop where mk' ::
  has_fac : ∀ {X Y : C} (f : X ⟶ Y), Nonempty (StrongEpiMonoFactorisation f)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasStrongEpiMonoFactorisations C] {X Y : C} (f : X ⟶ Y)
Goal: Nonempty (CategoryTheory.Limits.StrongEpiMonoFactorisation f)
-- CategoryTheory.Limits.HasStrongEpiMonoFactorisations.mk
theorem HasStrongEpiMonoFactorisations.mk
    (d : ∀ {X Y : C} (f : X ⟶ Y), StrongEpiMonoFactorisation f) :
    HasStrongEpiMonoFactorisations C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (d : {X Y : C} → (f : X ⟶ Y) → CategoryTheory.Limits.StrongEpiMonoFactorisation f)
Goal: CategoryTheory.Limits.HasStrongEpiMonoFactorisations C
-- CategoryTheory.Limits.HasStrongEpiImages.strong_factorThruImage
class HasStrongEpiImages : Prop where
  strong_factorThruImage : ∀ {X Y : C} (f : X ⟶ Y), StrongEpi (factorThruImage f)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasImages C] [self : CategoryTheory.Limits.HasStrongEpiImages C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.StrongEpi (CategoryTheory.Limits.factorThruImage f)
-- CategoryTheory.Limits.strongEpi_of_strongEpiMonoFactorisation
theorem strongEpi_of_strongEpiMonoFactorisation {X Y : C} {f : X ⟶ Y}
    (F : StrongEpiMonoFactorisation f) {F' : MonoFactorisation f} (hF' : IsImage F') :
    StrongEpi F'.e 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (F : CategoryTheory.Limits.StrongEpiMonoFactorisation f) {F' : CategoryTheory.Limits.MonoFactorisation f} (hF' : CategoryTheory.Limits.IsImage F')
Goal: CategoryTheory.StrongEpi F'.e
-- CategoryTheory.Limits.strongEpi_factorThruImage_of_strongEpiMonoFactorisation
theorem strongEpi_factorThruImage_of_strongEpiMonoFactorisation {X Y : C} {f : X ⟶ Y} [HasImage f]
    (F : StrongEpiMonoFactorisation f) : StrongEpi (factorThruImage f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasImage f] (F : CategoryTheory.Limits.StrongEpiMonoFactorisation f)
Goal: CategoryTheory.StrongEpi (CategoryTheory.Limits.factorThruImage f)
-- CategoryTheory.Limits.image.isoStrongEpiMono_hom_comp_ι
@[simp]
theorem image.isoStrongEpiMono_hom_comp_ι {I' : C} (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f)
    [StrongEpi e] [Mono m] : (image.isoStrongEpiMono e m comm).hom ≫ image.ι f = m 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrongEpiMonoFactorisations C] {X Y : C} {f : X ⟶ Y} {I' : C} (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f) [CategoryTheory.StrongEpi e] [CategoryTheory.Mono m]
Goal: (CategoryTheory.Limits.image.isoStrongEpiMono e m comm).hom ≫ CategoryTheory.Limits.image.ι f = m
-- CategoryTheory.Limits.image.isoStrongEpiMono_inv_comp_mono
@[simp]
theorem image.isoStrongEpiMono_inv_comp_mono {I' : C} (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f)
    [StrongEpi e] [Mono m] : (image.isoStrongEpiMono e m comm).inv ≫ m = image.ι f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrongEpiMonoFactorisations C] {X Y : C} {f : X ⟶ Y} {I' : C} (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f) [CategoryTheory.StrongEpi e] [CategoryTheory.Mono m]
Goal: (CategoryTheory.Limits.image.isoStrongEpiMono e m comm).inv ≫ m = CategoryTheory.Limits.image.ι f
-- CategoryTheory.Functor.hasStrongEpiMonoFactorisations_imp_of_isEquivalence
theorem hasStrongEpiMonoFactorisations_imp_of_isEquivalence (F : C ⥤ D) [IsEquivalence F]
    [h : HasStrongEpiMonoFactorisations C] : HasStrongEpiMonoFactorisations D 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] (F : C ⥤ D) [F.IsEquivalence] [h : CategoryTheory.Limits.HasStrongEpiMonoFactorisations C]
Goal: CategoryTheory.Limits.HasStrongEpiMonoFactorisations D
-- CategoryTheory.Limits.PreservesLimitPair.iso_hom
@[simp]
theorem PreservesLimitPair.iso_hom : (PreservesLimitPair.iso G X Y).hom = prodComparison G X Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y] [CategoryTheory.Limits.HasBinaryProduct (G.obj X) (G.obj Y)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.pair X Y) G]
Goal: (CategoryTheory.Limits.PreservesLimitPair.iso G X Y).hom = CategoryTheory.Limits.prodComparison G X Y
-- CategoryTheory.Limits.PreservesLimitPair.iso_inv_fst
@[simp]
theorem PreservesLimitPair.iso_inv_fst :
    (PreservesLimitPair.iso G X Y).inv ≫ G.map prod.fst = prod.fst 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y] [CategoryTheory.Limits.HasBinaryProduct (G.obj X) (G.obj Y)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.pair X Y) G]
Goal: (CategoryTheory.Limits.PreservesLimitPair.iso G X Y).inv ≫ G.map CategoryTheory.Limits.prod.fst =
  CategoryTheory.Limits.prod.fst
-- CategoryTheory.Limits.PreservesLimitPair.iso_inv_snd
@[simp]
theorem PreservesLimitPair.iso_inv_snd :
    (PreservesLimitPair.iso G X Y).inv ≫ G.map prod.snd = prod.snd 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y] [CategoryTheory.Limits.HasBinaryProduct (G.obj X) (G.obj Y)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.pair X Y) G]
Goal: (CategoryTheory.Limits.PreservesLimitPair.iso G X Y).inv ≫ G.map CategoryTheory.Limits.prod.snd =
  CategoryTheory.Limits.prod.snd
-- CategoryTheory.Limits.PreservesColimitPair.iso_hom
@[simp]
theorem PreservesColimitPair.iso_hom :
    (PreservesColimitPair.iso G X Y).hom = coprodComparison G X Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (X Y : C) [CategoryTheory.Limits.HasBinaryCoproduct X Y] [CategoryTheory.Limits.HasBinaryCoproduct (G.obj X) (G.obj Y)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.pair X Y) G]
Goal: (CategoryTheory.Limits.PreservesColimitPair.iso G X Y).hom = CategoryTheory.Limits.coprodComparison G X Y
-- CategoryTheory.Limits.hasTerminal_of_hasTerminal_of_preservesLimit
theorem hasTerminal_of_hasTerminal_of_preservesLimit [PreservesLimit (Functor.empty.{0} C) G] :
    HasTerminal D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) [CategoryTheory.Limits.HasTerminal C] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Functor.empty C) G]
Goal: CategoryTheory.Limits.HasTerminal D
-- CategoryTheory.Limits.PreservesTerminal.iso_hom
@[simp]
theorem PreservesTerminal.iso_hom : (PreservesTerminal.iso G).hom = terminalComparison G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) [CategoryTheory.Limits.HasTerminal C] [CategoryTheory.Limits.HasTerminal D] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Functor.empty C) G]
Goal: (CategoryTheory.Limits.PreservesTerminal.iso G).hom = CategoryTheory.Limits.terminalComparison G
-- CategoryTheory.Limits.hasInitial_of_hasInitial_of_preservesColimit
theorem hasInitial_of_hasInitial_of_preservesColimit [PreservesColimit (Functor.empty.{0} C) G] :
    HasInitial D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C) G]
Goal: CategoryTheory.Limits.HasInitial D
-- CategoryTheory.Limits.PreservesInitial.iso_hom
@[simp]
theorem PreservesInitial.iso_hom : (PreservesInitial.iso G).inv = initialComparison G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasInitial D] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C) G]
Goal: (CategoryTheory.Limits.PreservesInitial.iso G).inv = CategoryTheory.Limits.initialComparison G
-- CategoryTheory.Limits.PreservesEqualizer.iso_hom
@[simp]
theorem PreservesEqualizer.iso_hom :
    (PreservesEqualizer.iso G f g).hom = equalizerComparison f g G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g] [CategoryTheory.Limits.HasEqualizer (G.map f) (G.map g)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f g) G]
Goal: (CategoryTheory.Limits.PreservesEqualizer.iso G f g).hom = CategoryTheory.Limits.equalizerComparison f g G
-- CategoryTheory.Limits.PreservesEqualizer.iso_inv_ι
@[simp]
theorem PreservesEqualizer.iso_inv_ι :
    (PreservesEqualizer.iso G f g).inv ≫ G.map (equalizer.ι f g) =
      equalizer.ι (G.map f) (G.map g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g] [CategoryTheory.Limits.HasEqualizer (G.map f) (G.map g)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f g) G]
Goal: (CategoryTheory.Limits.PreservesEqualizer.iso G f g).inv ≫ G.map (CategoryTheory.Limits.equalizer.ι f g) =
  CategoryTheory.Limits.equalizer.ι (G.map f) (G.map g)
-- CategoryTheory.Limits.PreservesCoequalizer.iso_hom
@[simp]
theorem PreservesCoequalizer.iso_hom :
    (PreservesCoequalizer.iso G f g).hom = coequalizerComparison f g G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasCoequalizer f g] [CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G]
Goal: (CategoryTheory.Limits.PreservesCoequalizer.iso G f g).hom = CategoryTheory.Limits.coequalizerComparison f g G
-- CategoryTheory.Limits.map_π_preserves_coequalizer_inv
@[reassoc]
theorem map_π_preserves_coequalizer_inv :
    G.map (coequalizer.π f g) ≫ (PreservesCoequalizer.iso G f g).inv =
      coequalizer.π (G.map f) (G.map g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasCoequalizer f g] [CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G]
Goal: G.map (CategoryTheory.Limits.coequalizer.π f g) ≫ (CategoryTheory.Limits.PreservesCoequalizer.iso G f g).inv =
  CategoryTheory.Limits.coequalizer.π (G.map f) (G.map g)
-- CategoryTheory.Limits.map_π_preserves_coequalizer_inv_desc
@[reassoc]
theorem map_π_preserves_coequalizer_inv_desc {W : D} (k : G.obj Y ⟶ W)
    (wk : G.map f ≫ k = G.map g ≫ k) : G.map (coequalizer.π f g) ≫
      (PreservesCoequalizer.iso G f g).inv ≫ coequalizer.desc k wk = k 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasCoequalizer f g] [CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G] {W : D} (k : G.obj Y ⟶ W) (wk : G.map f ≫ k = G.map g ≫ k)
Goal: G.map (CategoryTheory.Limits.coequalizer.π f g) ≫
    (CategoryTheory.Limits.PreservesCoequalizer.iso G f g).inv ≫ CategoryTheory.Limits.coequalizer.desc k wk =
  k
-- CategoryTheory.Limits.map_π_preserves_coequalizer_inv_colimMap
@[reassoc]
theorem map_π_preserves_coequalizer_inv_colimMap {X' Y' : D} (f' g' : X' ⟶ Y')
    [HasCoequalizer f' g'] (p : G.obj X ⟶ X') (q : G.obj Y ⟶ Y') (wf : G.map f ≫ q = p ≫ f')
    (wg : G.map g ≫ q = p ≫ g') :
    G.map (coequalizer.π f g) ≫
        (PreservesCoequalizer.iso G f g).inv ≫
          colimMap (parallelPairHom (G.map f) (G.map g) f' g' p q wf wg) =
      q ≫ coequalizer.π f' g' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasCoequalizer f g] [CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G] {X' Y' : D} (f' g' : X' ⟶ Y') [CategoryTheory.Limits.HasCoequalizer f' g'] (p : G.obj X ⟶ X') (q : G.obj Y ⟶ Y') (wf : G.map f ≫ q = p ≫ f') (wg : G.map g ≫ q = p ≫ g')
Goal: G.map (CategoryTheory.Limits.coequalizer.π f g) ≫
    (CategoryTheory.Limits.PreservesCoequalizer.iso G f g).inv ≫
      CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom (G.map f) (G.map g) f' g' p q wf wg) =
  q ≫ CategoryTheory.Limits.coequalizer.π f' g'
-- CategoryTheory.Limits.map_π_preserves_coequalizer_inv_colimMap_desc
@[reassoc]
theorem map_π_preserves_coequalizer_inv_colimMap_desc {X' Y' : D} (f' g' : X' ⟶ Y')
    [HasCoequalizer f' g'] (p : G.obj X ⟶ X') (q : G.obj Y ⟶ Y') (wf : G.map f ≫ q = p ≫ f')
    (wg : G.map g ≫ q = p ≫ g') {Z' : D} (h : Y' ⟶ Z') (wh : f' ≫ h = g' ≫ h) :
    G.map (coequalizer.π f g) ≫
        (PreservesCoequalizer.iso G f g).inv ≫
          colimMap (parallelPairHom (G.map f) (G.map g) f' g' p q wf wg) ≫ coequalizer.desc h wh =
      q ≫ h 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasCoequalizer f g] [CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G] {X' Y' : D} (f' g' : X' ⟶ Y') [CategoryTheory.Limits.HasCoequalizer f' g'] (p : G.obj X ⟶ X') (q : G.obj Y ⟶ Y') (wf : G.map f ≫ q = p ≫ f') (wg : G.map g ≫ q = p ≫ g') {Z' : D} (h : Y' ⟶ Z') (wh : f' ≫ h = g' ≫ h)
Goal: G.map (CategoryTheory.Limits.coequalizer.π f g) ≫
    (CategoryTheory.Limits.PreservesCoequalizer.iso G f g).inv ≫
      CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom (G.map f) (G.map g) f' g' p q wf wg) ≫
        CategoryTheory.Limits.coequalizer.desc h wh =
  q ≫ h