ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.NonPreadditiveAbelian.add_comp
theorem add_comp (X Y Z : C) (f g : X ⟶ Y) (h : Y ⟶ Z) : (f + g) ≫ h = f ≫ h + g ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] (X Y Z : C) (f g : X ⟶ Y) (h : Y ⟶ Z)
Goal: (f + g) ≫ h = f ≫ h + g ≫ h
-- CategoryTheory.EffectiveEpiStruct.uniq
structure EffectiveEpiStruct {X Y : C} (f : Y ⟶ X) where
    desc : ∀ {W : C} (e : Y ⟶ W),
    (∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e) → (X ⟶ W)
    fac : ∀ {W : C} (e : Y ⟶ W)
    (h : ∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e),
    f ≫ desc e h = e
    uniq : ∀ {W : C} (e : Y ⟶ W)
    (h : ∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e)
    (m : X ⟶ W), f ≫ m = e → m = desc e h
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : Y ⟶ X} (self : CategoryTheory.EffectiveEpiStruct f) {W : C} (e : Y ⟶ W) (h :
  ∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
    CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
      CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e) (m : X ⟶ W)
Goal: CategoryTheory.CategoryStruct.comp f m = e → m = self.desc e ⋯
-- CategoryTheory.EffectiveEpiStruct.fac
structure EffectiveEpiStruct {X Y : C} (f : Y ⟶ X) where
    desc : ∀ {W : C} (e : Y ⟶ W),
    (∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e) → (X ⟶ W)
    fac : ∀ {W : C} (e : Y ⟶ W)
    (h : ∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e),
    f ≫ desc e h = e
    uniq : ∀ {W : C} (e : Y ⟶ W)
    (h : ∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e)
    (m : X ⟶ W), f ≫ m = e → m = desc e h
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : Y ⟶ X} (self : CategoryTheory.EffectiveEpiStruct f) {W : C} (e : Y ⟶ W) (h :
  ∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
    CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
      CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e)
Goal: CategoryTheory.CategoryStruct.comp f (self.desc e ⋯) = e
-- CategoryTheory.EffectiveEpi.effectiveEpi
class EffectiveEpi {X Y : C} (f : Y ⟶ X) : Prop where
    effectiveEpi : Nonempty (EffectiveEpiStruct f)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f : Y ⟶ X} [self : CategoryTheory.EffectiveEpi f]
Goal: Nonempty (CategoryTheory.EffectiveEpiStruct f)
-- CategoryTheory.EffectiveEpi.fac
@[reassoc (attr := simp)]
lemma EffectiveEpi.fac {X Y W : C} (f : Y ⟶ X) [EffectiveEpi f]
    (e : Y ⟶ W) (h : ∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e) :
    f ≫ EffectiveEpi.desc f e h = e 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y W : C} (f : Y ⟶ X) [CategoryTheory.EffectiveEpi f] (e : Y ⟶ W) (h :
  ∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
    CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
      CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.EffectiveEpi.desc f e ⋯) = e
-- CategoryTheory.EffectiveEpi.uniq
lemma EffectiveEpi.uniq {X Y W : C} (f : Y ⟶ X) [EffectiveEpi f]
    (e : Y ⟶ W) (h : ∀ {Z : C} (g₁ g₂ : Z ⟶ Y), g₁ ≫ f = g₂ ≫ f → g₁ ≫ e = g₂ ≫ e)
    (m : X ⟶ W) (hm : f ≫ m = e) :
    m = EffectiveEpi.desc f e h 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y W : C} (f : Y ⟶ X) [CategoryTheory.EffectiveEpi f] (e : Y ⟶ W) (h :
  ∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
    CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
      CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e) (m : X ⟶ W) (hm : CategoryTheory.CategoryStruct.comp f m = e)
Goal: m = CategoryTheory.EffectiveEpi.desc f e ⋯
-- CategoryTheory.EffectiveEpiFamilyStruct.uniq
structure EffectiveEpiFamilyStruct {B : C} {α : Type*}
    (X : α → C) (π : (a : α) → (X a ⟶ B)) where
    desc : ∀ {W} (e : (a : α) → (X a ⟶ W)),
          (∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
      g₁ ≫ π _ = g₂ ≫ π _ → g₁ ≫ e _ = g₂ ≫ e _) → (B ⟶ W)
    fac : ∀ {W} (e : (a : α) → (X a ⟶ W))
          (h : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
            g₁ ≫ π _ = g₂ ≫ π _ → g₁ ≫ e _ = g₂ ≫ e _)
          (a : α), π a ≫ desc e h = e a
    uniq : ∀ {W} (e : (a : α) → (X a ⟶ W))
          (h : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
            g₁ ≫ π _ = g₂ ≫ π _ → g₁ ≫ e _ = g₂ ≫ e _)
          (m : B ⟶ W), (∀ (a : α), π a ≫ m = e a) → m = desc e h
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B : C} {α : Type u_2} {X : α → C} {π : (a : α) → X a ⟶ B} (self : CategoryTheory.EffectiveEpiFamilyStruct X π) {W : C} (e : (a : α) → X a ⟶ W) (h :
  ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
    CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
      CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂)) (m : B ⟶ W)
Goal: (∀ (a : α), CategoryTheory.CategoryStruct.comp (π a) m = e a) → m = self.desc e ⋯
-- CategoryTheory.EffectiveEpiFamilyStruct.fac
structure EffectiveEpiFamilyStruct {B : C} {α : Type*}
    (X : α → C) (π : (a : α) → (X a ⟶ B)) where
    desc : ∀ {W} (e : (a : α) → (X a ⟶ W)),
          (∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
      g₁ ≫ π _ = g₂ ≫ π _ → g₁ ≫ e _ = g₂ ≫ e _) → (B ⟶ W)
    fac : ∀ {W} (e : (a : α) → (X a ⟶ W))
          (h : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
            g₁ ≫ π _ = g₂ ≫ π _ → g₁ ≫ e _ = g₂ ≫ e _)
          (a : α), π a ≫ desc e h = e a
    uniq : ∀ {W} (e : (a : α) → (X a ⟶ W))
          (h : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
            g₁ ≫ π _ = g₂ ≫ π _ → g₁ ≫ e _ = g₂ ≫ e _)
          (m : B ⟶ W), (∀ (a : α), π a ≫ m = e a) → m = desc e h
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B : C} {α : Type u_2} {X : α → C} {π : (a : α) → X a ⟶ B} (self : CategoryTheory.EffectiveEpiFamilyStruct X π) {W : C} (e : (a : α) → X a ⟶ W) (h :
  ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
    CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
      CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂)) (a : α)
Goal: CategoryTheory.CategoryStruct.comp (π a) (self.desc e ⋯) = e a
-- CategoryTheory.EffectiveEpiFamily.effectiveEpiFamily
class EffectiveEpiFamily {B : C} {α : Type*} (X : α → C) (π : (a : α) → (X a ⟶ B)) : Prop where
    effectiveEpiFamily : Nonempty (EffectiveEpiFamilyStruct X π)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B : C} {α : Type u_2} {X : α → C} {π : (a : α) → X a ⟶ B} [self : CategoryTheory.EffectiveEpiFamily X π]
Goal: Nonempty (CategoryTheory.EffectiveEpiFamilyStruct X π)
-- CategoryTheory.EffectiveEpiFamily.fac
@[reassoc (attr := simp)]
lemma EffectiveEpiFamily.fac {B W : C} {α : Type*} (X : α → C) (π : (a : α) → (X a ⟶ B))
    [EffectiveEpiFamily X π] (e : (a : α) → (X a ⟶ W))
    (h : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
      g₁ ≫ π _ = g₂ ≫ π _ → g₁ ≫ e _ = g₂ ≫ e _) (a : α) :
    π a ≫ EffectiveEpiFamily.desc X π e h = e a 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B W : C} {α : Type u_2} (X : α → C) (π : (a : α) → X a ⟶ B) [CategoryTheory.EffectiveEpiFamily X π] (e : (a : α) → X a ⟶ W) (h :
  ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
    CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
      CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂)) (a : α)
Goal: CategoryTheory.CategoryStruct.comp (π a) (CategoryTheory.EffectiveEpiFamily.desc X π e ⋯) = e a
-- CategoryTheory.EffectiveEpiFamily.uniq
lemma EffectiveEpiFamily.uniq {B W : C} {α : Type*} (X : α → C) (π : (a : α) → (X a ⟶ B))
    [EffectiveEpiFamily X π] (e : (a : α) → (X a ⟶ W))
    (h : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
      g₁ ≫ π _ = g₂ ≫ π _ → g₁ ≫ e _ = g₂ ≫ e _)
    (m : B ⟶ W) (hm : ∀ a, π a ≫ m = e a) :
    m = EffectiveEpiFamily.desc X π e h 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B W : C} {α : Type u_2} (X : α → C) (π : (a : α) → X a ⟶ B) [CategoryTheory.EffectiveEpiFamily X π] (e : (a : α) → X a ⟶ W) (h :
  ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
    CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
      CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂)) (m : B ⟶ W) (hm : ∀ (a : α), CategoryTheory.CategoryStruct.comp (π a) m = e a)
Goal: m = CategoryTheory.EffectiveEpiFamily.desc X π e ⋯
-- CategoryTheory.EffectiveEpiFamily.hom_ext
lemma EffectiveEpiFamily.hom_ext {B W : C} {α : Type*} (X : α → C) (π : (a : α) → (X a ⟶ B))
    [EffectiveEpiFamily X π] (m₁ m₂ : B ⟶ W) (h : ∀ a, π a ≫ m₁ = π a ≫ m₂) :
    m₁ = m₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B W : C} {α : Type u_2} (X : α → C) (π : (a : α) → X a ⟶ B) [CategoryTheory.EffectiveEpiFamily X π] (m₁ m₂ : B ⟶ W) (h : ∀ (a : α), CategoryTheory.CategoryStruct.comp (π a) m₁ = CategoryTheory.CategoryStruct.comp (π a) m₂)
Goal: m₁ = m₂
-- CategoryTheory.effectiveEpi_iff_effectiveEpiFamily
theorem effectiveEpi_iff_effectiveEpiFamily {B X : C} (f : X ⟶ B) :
    EffectiveEpi f ↔ EffectiveEpiFamily (fun () ↦ X) (fun () ↦ f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {B X : C} (f : X ⟶ B)
Goal: CategoryTheory.EffectiveEpi f ↔
  CategoryTheory.EffectiveEpiFamily (fun x => X) fun x =>
    match x with
    | PUnit.unit => f
-- CategoryTheory.EffectiveEpiFamily.reindex
lemma EffectiveEpiFamily.reindex
    {B : C} {α α' : Type*}
    (X : α → C)
    (π : (a : α) → (X a ⟶ B))
    (e : α' ≃ α)
    (h : EffectiveEpiFamily (fun a => X (e a)) (fun a => π (e a))) :
    EffectiveEpiFamily X π 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {B : C} {α : Type u_2} {α' : Type u_3} (X : α → C) (π : (a : α) → X a ⟶ B) (e : α' ≃ α) (h : CategoryTheory.EffectiveEpiFamily (fun a => X (e a)) fun a => π (e a))
Goal: CategoryTheory.EffectiveEpiFamily X π
-- CategoryTheory.Adjunction.inv_map_unit
@[simp]
theorem inv_map_unit {X : C} [IsIso (h.unit.app X)] :
    inv (L.map (h.unit.app X)) = h.counit.app (L.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) {X : C} [CategoryTheory.IsIso (h.unit.app X)]
Goal: CategoryTheory.inv (L.map (h.unit.app X)) = h.counit.app (L.obj X)
-- CategoryTheory.Adjunction.whiskerLeftLCounitIsoOfIsIsoUnit_inv_app
@[simps!]
noncomputable def whiskerLeftLCounitIsoOfIsIsoUnit [IsIso h.unit] : L ⋙ R ⋙ L ≅ L 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [CategoryTheory.IsIso h.unit] (X : C)
Goal: h.whiskerLeftLCounitIsoOfIsIsoUnit.inv.app X = L.map (h.unit.app X)
-- CategoryTheory.Adjunction.whiskerLeftLCounitIsoOfIsIsoUnit_hom_app
@[simps!]
noncomputable def whiskerLeftLCounitIsoOfIsIsoUnit [IsIso h.unit] : L ⋙ R ⋙ L ≅ L 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [CategoryTheory.IsIso h.unit] (X : C)
Goal: h.whiskerLeftLCounitIsoOfIsIsoUnit.hom.app X = h.counit.app (L.obj X)
-- CategoryTheory.Adjunction.inv_counit_map
@[simp]
theorem inv_counit_map {X : D} [IsIso (h.counit.app X)] :
    inv (R.map (h.counit.app X)) = h.unit.app (R.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) {X : D} [CategoryTheory.IsIso (h.counit.app X)]
Goal: CategoryTheory.inv (R.map (h.counit.app X)) = h.unit.app (R.obj X)
-- CategoryTheory.Adjunction.whiskerLeftRUnitIsoOfIsIsoCounit_inv_app
@[simps!]
noncomputable def whiskerLeftRUnitIsoOfIsIsoCounit [IsIso h.counit] : R ⋙ L ⋙ R ≅ R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [CategoryTheory.IsIso h.counit] (X : D)
Goal: h.whiskerLeftRUnitIsoOfIsIsoCounit.inv.app X = h.unit.app (R.obj X)
-- CategoryTheory.Adjunction.whiskerLeftRUnitIsoOfIsIsoCounit_hom_app
@[simps!]
noncomputable def whiskerLeftRUnitIsoOfIsIsoCounit [IsIso h.counit] : R ⋙ L ⋙ R ≅ R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [CategoryTheory.IsIso h.counit] (X : D)
Goal: h.whiskerLeftRUnitIsoOfIsIsoCounit.hom.app X = R.map (h.counit.app X)
-- CategoryTheory.Adjunction.faithful_L_of_mono_unit_app
lemma faithful_L_of_mono_unit_app [∀ X, Mono (h.unit.app X)] : L.Faithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [∀ (X : C), CategoryTheory.Mono (h.unit.app X)]
Goal: L.Faithful
-- CategoryTheory.Adjunction.full_L_of_isSplitEpi_unit_app
lemma full_L_of_isSplitEpi_unit_app [∀ X, IsSplitEpi (h.unit.app X)] : L.Full 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [∀ (X : C), CategoryTheory.IsSplitEpi (h.unit.app X)]
Goal: L.Full
-- CategoryTheory.Adjunction.faithful_R_of_epi_counit_app
lemma faithful_R_of_epi_counit_app [∀ X, Epi (h.counit.app X)] : R.Faithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [∀ (X : D), CategoryTheory.Epi (h.counit.app X)]
Goal: R.Faithful
-- CategoryTheory.Adjunction.full_R_of_isSplitMono_counit_app
lemma full_R_of_isSplitMono_counit_app [∀ X, IsSplitMono (h.counit.app X)] : R.Full 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [∀ (X : D), CategoryTheory.IsSplitMono (h.counit.app X)]
Goal: R.Full
-- CategoryTheory.Adjunction.isIso_counit_app_iff_mem_essImage
lemma isIso_counit_app_iff_mem_essImage [L.Faithful] [L.Full] {X : D} :
    IsIso (h.counit.app X) ↔ X ∈ L.essImage 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [L.Faithful] [L.Full] {X : D}
Goal: CategoryTheory.IsIso (h.counit.app X) ↔ X ∈ L.essImage
-- CategoryTheory.Adjunction.mem_essImage_of_counit_isIso
lemma mem_essImage_of_counit_isIso (A : D)
    [IsIso (h.counit.app A)] : A ∈ L.essImage 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) (A : D) [CategoryTheory.IsIso (h.counit.app A)]
Goal: A ∈ L.essImage
-- CategoryTheory.Adjunction.isIso_counit_app_of_iso
lemma isIso_counit_app_of_iso [L.Faithful] [L.Full] {X : D} {Y : C} (e : X ≅ L.obj Y) :
    IsIso (h.counit.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [L.Faithful] [L.Full] {X : D} {Y : C} (e : X ≅ L.obj Y)
Goal: CategoryTheory.IsIso (h.counit.app X)
-- CategoryTheory.Adjunction.isIso_unit_app_iff_mem_essImage
lemma isIso_unit_app_iff_mem_essImage [R.Faithful] [R.Full] {Y : C} :
    IsIso (h.unit.app Y) ↔ Y ∈ R.essImage 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [R.Faithful] [R.Full] {Y : C}
Goal: CategoryTheory.IsIso (h.unit.app Y) ↔ Y ∈ R.essImage
-- CategoryTheory.Adjunction.mem_essImage_of_unit_isIso
theorem mem_essImage_of_unit_isIso (A : C)
    [IsIso (h.unit.app A)] : A ∈ R.essImage 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) (A : C) [CategoryTheory.IsIso (h.unit.app A)]
Goal: A ∈ R.essImage
-- CategoryTheory.Adjunction.isIso_unit_app_of_iso
lemma isIso_unit_app_of_iso [R.Faithful] [R.Full] {X : D} {Y : C} (e : Y ≅ R.obj X) :
    IsIso (h.unit.app Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [R.Faithful] [R.Full] {X : D} {Y : C} (e : Y ≅ R.obj X)
Goal: CategoryTheory.IsIso (h.unit.app Y)
-- CategoryTheory.Adjunction.isEquivalence_left_of_isEquivalence_right
lemma isEquivalence_left_of_isEquivalence_right (h : L ⊣ R) [R.IsEquivalence] : L.IsEquivalence 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [R.IsEquivalence]
Goal: L.IsEquivalence
-- CategoryTheory.Adjunction.isEquivalence_right_of_isEquivalence_left
lemma isEquivalence_right_of_isEquivalence_left (h : L ⊣ R) [L.IsEquivalence] : R.IsEquivalence 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) [L.IsEquivalence]
Goal: R.IsEquivalence
-- CategoryTheory.InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_hom_naturality
@[reassoc]
lemma InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_hom_naturality
    {X Y : C} (f : X ⟶ Y) (I : InjectiveResolution X) (J : InjectiveResolution Y)
    (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)
    (F : C ⥤ D) [F.Additive] :
    F.rightDerivedToHomotopyCategory.map f ≫ (J.isoRightDerivedToHomotopyCategoryObj F).hom =
      (I.isoRightDerivedToHomotopyCategoryObj F).hom ≫
        (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).map φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasInjectiveResolutions C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X) (J : CategoryTheory.InjectiveResolution Y) (φ : I.cocomplex ⟶ J.cocomplex) (comm : CategoryTheory.CategoryStruct.comp (I.ι.f 0) (φ.f 0) = CategoryTheory.CategoryStruct.comp f (J.ι.f 0)) (F : CategoryTheory.Functor C D) [F.Additive]
Goal: CategoryTheory.CategoryStruct.comp (F.rightDerivedToHomotopyCategory.map f)
    (J.isoRightDerivedToHomotopyCategoryObj F).hom =
  CategoryTheory.CategoryStruct.comp (I.isoRightDerivedToHomotopyCategoryObj F).hom
    (((F.mapHomologicalComplex (ComplexShape.up ℕ)).comp (HomotopyCategory.quotient D (ComplexShape.up ℕ))).map φ)
-- CategoryTheory.InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_inv_naturality
@[reassoc]
lemma InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_inv_naturality
    {X Y : C} (f : X ⟶ Y) (I : InjectiveResolution X) (J : InjectiveResolution Y)
    (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)
    (F : C ⥤ D) [F.Additive] :
    (I.isoRightDerivedToHomotopyCategoryObj F).inv ≫ F.rightDerivedToHomotopyCategory.map f =
      (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).map φ ≫
        (J.isoRightDerivedToHomotopyCategoryObj F).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasInjectiveResolutions C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X) (J : CategoryTheory.InjectiveResolution Y) (φ : I.cocomplex ⟶ J.cocomplex) (comm : CategoryTheory.CategoryStruct.comp (I.ι.f 0) (φ.f 0) = CategoryTheory.CategoryStruct.comp f (J.ι.f 0)) (F : CategoryTheory.Functor C D) [F.Additive]
Goal: CategoryTheory.CategoryStruct.comp (I.isoRightDerivedToHomotopyCategoryObj F).inv
    (F.rightDerivedToHomotopyCategory.map f) =
  CategoryTheory.CategoryStruct.comp
    (((F.mapHomologicalComplex (ComplexShape.up ℕ)).comp (HomotopyCategory.quotient D (ComplexShape.up ℕ))).map φ)
    (J.isoRightDerivedToHomotopyCategoryObj F).inv
-- CategoryTheory.InjectiveResolution.isoRightDerivedObj_hom_naturality
@[reassoc]
lemma InjectiveResolution.isoRightDerivedObj_hom_naturality
    {X Y : C} (f : X ⟶ Y) (I : InjectiveResolution X) (J : InjectiveResolution Y)
    (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)
    (F : C ⥤ D) [F.Additive] (n : ℕ) :
    (F.rightDerived n).map f ≫ (J.isoRightDerivedObj F n).hom =
      (I.isoRightDerivedObj F n).hom ≫
        (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasInjectiveResolutions C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X) (J : CategoryTheory.InjectiveResolution Y) (φ : I.cocomplex ⟶ J.cocomplex) (comm : CategoryTheory.CategoryStruct.comp (I.ι.f 0) (φ.f 0) = CategoryTheory.CategoryStruct.comp f (J.ι.f 0)) (F : CategoryTheory.Functor C D) [F.Additive] (n : ℕ)
Goal: CategoryTheory.CategoryStruct.comp ((F.rightDerived n).map f) (J.isoRightDerivedObj F n).hom =
  CategoryTheory.CategoryStruct.comp (I.isoRightDerivedObj F n).hom
    (((F.mapHomologicalComplex (ComplexShape.up ℕ)).comp
          (HomologicalComplex.homologyFunctor D (ComplexShape.up ℕ) n)).map
      φ)
-- CategoryTheory.InjectiveResolution.isoRightDerivedObj_inv_naturality
@[reassoc]
lemma InjectiveResolution.isoRightDerivedObj_inv_naturality
    {X Y : C} (f : X ⟶ Y) (I : InjectiveResolution X) (J : InjectiveResolution Y)
    (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)
    (F : C ⥤ D) [F.Additive] (n : ℕ) :
    (I.isoRightDerivedObj F n).inv ≫ (F.rightDerived n).map f =
        (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map φ ≫
          (J.isoRightDerivedObj F n).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasInjectiveResolutions C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X) (J : CategoryTheory.InjectiveResolution Y) (φ : I.cocomplex ⟶ J.cocomplex) (comm : CategoryTheory.CategoryStruct.comp (I.ι.f 0) (φ.f 0) = CategoryTheory.CategoryStruct.comp f (J.ι.f 0)) (F : CategoryTheory.Functor C D) [F.Additive] (n : ℕ)
Goal: CategoryTheory.CategoryStruct.comp (I.isoRightDerivedObj F n).inv ((F.rightDerived n).map f) =
  CategoryTheory.CategoryStruct.comp
    (((F.mapHomologicalComplex (ComplexShape.up ℕ)).comp
          (HomologicalComplex.homologyFunctor D (ComplexShape.up ℕ) n)).map
      φ)
    (J.isoRightDerivedObj F n).inv
-- CategoryTheory.Functor.isZero_rightDerived_obj_injective_succ
lemma Functor.isZero_rightDerived_obj_injective_succ
    (F : C ⥤ D) [F.Additive] (n : ℕ) (X : C) [Injective X] :
    IsZero ((F.rightDerived (n+1)).obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasInjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] (n : ℕ) (X : C) [CategoryTheory.Injective X]
Goal: CategoryTheory.Limits.IsZero ((F.rightDerived (n + 1)).obj X)