ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.AdditiveFunctor.ofRightExact_map
@[simp]
theorem AdditiveFunctor.ofRightExact_map {F G : C ⥤ᵣ D} (α : F ⟶ G) :
    (AdditiveFunctor.ofRightExact C D).map α = α 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasBinaryBiproducts C] {F G : C ⥤ᵣ D} (α : F ⟶ G)
Goal: (CategoryTheory.AdditiveFunctor.ofRightExact C D).map α = α
-- CategoryTheory.AdditiveFunctor.ofExact_map
@[simp]
theorem AdditiveFunctor.ofExact_map {F G : C ⥤ₑ D} (α : F ⟶ G) :
    (AdditiveFunctor.ofExact C D).map α = α 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasBinaryBiproducts C] {F G : C ⥤ₑ D} (α : F ⟶ G)
Goal: (CategoryTheory.AdditiveFunctor.ofExact C D).map α = α
-- CategoryTheory.preadditiveYonedaObj_obj
@[simps]
def preadditiveYonedaObj (Y : C) : Cᵒᵖ ⥤ ModuleCat.{v} (End Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] (Y : C) (X : Cᵒᵖ)
Goal: (CategoryTheory.preadditiveYonedaObj Y).obj X = ModuleCat.of (CategoryTheory.End Y) (Opposite.unop X ⟶ Y)
-- CategoryTheory.preadditiveYonedaObj_map
@[simps]
def preadditiveYonedaObj (Y : C) : Cᵒᵖ ⥤ ModuleCat.{v} (End Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] (Y : C)
Goal: ∀ {X Y_1 : Cᵒᵖ} (f : X ⟶ Y_1),
  (CategoryTheory.preadditiveYonedaObj Y).map f =
    ModuleCat.ofHom { toFun := fun g => CategoryTheory.CategoryStruct.comp f.unop g, map_add' := ⋯, map_smul' := ⋯ }
-- CategoryTheory.preadditiveYoneda_map_app_apply
@[simps]
def preadditiveYoneda : C ⥤ Cᵒᵖ ⥤ AddCommGrp.{v} 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C]
Goal: ∀ {X Y : C} (f : X ⟶ Y) (X_1 : Cᵒᵖ)
  (g :
    ↑(((fun Y =>
              (CategoryTheory.preadditiveYonedaObj Y).comp
                (CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End Y)) AddCommGrp))
            X).obj
        X_1)),
  ((CategoryTheory.preadditiveYoneda.map f).app X_1) g = CategoryTheory.CategoryStruct.comp g f
-- CategoryTheory.preadditiveYoneda_obj
@[simps]
def preadditiveYoneda : C ⥤ Cᵒᵖ ⥤ AddCommGrp.{v} 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] (Y : C)
Goal: CategoryTheory.preadditiveYoneda.obj Y =
  (CategoryTheory.preadditiveYonedaObj Y).comp (CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End Y)) AddCommGrp)
-- CategoryTheory.preadditiveCoyonedaObj_map
@[simps]
def preadditiveCoyonedaObj (X : Cᵒᵖ) : C ⥤ ModuleCat.{v} (End X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] (X : Cᵒᵖ)
Goal: ∀ {X_1 Y : C} (f : X_1 ⟶ Y),
  (CategoryTheory.preadditiveCoyonedaObj X).map f =
    ModuleCat.ofHom { toFun := fun g => CategoryTheory.CategoryStruct.comp g f, map_add' := ⋯, map_smul' := ⋯ }
-- CategoryTheory.preadditiveCoyonedaObj_obj
@[simps]
def preadditiveCoyonedaObj (X : Cᵒᵖ) : C ⥤ ModuleCat.{v} (End X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] (X : Cᵒᵖ) (Y : C)
Goal: (CategoryTheory.preadditiveCoyonedaObj X).obj Y = ModuleCat.of (CategoryTheory.End X) (Opposite.unop X ⟶ Y)
-- CategoryTheory.preadditiveCoyoneda_obj
@[simps]
def preadditiveCoyoneda : Cᵒᵖ ⥤ C ⥤ AddCommGrp.{v} 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] (X : Cᵒᵖ)
Goal: CategoryTheory.preadditiveCoyoneda.obj X =
  (CategoryTheory.preadditiveCoyonedaObj X).comp (CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End X)) AddCommGrp)
-- CategoryTheory.preadditiveCoyoneda_map_app_apply
@[simps]
def preadditiveCoyoneda : Cᵒᵖ ⥤ C ⥤ AddCommGrp.{v} 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C]
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (Y_1 : C)
  (g :
    ↑(((fun X =>
              (CategoryTheory.preadditiveCoyonedaObj X).comp
                (CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End X)) AddCommGrp))
            X).obj
        Y_1)),
  ((CategoryTheory.preadditiveCoyoneda.map f).app Y_1) g = CategoryTheory.CategoryStruct.comp f.unop g
-- CategoryTheory.whiskering_preadditiveYoneda
@[simp]
theorem whiskering_preadditiveYoneda :
    preadditiveYoneda ⋙
        (whiskeringRight Cᵒᵖ AddCommGrp (Type v)).obj (forget AddCommGrp) =
      yoneda 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C]
Goal: CategoryTheory.preadditiveYoneda.comp
    ((CategoryTheory.whiskeringRight Cᵒᵖ AddCommGrp (Type v)).obj (CategoryTheory.forget AddCommGrp)) =
  CategoryTheory.yoneda
-- CategoryTheory.whiskering_preadditiveCoyoneda
@[simp]
theorem whiskering_preadditiveCoyoneda :
    preadditiveCoyoneda ⋙
        (whiskeringRight C AddCommGrp (Type v)).obj (forget AddCommGrp) =
      coyoneda 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C]
Goal: CategoryTheory.preadditiveCoyoneda.comp
    ((CategoryTheory.whiskeringRight C AddCommGrp (Type v)).obj (CategoryTheory.forget AddCommGrp)) =
  CategoryTheory.coyoneda
-- CategoryTheory.InjectiveResolution.injective
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure InjectiveResolution (Z : C) where
    cocomplex : CochainComplex C ℕ
    injective : ∀ n, Injective (cocomplex.X n) := by infer_instance
    [hasHomology : ∀ i, cocomplex.HasHomology i]
    ι : (single₀ C).obj Z ⟶ cocomplex
    quasiIso : QuasiIso ι := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (self : CategoryTheory.InjectiveResolution Z) (n : ℕ)
Goal: CategoryTheory.Injective (self.cocomplex.X n)
-- CategoryTheory.InjectiveResolution.hasHomology
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure InjectiveResolution (Z : C) where
    cocomplex : CochainComplex C ℕ
    injective : ∀ n, Injective (cocomplex.X n) := by infer_instance
    [hasHomology : ∀ i, cocomplex.HasHomology i]
    ι : (single₀ C).obj Z ⟶ cocomplex
    quasiIso : QuasiIso ι := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (self : CategoryTheory.InjectiveResolution Z) (i : ℕ)
Goal: HomologicalComplex.HasHomology self.cocomplex i
-- CategoryTheory.InjectiveResolution.quasiIso
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure InjectiveResolution (Z : C) where
    cocomplex : CochainComplex C ℕ
    injective : ∀ n, Injective (cocomplex.X n) := by infer_instance
    [hasHomology : ∀ i, cocomplex.HasHomology i]
    ι : (single₀ C).obj Z ⟶ cocomplex
    quasiIso : QuasiIso ι := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (self : CategoryTheory.InjectiveResolution Z)
Goal: QuasiIso self.ι
-- CategoryTheory.HasInjectiveResolution.out
class HasInjectiveResolution (Z : C) : Prop where
  out : Nonempty (InjectiveResolution Z)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} [self : CategoryTheory.HasInjectiveResolution Z]
Goal: Nonempty (CategoryTheory.InjectiveResolution Z)
-- CategoryTheory.HasInjectiveResolutions.out
class HasInjectiveResolutions : Prop where
  out : ∀ Z : C, HasInjectiveResolution Z
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] [self : CategoryTheory.HasInjectiveResolutions C] (Z : C)
Goal: CategoryTheory.HasInjectiveResolution Z
-- CategoryTheory.InjectiveResolution.cocomplex_exactAt_succ
lemma cocomplex_exactAt_succ (n : ℕ) :
    I.cocomplex.ExactAt (n + 1) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z) (n : ℕ)
Goal: HomologicalComplex.ExactAt I.cocomplex (n + 1)
-- CategoryTheory.InjectiveResolution.exact_succ
lemma exact_succ (n : ℕ) :
    (ShortComplex.mk _ _ (I.cocomplex.d_comp_d n (n + 1) (n + 2))).Exact 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z) (n : ℕ)
Goal: (CategoryTheory.ShortComplex.mk (I.cocomplex.d n (n + 1)) (I.cocomplex.d (n + 1) (n + 2)) ⋯).Exact
-- CategoryTheory.InjectiveResolution.ι_f_succ
@[simp]
theorem ι_f_succ (n : ℕ) : I.ι.f (n + 1) = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z) (n : ℕ)
Goal: I.ι.f (n + 1) = 0
-- CategoryTheory.InjectiveResolution.ι_f_zero_comp_complex_d
@[reassoc]
theorem ι_f_zero_comp_complex_d :
    I.ι.f 0 ≫ I.cocomplex.d 0 1 = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z)
Goal: CategoryTheory.CategoryStruct.comp (I.ι.f 0) (I.cocomplex.d 0 1) = 0
-- CategoryTheory.InjectiveResolution.complex_d_comp
theorem complex_d_comp (n : ℕ) :
    I.cocomplex.d n (n + 1) ≫ I.cocomplex.d (n + 1) (n + 2) = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z) (n : ℕ)
Goal: CategoryTheory.CategoryStruct.comp (I.cocomplex.d n (n + 1)) (I.cocomplex.d (n + 1) (n + 2)) = 0
-- CategoryTheory.InjectiveResolution.self_cocomplex
@[simps]
def self [Injective Z] : InjectiveResolution Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (Z : C) [CategoryTheory.Injective Z]
Goal: (CategoryTheory.InjectiveResolution.self Z).cocomplex = (CochainComplex.single₀ C).obj Z
-- CategoryTheory.InjectiveResolution.self_ι
@[simps]
def self [Injective Z] : InjectiveResolution Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (Z : C) [CategoryTheory.Injective Z]
Goal: (CategoryTheory.InjectiveResolution.self Z).ι = CategoryTheory.CategoryStruct.id ((CochainComplex.single₀ C).obj Z)
-- CategoryTheory.Functor.essImage.ofIso
theorem essImage.ofIso {Y Y' : D} (h : Y ≅ Y') (hY : Y ∈ essImage F) : Y' ∈ essImage F 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {Y Y' : D} (h : Y ≅ Y') (hY : Y ∈ F.essImage)
Goal: Y' ∈ F.essImage
-- CategoryTheory.Functor.essImage.ofNatIso
theorem essImage.ofNatIso {F' : C ⥤ D} (h : F ≅ F') {Y : D} (hY : Y ∈ essImage F) :
    Y ∈ essImage F' 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} (h : F ≅ F') {Y : D} (hY : Y ∈ F.essImage)
Goal: Y ∈ F'.essImage
-- CategoryTheory.Functor.essImage_eq_of_natIso
theorem essImage_eq_of_natIso {F' : C ⥤ D} (h : F ≅ F') : essImage F = essImage F' 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} (h : F ≅ F')
Goal: F.essImage = F'.essImage
-- CategoryTheory.Functor.obj_mem_essImage
theorem obj_mem_essImage (F : D ⥤ C) (Y : D) : F.obj Y ∈ essImage F 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D C) (Y : D)
Goal: F.obj Y ∈ F.essImage
-- CategoryTheory.Functor.essImageInclusion_obj
@[simps!]
def essImageInclusion (F : C ⥤ D) : F.EssImageSubcategory ⥤ D 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (self : CategoryTheory.FullSubcategory F.essImage)
Goal: F.essImageInclusion.obj self = self.obj
-- CategoryTheory.Functor.essImageInclusion_map
@[simps!]
def essImageInclusion (F : C ⥤ D) : F.EssImageSubcategory ⥤ D 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.InducedCategory D CategoryTheory.FullSubcategory.obj} (f : X ⟶ Y), F.essImageInclusion.map f = f
-- CategoryTheory.Functor.toEssImage_obj_obj
@[simps!]
def toEssImage (F : C ⥤ D) : C ⥤ F.EssImageSubcategory 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: (F.toEssImage.obj X).obj = F.obj X
-- CategoryTheory.Functor.toEssImage_map
@[simps!]
def toEssImage (F : C ⥤ D) : C ⥤ F.EssImageSubcategory 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : C} (f : X ⟶ Y), F.toEssImage.map f = F.map f
-- CategoryTheory.Functor.toEssImageCompEssentialImageInclusion_hom_app
@[simps!]
def toEssImageCompEssentialImageInclusion (F : C ⥤ D) : F.toEssImage ⋙ F.essImageInclusion ≅ F 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: F.toEssImageCompEssentialImageInclusion.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.toEssImageCompEssentialImageInclusion_inv_app
@[simps!]
def toEssImageCompEssentialImageInclusion (F : C ⥤ D) : F.toEssImage ⋙ F.essImageInclusion ≅ F 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: F.toEssImageCompEssentialImageInclusion.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.EssSurj.mem_essImage
class EssSurj (F : C ⥤ D) : Prop where
    mem_essImage (Y : D) : Y ∈ F.essImage
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [self : F.EssSurj] (Y : D)
Goal: Y ∈ F.essImage
-- CategoryTheory.Functor.essSurj_of_surj
theorem essSurj_of_surj (h : Function.Surjective F.obj) : EssSurj F 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (h : Function.Surjective F.obj)
Goal: F.EssSurj
-- CategoryTheory.Functor.essSurj_of_iso
lemma essSurj_of_iso {F G : C ⥤ D} [EssSurj F] (α : F ≅ G) : EssSurj G 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} [F.EssSurj] (α : F ≅ G)
Goal: G.EssSurj
-- CategoryTheory.Functor.essSurj_of_comp_fully_faithful
lemma essSurj_of_comp_fully_faithful (F : C ⥤ D) (G : D ⥤ E) [(F ⋙ G).EssSurj]
    [G.Faithful] [G.Full] : F.EssSurj 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [(F.comp G).EssSurj] [G.Faithful] [G.Full]
Goal: F.EssSurj
-- CategoryTheory.Localization.equivalence_counitIso_app
@[simp]
lemma equivalence_counitIso_app (X : C₂) :
    (equivalence L₁ W₁ L₂ W₂ G G' F F' α β).counitIso.app (L₂.obj X) =
      (Lifting.iso L₂ W₂ (F ⋙ G') (F' ⋙ G')).app X ≪≫ β.app X 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_4} {D₂ : Type u_5} [CategoryTheory.Category.{u_8, u_1} C₁] [CategoryTheory.Category.{u_9, u_2} C₂] [CategoryTheory.Category.{u_7, u_4} D₁] [CategoryTheory.Category.{u_6, u_5} D₂] (L₁ : CategoryTheory.Functor C₁ D₁) (W₁ : CategoryTheory.MorphismProperty C₁) [L₁.IsLocalization W₁] (L₂ : CategoryTheory.Functor C₂ D₂) (W₂ : CategoryTheory.MorphismProperty C₂) [L₂.IsLocalization W₂] (G : CategoryTheory.Functor C₁ D₂) (G' : CategoryTheory.Functor D₁ D₂) [CategoryTheory.Localization.Lifting L₁ W₁ G G'] (F : CategoryTheory.Functor C₂ D₁) (F' : CategoryTheory.Functor D₂ D₁) [CategoryTheory.Localization.Lifting L₂ W₂ F F'] (α : G.comp F' ≅ L₁) (β : F.comp G' ≅ L₂) (X : C₂)
Goal: (CategoryTheory.Localization.equivalence L₁ W₁ L₂ W₂ G G' F F' α β).counitIso.app (L₂.obj X) =
  (CategoryTheory.Localization.Lifting.iso L₂ W₂ (F.comp G') (F'.comp G')).app X ≪≫ β.app X
-- CategoryTheory.Localization.isEquivalence
lemma isEquivalence : G'.IsEquivalence 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_4} {D₂ : Type u_5} [CategoryTheory.Category.{u_8, u_1} C₁] [CategoryTheory.Category.{u_9, u_2} C₂] [CategoryTheory.Category.{u_6, u_4} D₁] [CategoryTheory.Category.{u_7, u_5} D₂] (L₁ : CategoryTheory.Functor C₁ D₁) (W₁ : CategoryTheory.MorphismProperty C₁) [L₁.IsLocalization W₁] (L₂ : CategoryTheory.Functor C₂ D₂) (W₂ : CategoryTheory.MorphismProperty C₂) [L₂.IsLocalization W₂] (G : CategoryTheory.Functor C₁ D₂) (G' : CategoryTheory.Functor D₁ D₂) [CategoryTheory.Localization.Lifting L₁ W₁ G G'] (F : CategoryTheory.Functor C₂ D₁) (F' : CategoryTheory.Functor D₂ D₁) [CategoryTheory.Localization.Lifting L₂ W₂ F F'] (α : G.comp F' ≅ L₁) (β : F.comp G' ≅ L₂)
Goal: G'.IsEquivalence
-- CategoryTheory.Functor.IsLocalization.of_equivalence_source
lemma of_equivalence_source (L₁ : C₁ ⥤ D) (W₁ : MorphismProperty C₁)
    (L₂ : C₂ ⥤ D) (W₂ : MorphismProperty C₂)
    (E : C₁ ≌ C₂) (hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor) (hW₂ : W₂.IsInvertedBy L₂)
    [L₁.IsLocalization W₁] (iso : E.functor ⋙ L₂ ≅ L₁) : L₂.IsLocalization W₂ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_6, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_7, u_3} D] (L₁ : CategoryTheory.Functor C₁ D) (W₁ : CategoryTheory.MorphismProperty C₁) (L₂ : CategoryTheory.Functor C₂ D) (W₂ : CategoryTheory.MorphismProperty C₂) (E : C₁ ≌ C₂) (hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor) (hW₂ : W₂.IsInvertedBy L₂) [L₁.IsLocalization W₁] (iso : E.functor.comp L₂ ≅ L₁)
Goal: L₂.IsLocalization W₂
-- CategoryTheory.Functor.IsLocalization.of_equivalences
lemma of_equivalences (L₁ : C₁ ⥤ D₁) (W₁ : MorphismProperty C₁) [L₁.IsLocalization W₁]
    (L₂ : C₂ ⥤ D₂) (W₂ : MorphismProperty C₂)
    (E : C₁ ≌ C₂) (E' : D₁ ≌ D₂) [CatCommSq E.functor L₁ L₂ E'.functor]
    (hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor) (hW₂ : W₂.IsInvertedBy L₂) :
    L₂.IsLocalization W₂ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_4} {D₂ : Type u_5} [CategoryTheory.Category.{u_6, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_7, u_4} D₁] [CategoryTheory.Category.{u_9, u_5} D₂] (L₁ : CategoryTheory.Functor C₁ D₁) (W₁ : CategoryTheory.MorphismProperty C₁) [L₁.IsLocalization W₁] (L₂ : CategoryTheory.Functor C₂ D₂) (W₂ : CategoryTheory.MorphismProperty C₂) (E : C₁ ≌ C₂) (E' : D₁ ≌ D₂) [CategoryTheory.CatCommSq E.functor L₁ L₂ E'.functor] (hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor) (hW₂ : W₂.IsInvertedBy L₂)
Goal: L₂.IsLocalization W₂
-- CategoryTheory.Localization.LeftBousfield.W.homEquiv_apply
@[simps! apply]
noncomputable def W.homEquiv {X Y : C} {f : X ⟶ Y} (hf : W P f) (Z : C) (hZ : P Z) :
    (Y ⟶ Z) ≃ (X ⟶ Z) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {P : C → Prop} {X Y : C} {f : X ⟶ Y} (hf : CategoryTheory.Localization.LeftBousfield.W P f) (Z : C) (hZ : P Z) (g : Y ⟶ Z)
Goal: (hf.homEquiv Z hZ) g = CategoryTheory.CategoryStruct.comp f g
-- CategoryTheory.Localization.LeftBousfield.W_isoClosure
lemma W_isoClosure : W (isoClosure P) = W P 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (P : C → Prop)
Goal: CategoryTheory.Localization.LeftBousfield.W (CategoryTheory.isoClosure P) =
  CategoryTheory.Localization.LeftBousfield.W P
-- CategoryTheory.Localization.LeftBousfield.W_of_isIso
lemma W_of_isIso {X Y : C} (f : X ⟶ Y) [IsIso f] : W P f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (P : C → Prop) {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: CategoryTheory.Localization.LeftBousfield.W P f
-- CategoryTheory.Localization.LeftBousfield.W_iff_isIso
lemma W_iff_isIso {X Y : C} (f : X ⟶ Y) (hX : P X) (hY : P Y) :
    W P f ↔ IsIso f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (P : C → Prop) {X Y : C} (f : X ⟶ Y) (hX : P X) (hY : P Y)
Goal: CategoryTheory.Localization.LeftBousfield.W P f ↔ CategoryTheory.IsIso f
-- CategoryTheory.Localization.LeftBousfield.W_adj_unit_app
lemma W_adj_unit_app (X : D) : W (· ∈ Set.range F.obj) (adj.unit.app X) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : G ⊣ F) [F.Full] [F.Faithful] (X : D)
Goal: CategoryTheory.Localization.LeftBousfield.W (fun x => x ∈ Set.range F.obj) (adj.unit.app X)
-- CategoryTheory.Localization.LeftBousfield.W_iff_isIso_map
lemma W_iff_isIso_map {X Y : D} (f : X ⟶ Y) :
    W (· ∈ Set.range F.obj) f ↔ IsIso (G.map f) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : G ⊣ F) [F.Full] [F.Faithful] {X Y : D} (f : X ⟶ Y)
Goal: CategoryTheory.Localization.LeftBousfield.W (fun x => x ∈ Set.range F.obj) f ↔ CategoryTheory.IsIso (G.map f)
-- CategoryTheory.Localization.LeftBousfield.W_eq_inverseImage_isomorphisms
lemma W_eq_inverseImage_isomorphisms :
    W (· ∈ Set.range F.obj) = (MorphismProperty.isomorphisms _).inverseImage G 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : G ⊣ F) [F.Full] [F.Faithful]
Goal: (CategoryTheory.Localization.LeftBousfield.W fun x => x ∈ Set.range F.obj) =
  (CategoryTheory.MorphismProperty.isomorphisms C).inverseImage G
-- CategoryTheory.Localization.LeftBousfield.isLocalization
lemma isLocalization : G.IsLocalization (W (· ∈ Set.range F.obj)) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : G ⊣ F) [F.Full] [F.Faithful]
Goal: G.IsLocalization (CategoryTheory.Localization.LeftBousfield.W fun x => x ∈ Set.range F.obj)
-- CategoryTheory.NatTrans.appHom_apply
@[simps]
def appHom (X : C) : (F ⟶ G) →+ (F.obj X ⟶ G.obj X) 
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 D] {F G : CategoryTheory.Functor C D} (X : C) (α : F ⟶ G)
Goal: (CategoryTheory.NatTrans.appHom X) α = α.app X
-- CategoryTheory.NatTrans.app_zero
@[simp]
theorem app_zero (X : C) : (0 : F ⟶ G).app X = 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 D] {F G : CategoryTheory.Functor C D} (X : C)
Goal: CategoryTheory.NatTrans.app 0 X = 0
-- CategoryTheory.NatTrans.app_add
@[simp]
theorem app_add (X : C) (α β : F ⟶ G) : (α + β).app X = α.app X + β.app X 
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 D] {F G : CategoryTheory.Functor C D} (X : C) (α β : F ⟶ G)
Goal: (α + β).app X = α.app X + β.app X