ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.ShiftedHom.comp_neg
@[simp]
lemma comp_neg [∀ (a : M), (shiftFunctor C a).Additive]
    {a b c : M} (α : ShiftedHom X Y a) (β : ShiftedHom Y Z b) (h : b + a = c) :
    α.comp (-β) h = -α.comp β h 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {M : Type u_4} [AddMonoid M] [CategoryTheory.HasShift C M] {X Y Z : C} [CategoryTheory.Preadditive C] [∀ (a : M), (CategoryTheory.shiftFunctor C a).Additive] {a b c : M} (α : CategoryTheory.ShiftedHom X Y a) (β : CategoryTheory.ShiftedHom Y Z b) (h : b + a = c)
Goal: α.comp (-β) h = -α.comp β h
-- CategoryTheory.ShiftedHom.neg_comp
@[simp]
lemma neg_comp
    {a b c : M} (α : ShiftedHom X Y a) (β : ShiftedHom Y Z b) (h : b + a = c) :
    (-α).comp β h = -α.comp β h 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {M : Type u_4} [AddMonoid M] [CategoryTheory.HasShift C M] {X Y Z : C} [CategoryTheory.Preadditive C] {a b c : M} (α : CategoryTheory.ShiftedHom X Y a) (β : CategoryTheory.ShiftedHom Y Z b) (h : b + a = c)
Goal: (-α).comp β h = -α.comp β h
-- CategoryTheory.ShiftedHom.comp_zero
@[simp]
lemma comp_zero [∀ (a : M), (shiftFunctor C a).PreservesZeroMorphisms]
    {a : M} (β : ShiftedHom X Y a) {b c : M} (h : b + a = c) :
    β.comp (0 : ShiftedHom Y Z b) h = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {M : Type u_4} [AddMonoid M] [CategoryTheory.HasShift C M] {X Y : C} (Z : C) [CategoryTheory.Preadditive C] [∀ (a : M), (CategoryTheory.shiftFunctor C a).PreservesZeroMorphisms] {a : M} (β : CategoryTheory.ShiftedHom X Y a) {b c : M} (h : b + a = c)
Goal: β.comp 0 h = 0
-- CategoryTheory.ShiftedHom.zero_comp
@[simp]
lemma zero_comp (a : M) {b c : M} (β : ShiftedHom Y Z b) (h : b + a = c) :
    (0 : ShiftedHom X Y a).comp β h = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {M : Type u_4} [AddMonoid M] [CategoryTheory.HasShift C M] (X : C) {Y Z : C} [CategoryTheory.Preadditive C] (a : M) {b c : M} (β : CategoryTheory.ShiftedHom Y Z b) (h : b + a = c)
Goal: CategoryTheory.ShiftedHom.comp 0 β h = 0
-- CategoryTheory.ShiftedHom.id_map
@[simp]
lemma id_map {a : M} (f : ShiftedHom X Y a) : f.map (𝟭 C) = f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {M : Type u_4} [AddMonoid M] [CategoryTheory.HasShift C M] {X Y : C} {a : M} (f : CategoryTheory.ShiftedHom X Y a)
Goal: f.map (CategoryTheory.Functor.id C) = f
-- CategoryTheory.ShiftedHom.comp_map
lemma comp_map {a : M} (f : ShiftedHom X Y a) (F : C ⥤ D) [F.CommShift M]
    (G : D ⥤ E) [G.CommShift M] : f.map (F ⋙ G) = (f.map F).map G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_6, u_2} D] {E : Type u_3} [CategoryTheory.Category.{u_7, u_3} E] {M : Type u_4} [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [CategoryTheory.HasShift E M] {X Y : C} {a : M} (f : CategoryTheory.ShiftedHom X Y a) (F : CategoryTheory.Functor C D) [F.CommShift M] (G : CategoryTheory.Functor D E) [G.CommShift M]
Goal: f.map (F.comp G) = (f.map F).map G
-- CategoryTheory.ShiftedHom.map_comp
lemma map_comp {a b c : M} (f : ShiftedHom X Y a) (g : ShiftedHom Y Z b)
    (h : b + a = c) (F : C ⥤ D) [F.CommShift M] :
    (f.comp g h).map F = (f.map F).comp (g.map F) h 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_6, u_2} D] {M : Type u_4} [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] {X Y Z : C} {a b c : M} (f : CategoryTheory.ShiftedHom X Y a) (g : CategoryTheory.ShiftedHom Y Z b) (h : b + a = c) (F : CategoryTheory.Functor C D) [F.CommShift M]
Goal: (f.comp g h).map F = (f.map F).comp (g.map F) h
-- CategoryTheory.mono_iff_fst_eq_snd
lemma mono_iff_fst_eq_snd (hc : IsLimit c) : Mono f ↔ c.fst = c.snd 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.PullbackCone f f} (hc : CategoryTheory.Limits.IsLimit c)
Goal: CategoryTheory.Mono f ↔ c.fst = c.snd
-- CategoryTheory.mono_iff_isIso_fst
lemma mono_iff_isIso_fst (hc : IsLimit c) : Mono f ↔ IsIso c.fst 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.PullbackCone f f} (hc : CategoryTheory.Limits.IsLimit c)
Goal: CategoryTheory.Mono f ↔ CategoryTheory.IsIso c.fst
-- CategoryTheory.mono_iff_isIso_snd
lemma mono_iff_isIso_snd (hc : IsLimit c) : Mono f ↔ IsIso c.snd 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.PullbackCone f f} (hc : CategoryTheory.Limits.IsLimit c)
Goal: CategoryTheory.Mono f ↔ CategoryTheory.IsIso c.snd
-- CategoryTheory.mono_iff_isPullback
lemma mono_iff_isPullback : Mono f ↔ IsPullback (𝟙 X) (𝟙 X) f f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Mono f ↔
  CategoryTheory.IsPullback (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) f f
-- CategoryTheory.epi_iff_inl_eq_inr
lemma epi_iff_inl_eq_inr (hc : IsColimit c) : Epi f ↔ c.inl = c.inr 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.PushoutCocone f f} (hc : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.Epi f ↔ c.inl = c.inr
-- CategoryTheory.epi_iff_isIso_inl
lemma epi_iff_isIso_inl (hc : IsColimit c) : Epi f ↔ IsIso c.inl 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.PushoutCocone f f} (hc : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.Epi f ↔ CategoryTheory.IsIso c.inl
-- CategoryTheory.epi_iff_isIso_inr
lemma epi_iff_isIso_inr (hc : IsColimit c) : Epi f ↔ IsIso c.inr 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.PushoutCocone f f} (hc : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.Epi f ↔ CategoryTheory.IsIso c.inr
-- CategoryTheory.epi_iff_isPushout
lemma epi_iff_isPushout : Epi f ↔ IsPushout f f (𝟙 Y) (𝟙 Y) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Epi f ↔
  CategoryTheory.IsPushout f f (CategoryTheory.CategoryStruct.id Y) (CategoryTheory.CategoryStruct.id Y)
-- CategoryTheory.MorphismProperty.LeftFraction₂.symm_add
@[simp]
lemma symm_add : φ.symm.add = φ.add 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] {W : CategoryTheory.MorphismProperty C} {X Y : C} (φ : W.LeftFraction₂ X Y)
Goal: φ.symm.add = φ.add
-- CategoryTheory.MorphismProperty.LeftFraction₂.map_add
@[simp]
lemma map_add (F : C ⥤ D) (hF : W.IsInvertedBy F) [Preadditive D] [F.Additive] :
    φ.add.map F hF = φ.fst.map F hF + φ.snd.map F hF 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] {W : CategoryTheory.MorphismProperty C} {X Y : C} (φ : W.LeftFraction₂ X Y) (F : CategoryTheory.Functor C D) (hF : W.IsInvertedBy F) [CategoryTheory.Preadditive D] [F.Additive]
Goal: φ.add.map F hF = φ.fst.map F hF + φ.snd.map F hF
-- CategoryTheory.Localization.Preadditive.neg'_eq
lemma neg'_eq (f : L.obj X ⟶ L.obj Y) (φ : W.LeftFraction X Y)
    (hφ : f = φ.map L (inverts L W)) :
    neg' W f = φ.neg.map L (inverts L W) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f : L.obj X ⟶ L.obj Y) (φ : W.LeftFraction X Y) (hφ : f = φ.map L ⋯)
Goal: CategoryTheory.Localization.Preadditive.neg' W f = φ.neg.map L ⋯
-- CategoryTheory.Localization.Preadditive.add'_eq
lemma add'_eq (f₁ f₂ : L.obj X ⟶ L.obj Y) (φ : W.LeftFraction₂ X Y)
    (hφ₁ : f₁ = φ.fst.map L (inverts L W))
    (hφ₂ : f₂ = φ.snd.map L (inverts L W)) :
    add' W f₁ f₂ = φ.add.map L (inverts L W) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f₁ f₂ : L.obj X ⟶ L.obj Y) (φ : W.LeftFraction₂ X Y) (hφ₁ : f₁ = φ.fst.map L ⋯) (hφ₂ : f₂ = φ.snd.map L ⋯)
Goal: CategoryTheory.Localization.Preadditive.add' W f₁ f₂ = φ.add.map L ⋯
-- CategoryTheory.Localization.Preadditive.add'_comm
lemma add'_comm (f₁ f₂ : L.obj X ⟶ L.obj Y) :
    add' W f₁ f₂ = add' W f₂ f₁ 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f₁ f₂ : L.obj X ⟶ L.obj Y)
Goal: CategoryTheory.Localization.Preadditive.add' W f₁ f₂ = CategoryTheory.Localization.Preadditive.add' W f₂ f₁
-- CategoryTheory.Localization.Preadditive.add'_zero
lemma add'_zero (f : L.obj X ⟶ L.obj Y) :
    add' W f (L.map 0) = f 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f : L.obj X ⟶ L.obj Y)
Goal: CategoryTheory.Localization.Preadditive.add' W f (L.map 0) = f
-- CategoryTheory.Localization.Preadditive.zero_add'
lemma zero_add' (f : L.obj X ⟶ L.obj Y) :
    add' W (L.map 0) f = f 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f : L.obj X ⟶ L.obj Y)
Goal: CategoryTheory.Localization.Preadditive.add' W (L.map 0) f = f
-- CategoryTheory.Localization.Preadditive.add'_left_neg'
lemma add'_left_neg' (f : L.obj X ⟶ L.obj Y) :
    add' W (neg' W f) f = L.map 0 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f : L.obj X ⟶ L.obj Y)
Goal: CategoryTheory.Localization.Preadditive.add' W (CategoryTheory.Localization.Preadditive.neg' W f) f = L.map 0
-- CategoryTheory.Localization.Preadditive.add'_assoc
lemma add'_assoc (f₁ f₂ f₃ : L.obj X ⟶ L.obj Y) :
    add' W (add' W f₁ f₂) f₃ = add' W f₁ (add' W f₂ f₃) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f₁ f₂ f₃ : L.obj X ⟶ L.obj Y)
Goal: CategoryTheory.Localization.Preadditive.add' W (CategoryTheory.Localization.Preadditive.add' W f₁ f₂) f₃ =
  CategoryTheory.Localization.Preadditive.add' W f₁ (CategoryTheory.Localization.Preadditive.add' W f₂ f₃)
-- CategoryTheory.Localization.Preadditive.add'_comp
@[reassoc (attr := simp)]
lemma add'_comp (f₁ f₂ : L.obj X ⟶ L.obj Y) (g : L.obj Y ⟶ L.obj Z) :
    add' W f₁ f₂ ≫ g = add' W (f₁ ≫ g) (f₂ ≫ g) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y Z : C} (f₁ f₂ : L.obj X ⟶ L.obj Y) (g : L.obj Y ⟶ L.obj Z)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.Preadditive.add' W f₁ f₂) g =
  CategoryTheory.Localization.Preadditive.add' W (CategoryTheory.CategoryStruct.comp f₁ g)
    (CategoryTheory.CategoryStruct.comp f₂ g)
-- CategoryTheory.Localization.Preadditive.comp_add'
@[reassoc (attr := simp)]
lemma comp_add' (f : L.obj X ⟶ L.obj Y) (g₁ g₂ : L.obj Y ⟶ L.obj Z) :
    f ≫ add' W g₁ g₂ = add' W (f ≫ g₁) (f ≫ g₂) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y Z : C} (f : L.obj X ⟶ L.obj Y) (g₁ g₂ : L.obj Y ⟶ L.obj Z)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.Localization.Preadditive.add' W g₁ g₂) =
  CategoryTheory.Localization.Preadditive.add' W (CategoryTheory.CategoryStruct.comp f g₁)
    (CategoryTheory.CategoryStruct.comp f g₂)
-- CategoryTheory.Localization.Preadditive.add'_map
@[simp]
lemma add'_map (f₁ f₂ : X ⟶ Y) :
    add' W (L.map f₁) (L.map f₂) = L.map (f₁ + f₂) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f₁ f₂ : X ⟶ Y)
Goal: CategoryTheory.Localization.Preadditive.add' W (L.map f₁) (L.map f₂) = L.map (f₁ + f₂)
-- CategoryTheory.Localization.Preadditive.homEquiv_apply
@[simps]
def homEquiv : (X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {L : CategoryTheory.Functor C D} {X Y : C} {X' Y' : D} (eX : L.obj X ≅ X') (eY : L.obj Y ≅ Y') (f : X' ⟶ Y')
Goal: (CategoryTheory.Localization.Preadditive.homEquiv eX eY) f =
  CategoryTheory.CategoryStruct.comp eX.hom (CategoryTheory.CategoryStruct.comp f eY.inv)
-- CategoryTheory.Localization.Preadditive.homEquiv_symm_apply
@[simps]
def homEquiv : (X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {L : CategoryTheory.Functor C D} {X Y : C} {X' Y' : D} (eX : L.obj X ≅ X') (eY : L.obj Y ≅ Y') (g : L.obj X ⟶ L.obj Y)
Goal: (CategoryTheory.Localization.Preadditive.homEquiv eX eY).symm g =
  CategoryTheory.CategoryStruct.comp eX.inv (CategoryTheory.CategoryStruct.comp g eY.hom)
-- CategoryTheory.Localization.Preadditive.add_comp
@[reassoc]
lemma add_comp (f₁ f₂ : X' ⟶ Y') (g : Y' ⟶ Z') :
    add W eX eY f₁ f₂ ≫ g = add W eX eZ (f₁ ≫ g) (f₂ ≫ g) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y Z : C} {X' Y' Z' : D} (eX : L.obj X ≅ X') (eY : L.obj Y ≅ Y') (eZ : L.obj Z ≅ Z') (f₁ f₂ : X' ⟶ Y') (g : Y' ⟶ Z')
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.Preadditive.add W eX eY f₁ f₂) g =
  CategoryTheory.Localization.Preadditive.add W eX eZ (CategoryTheory.CategoryStruct.comp f₁ g)
    (CategoryTheory.CategoryStruct.comp f₂ g)
-- CategoryTheory.Localization.Preadditive.comp_add
@[reassoc]
lemma comp_add (f : X' ⟶ Y') (g₁ g₂ : Y' ⟶ Z') :
    f ≫ add W eY eZ g₁ g₂ = add W eX eZ (f ≫ g₁) (f ≫ g₂) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y Z : C} {X' Y' Z' : D} (eX : L.obj X ≅ X') (eY : L.obj Y ≅ Y') (eZ : L.obj Z ≅ Z') (f : X' ⟶ Y') (g₁ g₂ : Y' ⟶ Z')
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.Localization.Preadditive.add W eY eZ g₁ g₂) =
  CategoryTheory.Localization.Preadditive.add W eX eZ (CategoryTheory.CategoryStruct.comp f g₁)
    (CategoryTheory.CategoryStruct.comp f g₂)
-- CategoryTheory.Localization.Preadditive.add_eq_add
lemma add_eq_add {X'' Y'' : C} (eX' : L.obj X'' ≅ X') (eY' : L.obj Y'' ≅ Y')
    (f₁ f₂ : X' ⟶ Y') :
    add W eX eY f₁ f₂ = add W eX' eY' f₁ f₂ 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} {X' Y' : D} (eX : L.obj X ≅ X') (eY : L.obj Y ≅ Y') {X'' Y'' : C} (eX' : L.obj X'' ≅ X') (eY' : L.obj Y'' ≅ Y') (f₁ f₂ : X' ⟶ Y')
Goal: CategoryTheory.Localization.Preadditive.add W eX eY f₁ f₂ = CategoryTheory.Localization.Preadditive.add W eX' eY' f₁ f₂
-- CategoryTheory.Localization.Preadditive.add_eq
lemma add_eq (f₁ f₂ : X' ⟶ Y') :
    letI := addCommGroup L W X' Y'
    f₁ + f₂ = add W eX eY f₁ f₂ 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive C] {L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} {X' Y' : D} (eX : L.obj X ≅ X') (eY : L.obj Y ≅ Y') (f₁ f₂ : X' ⟶ Y')
Goal: f₁ + f₂ = CategoryTheory.Localization.Preadditive.add W eX eY f₁ f₂
-- CategoryTheory.Localization.Preadditive.map_add
lemma map_add (f₁ f₂ : X ⟶ Y) :
    letI := addCommGroup L W (L.obj X) (L.obj Y)
    L.map (f₁ + f₂) = L.map f₁ + L.map f₂ 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (f₁ f₂ : X ⟶ Y)
Goal: L.map (f₁ + f₂) = L.map f₁ + L.map f₂
-- CategoryTheory.Localization.functor_additive
lemma functor_additive :
    letI := preadditive L W
    L.Additive 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions]
Goal: L.Additive
-- CategoryTheory.Localization.functor_additive_iff
lemma functor_additive_iff {E : Type*} [Category E] [Preadditive E] [Preadditive D] [L.Additive]
    (G : D ⥤ E) :
    G.Additive ↔ (L ⋙ G).Additive 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {E : Type u_3} [CategoryTheory.Category.{u_4, u_3} E] [CategoryTheory.Preadditive E] [CategoryTheory.Preadditive D] [L.Additive] (G : CategoryTheory.Functor D E)
Goal: G.Additive ↔ (L.comp G).Additive
-- CategoryTheory.Functor.IsCartesian.universal_property
class IsCartesian extends IsHomLift p f φ : Prop where
  universal_property {a' : 𝒳} (φ' : a' ⟶ b) [IsHomLift p f φ'] :
      ∃! χ : a' ⟶ a, IsHomLift p (𝟙 R) χ ∧ χ ≫ φ = φ'
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] {p : 𝒳 ⥤ 𝒮} {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) {φ : a ⟶ b} [self : p.IsCartesian f φ] {a' : 𝒳} (φ' : a' ⟶ b) [p.IsHomLift f φ']
Goal: ∃! χ, p.IsHomLift (𝟙 R) χ ∧ χ ≫ φ = φ'
-- CategoryTheory.Functor.IsStronglyCartesian.universal_property'
class IsStronglyCartesian extends IsHomLift p f φ : Prop where
  universal_property' {a' : 𝒳} (g : p.obj a' ⟶ R) (φ' : a' ⟶ b) [IsHomLift p (g ≫ f) φ'] :
      ∃! χ : a' ⟶ a, IsHomLift p g χ ∧ χ ≫ φ = φ'
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] {p : 𝒳 ⥤ 𝒮} {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) {φ : a ⟶ b} [self : p.IsStronglyCartesian f φ] {a' : 𝒳} (g : p.obj a' ⟶ R) (φ' : a' ⟶ b) [p.IsHomLift (g ≫ f) φ']
Goal: ∃! χ, p.IsHomLift g χ ∧ χ ≫ φ = φ'
-- CategoryTheory.Functor.IsCartesian.fac
@[reassoc (attr := simp)]
lemma fac : IsCartesian.map p f φ φ' ≫ φ = φ' 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsCartesian f φ] {a' : 𝒳} (φ' : a' ⟶ b) [p.IsHomLift f φ']
Goal: CategoryTheory.Functor.IsCartesian.map p f φ φ' ≫ φ = φ'
-- CategoryTheory.Functor.IsCartesian.map_uniq
lemma map_uniq (ψ : a' ⟶ a) [IsHomLift p (𝟙 R) ψ] (hψ : ψ ≫ φ = φ') :
    ψ = IsCartesian.map p f φ φ' 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsCartesian f φ] {a' : 𝒳} (φ' : a' ⟶ b) [p.IsHomLift f φ'] (ψ : a' ⟶ a) [p.IsHomLift (𝟙 R) ψ] (hψ : ψ ≫ φ = φ')
Goal: ψ = CategoryTheory.Functor.IsCartesian.map p f φ φ'
-- CategoryTheory.Functor.IsCartesian.ext
protected lemma ext (φ : a ⟶ b) [IsCartesian p f φ] {a' : 𝒳} (ψ ψ' : a' ⟶ a)
    [IsHomLift p (𝟙 R) ψ] [IsHomLift p (𝟙 R) ψ'] (h : ψ ≫ φ = ψ' ≫ φ) : ψ = ψ' 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsCartesian f φ] {a' : 𝒳} (ψ ψ' : a' ⟶ a) [p.IsHomLift (𝟙 R) ψ] [p.IsHomLift (𝟙 R) ψ'] (h : ψ ≫ φ = ψ' ≫ φ)
Goal: ψ = ψ'
-- CategoryTheory.Functor.IsCartesian.map_self
@[simp]
lemma map_self : IsCartesian.map p f φ φ = 𝟙 a 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsCartesian f φ]
Goal: CategoryTheory.Functor.IsCartesian.map p f φ φ = 𝟙 a
-- CategoryTheory.Functor.IsStronglyCartesian.universal_property
lemma universal_property {R' : 𝒮} {a' : 𝒳} (g : R' ⟶ R) (f' : R' ⟶ S) (hf' : f' = g ≫ f)
    (φ' : a' ⟶ b) [IsHomLift p f' φ'] : ∃! χ : a' ⟶ a, IsHomLift p g χ ∧ χ ≫ φ = φ' 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsStronglyCartesian f φ] {R' : 𝒮} {a' : 𝒳} (g : R' ⟶ R) (f' : R' ⟶ S) (hf' : f' = g ≫ f) (φ' : a' ⟶ b) [p.IsHomLift f' φ']
Goal: ∃! χ, p.IsHomLift g χ ∧ χ ≫ φ = φ'
-- CategoryTheory.Functor.IsStronglyCartesian.fac
@[reassoc (attr := simp)]
lemma fac : (map p f φ hf' φ') ≫ φ = φ' 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsStronglyCartesian f φ] {R' : 𝒮} {a' : 𝒳} {g : R' ⟶ R} {f' : R' ⟶ S} (hf' : f' = g ≫ f) (φ' : a' ⟶ b) [p.IsHomLift f' φ']
Goal: CategoryTheory.Functor.IsStronglyCartesian.map p f φ hf' φ' ≫ φ = φ'
-- CategoryTheory.Functor.IsStronglyCartesian.map_uniq
lemma map_uniq (ψ : a' ⟶ a) [IsHomLift p g ψ] (hψ : ψ ≫ φ = φ') : ψ = map p f φ hf' φ' 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsStronglyCartesian f φ] {R' : 𝒮} {a' : 𝒳} {g : R' ⟶ R} {f' : R' ⟶ S} (hf' : f' = g ≫ f) (φ' : a' ⟶ b) [p.IsHomLift f' φ'] (ψ : a' ⟶ a) [p.IsHomLift g ψ] (hψ : ψ ≫ φ = φ')
Goal: ψ = CategoryTheory.Functor.IsStronglyCartesian.map p f φ hf' φ'
-- CategoryTheory.Functor.IsStronglyCartesian.ext
protected lemma ext (φ : a ⟶ b) [IsStronglyCartesian p f φ] {R' : 𝒮} {a' : 𝒳} (g : R' ⟶ R)
    {ψ ψ' : a' ⟶ a} [IsHomLift p g ψ] [IsHomLift p g ψ'] (h : ψ ≫ φ = ψ' ≫ φ) : ψ = ψ' 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsStronglyCartesian f φ] {R' : 𝒮} {a' : 𝒳} (g : R' ⟶ R) {ψ ψ' : a' ⟶ a} [p.IsHomLift g ψ] [p.IsHomLift g ψ'] (h : ψ ≫ φ = ψ' ≫ φ)
Goal: ψ = ψ'
-- CategoryTheory.Functor.IsStronglyCartesian.map_self
@[simp]
lemma map_self : map p f φ (id_comp f).symm φ = 𝟙 a 
Arguments: {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Category.{v₁, u₁} 𝒮] [CategoryTheory.Category.{v₂, u₂} 𝒳] (p : 𝒳 ⥤ 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsStronglyCartesian f φ]
Goal: CategoryTheory.Functor.IsStronglyCartesian.map p f φ ⋯ φ = 𝟙 a