ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.unit_obj_eq_map_unit
theorem unit_obj_eq_map_unit [Reflective i] (X : C) :
    (reflectorAdjunction i).unit.app (i.obj ((reflector i).obj X)) =
      i.map ((reflector i).map ((reflectorAdjunction i).unit.app X)) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (i : CategoryTheory.Functor D C) [CategoryTheory.Reflective i] (X : C)
Goal: (CategoryTheory.reflectorAdjunction i).unit.app (i.obj ((CategoryTheory.reflector i).obj X)) =
  i.map ((CategoryTheory.reflector i).map ((CategoryTheory.reflectorAdjunction i).unit.app X))
-- CategoryTheory.Functor.essImage.unit_isIso
theorem Functor.essImage.unit_isIso [Reflective i] {A : C} (h : A ∈ i.essImage) :
    IsIso ((reflectorAdjunction i).unit.app A) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i] {A : C} (h : A ∈ i.essImage)
Goal: CategoryTheory.IsIso ((CategoryTheory.reflectorAdjunction i).unit.app A)
-- CategoryTheory.mem_essImage_of_unit_isSplitMono
theorem mem_essImage_of_unit_isSplitMono [Reflective i] {A : C}
    [IsSplitMono ((reflectorAdjunction i).unit.app A)] : A ∈ i.essImage 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i] {A : C} [CategoryTheory.IsSplitMono ((CategoryTheory.reflectorAdjunction i).unit.app A)]
Goal: A ∈ i.essImage
-- CategoryTheory.unitCompPartialBijectiveAux_symm_apply
theorem unitCompPartialBijectiveAux_symm_apply [Reflective i] {A : C} {B : D}
    (f : i.obj ((reflector i).obj A) ⟶ i.obj B) :
    (unitCompPartialBijectiveAux _ _).symm f = (reflectorAdjunction i).unit.app A ≫ f 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i] {A : C} {B : D} (f : i.obj ((CategoryTheory.reflector i).obj A) ⟶ i.obj B)
Goal: (CategoryTheory.unitCompPartialBijectiveAux A B).symm f =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.reflectorAdjunction i).unit.app A) f
-- CategoryTheory.unitCompPartialBijective_symm_apply
@[simp]
theorem unitCompPartialBijective_symm_apply [Reflective i] (A : C) {B : C} (hB : B ∈ i.essImage)
    (f) : (unitCompPartialBijective A hB).symm f = (reflectorAdjunction i).unit.app A ≫ f 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i] (A : C) {B : C} (hB : B ∈ i.essImage) (f : i.obj ((CategoryTheory.reflector i).obj A) ⟶ B)
Goal: (CategoryTheory.unitCompPartialBijective A hB).symm f =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.reflectorAdjunction i).unit.app A) f
-- CategoryTheory.unitCompPartialBijective_symm_natural
theorem unitCompPartialBijective_symm_natural [Reflective i] (A : C) {B B' : C} (h : B ⟶ B')
    (hB : B ∈ i.essImage) (hB' : B' ∈ i.essImage) (f : i.obj ((reflector i).obj A) ⟶ B) :
    (unitCompPartialBijective A hB').symm (f ≫ h) = (unitCompPartialBijective A hB).symm f ≫ h 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i] (A : C) {B B' : C} (h : B ⟶ B') (hB : B ∈ i.essImage) (hB' : B' ∈ i.essImage) (f : i.obj ((CategoryTheory.reflector i).obj A) ⟶ B)
Goal: (CategoryTheory.unitCompPartialBijective A hB').symm (CategoryTheory.CategoryStruct.comp f h) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.unitCompPartialBijective A hB).symm f) h
-- CategoryTheory.unitCompPartialBijective_natural
theorem unitCompPartialBijective_natural [Reflective i] (A : C) {B B' : C} (h : B ⟶ B')
    (hB : B ∈ i.essImage) (hB' : B' ∈ i.essImage) (f : A ⟶ B) :
    (unitCompPartialBijective A hB') (f ≫ h) = unitCompPartialBijective A hB f ≫ h 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i] (A : C) {B B' : C} (h : B ⟶ B') (hB : B ∈ i.essImage) (hB' : B' ∈ i.essImage) (f : A ⟶ B)
Goal: (CategoryTheory.unitCompPartialBijective A hB') (CategoryTheory.CategoryStruct.comp f h) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.unitCompPartialBijective A hB) f) h
-- CategoryTheory.equivEssImageOfReflective_map_counitIso_app_hom
lemma equivEssImageOfReflective_map_counitIso_app_hom [Reflective i]
    (X : Functor.EssImageSubcategory i) :
  (Functor.essImageInclusion i).map (equivEssImageOfReflective_counitIso_app X).hom =
    inv (NatTrans.app (reflectorAdjunction i).unit X.obj) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i] (X : i.EssImageSubcategory)
Goal: i.essImageInclusion.map (CategoryTheory.equivEssImageOfReflective_counitIso_app X).hom =
  CategoryTheory.inv ((CategoryTheory.reflectorAdjunction i).unit.app X.obj)
-- CategoryTheory.equivEssImageOfReflective_map_counitIso_app_inv
lemma equivEssImageOfReflective_map_counitIso_app_inv [Reflective i]
    (X : Functor.EssImageSubcategory i) :
  (Functor.essImageInclusion i).map (equivEssImageOfReflective_counitIso_app X).inv =
    (NatTrans.app (reflectorAdjunction i).unit X.obj) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i] (X : i.EssImageSubcategory)
Goal: i.essImageInclusion.map (CategoryTheory.equivEssImageOfReflective_counitIso_app X).inv =
  (CategoryTheory.reflectorAdjunction i).unit.app X.obj
-- CategoryTheory.equivEssImageOfReflective_unitIso
@[simps]
def equivEssImageOfReflective [Reflective i] : D ≌ i.EssImageSubcategory 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i]
Goal: CategoryTheory.equivEssImageOfReflective.unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun X => (CategoryTheory.asIso ((CategoryTheory.reflectorAdjunction i).counit.app X)).symm) ⋯
-- CategoryTheory.equivEssImageOfReflective_inverse
@[simps]
def equivEssImageOfReflective [Reflective i] : D ≌ i.EssImageSubcategory 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i]
Goal: CategoryTheory.equivEssImageOfReflective.inverse = i.essImageInclusion.comp (CategoryTheory.reflector i)
-- CategoryTheory.equivEssImageOfReflective_counitIso
@[simps]
def equivEssImageOfReflective [Reflective i] : D ≌ i.EssImageSubcategory 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i]
Goal: CategoryTheory.equivEssImageOfReflective.counitIso =
  CategoryTheory.NatIso.ofComponents CategoryTheory.equivEssImageOfReflective_counitIso_app ⋯
-- CategoryTheory.equivEssImageOfReflective_functor
@[simps]
def equivEssImageOfReflective [Reflective i] : D ≌ i.EssImageSubcategory 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C} [CategoryTheory.Reflective i]
Goal: CategoryTheory.equivEssImageOfReflective.functor = i.toEssImage
-- CategoryTheory.counit_obj_eq_map_counit
lemma counit_obj_eq_map_counit [Coreflective j] (X : D) :
    (coreflectorAdjunction j).counit.app (j.obj ((coreflector j).obj X)) =
      j.map ((coreflector j).map ((coreflectorAdjunction j).counit.app X)) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (j : CategoryTheory.Functor C D) [CategoryTheory.Coreflective j] (X : D)
Goal: (CategoryTheory.coreflectorAdjunction j).counit.app (j.obj ((CategoryTheory.coreflector j).obj X)) =
  j.map ((CategoryTheory.coreflector j).map ((CategoryTheory.coreflectorAdjunction j).counit.app X))
-- CategoryTheory.Functor.essImage.counit_isIso
lemma Functor.essImage.counit_isIso [Coreflective j] {A : D} (h : A ∈ j.essImage) :
    IsIso ((coreflectorAdjunction j).counit.app A) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {j : CategoryTheory.Functor C D} [CategoryTheory.Coreflective j] {A : D} (h : A ∈ j.essImage)
Goal: CategoryTheory.IsIso ((CategoryTheory.coreflectorAdjunction j).counit.app A)
-- CategoryTheory.mem_essImage_of_counit_isSplitEpi
lemma mem_essImage_of_counit_isSplitEpi [Coreflective j] {A : D}
    [IsSplitEpi ((coreflectorAdjunction j).counit.app A)] : A ∈ j.essImage 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {j : CategoryTheory.Functor C D} [CategoryTheory.Coreflective j] {A : D} [CategoryTheory.IsSplitEpi ((CategoryTheory.coreflectorAdjunction j).counit.app A)]
Goal: A ∈ j.essImage
-- CategoryTheory.Adjunction.whiskerRight_unit_app_app
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G 
Arguments: (C : Type u_1) {D : Type u_2} {E : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} (adj : F ⊣ G) (X : CategoryTheory.Functor C D)
Goal: ∀ (X_1 : C), ((CategoryTheory.Adjunction.whiskerRight C adj).unit.app X).app X_1 = adj.unit.app (X.obj X_1)
-- CategoryTheory.Adjunction.whiskerRight_counit_app_app
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G 
Arguments: (C : Type u_1) {D : Type u_2} {E : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} (adj : F ⊣ G) (X : CategoryTheory.Functor C E)
Goal: ∀ (X_1 : C), ((CategoryTheory.Adjunction.whiskerRight C adj).counit.app X).app X_1 = adj.counit.app (X.obj X_1)
-- CategoryTheory.Adjunction.whiskerLeft_counit_app_app
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F 
Arguments: (C : Type u_1) {D : Type u_2} {E : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} (adj : F ⊣ G) (X : CategoryTheory.Functor E C)
Goal: ∀ (X_1 : E), ((CategoryTheory.Adjunction.whiskerLeft C adj).counit.app X).app X_1 = X.map (adj.counit.app X_1)
-- CategoryTheory.Adjunction.whiskerLeft_unit_app_app
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F 
Arguments: (C : Type u_1) {D : Type u_2} {E : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} (adj : F ⊣ G) (X : CategoryTheory.Functor D C)
Goal: ∀ (X_1 : D), ((CategoryTheory.Adjunction.whiskerLeft C adj).unit.app X).app X_1 = X.map (adj.unit.app X_1)
-- CategoryTheory.leftAdjointOfStructuredArrowInitialsAux_apply
@[simps]
def leftAdjointOfStructuredArrowInitialsAux (A : C) (B : D) :
    ((⊥_ StructuredArrow A G).right ⟶ B) ≃ (A ⟶ G.obj B) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor D C) [∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)] (A : C) (B : D) (g : (⊥_ CategoryTheory.StructuredArrow A G).right ⟶ B)
Goal: (CategoryTheory.leftAdjointOfStructuredArrowInitialsAux G A B) g =
  CategoryTheory.CategoryStruct.comp (⊥_ CategoryTheory.StructuredArrow A G).hom (G.map g)
-- CategoryTheory.leftAdjointOfStructuredArrowInitialsAux_symm_apply
@[simps]
def leftAdjointOfStructuredArrowInitialsAux (A : C) (B : D) :
    ((⊥_ StructuredArrow A G).right ⟶ B) ≃ (A ⟶ G.obj B) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor D C) [∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)] (A : C) (B : D) (f : A ⟶ G.obj B)
Goal: (CategoryTheory.leftAdjointOfStructuredArrowInitialsAux G A B).symm f =
  (CategoryTheory.Limits.initial.to (CategoryTheory.StructuredArrow.mk f)).right
-- CategoryTheory.isRightAdjointOfStructuredArrowInitials
lemma isRightAdjointOfStructuredArrowInitials : G.IsRightAdjoint 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor D C) [∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)]
Goal: G.IsRightAdjoint
-- CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux_symm_apply
@[simps]
def rightAdjointOfCostructuredArrowTerminalsAux (B : D) (A : C) :
    (G.obj B ⟶ A) ≃ (B ⟶ (⊤_ CostructuredArrow G A).left) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor D C) [∀ (A : C), CategoryTheory.Limits.HasTerminal (CategoryTheory.CostructuredArrow G A)] (B : D) (A : C) (g : B ⟶ (⊤_ CategoryTheory.CostructuredArrow G A).left)
Goal: (CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux G B A).symm g =
  CategoryTheory.CategoryStruct.comp (G.map g) (⊤_ CategoryTheory.CostructuredArrow G A).hom
-- CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux_apply
@[simps]
def rightAdjointOfCostructuredArrowTerminalsAux (B : D) (A : C) :
    (G.obj B ⟶ A) ≃ (B ⟶ (⊤_ CostructuredArrow G A).left) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor D C) [∀ (A : C), CategoryTheory.Limits.HasTerminal (CategoryTheory.CostructuredArrow G A)] (B : D) (A : C) (g : G.obj B ⟶ A)
Goal: (CategoryTheory.rightAdjointOfCostructuredArrowTerminalsAux G B A) g =
  (CategoryTheory.Limits.terminal.from (CategoryTheory.CostructuredArrow.mk g)).left
-- CategoryTheory.isLeftAdjoint_of_costructuredArrowTerminals
lemma isLeftAdjoint_of_costructuredArrowTerminals : G.IsLeftAdjoint 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor D C) [∀ (A : C), CategoryTheory.Limits.HasTerminal (CategoryTheory.CostructuredArrow G A)]
Goal: G.IsLeftAdjoint
-- CategoryTheory.isRightAdjoint_iff_hasInitial_structuredArrow
theorem isRightAdjoint_iff_hasInitial_structuredArrow {G : D ⥤ C} :
    G.IsRightAdjoint ↔ ∀ A, HasInitial (StructuredArrow A G) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {G : CategoryTheory.Functor D C}
Goal: G.IsRightAdjoint ↔ ∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)
-- CategoryTheory.isLeftAdjoint_iff_hasTerminal_costructuredArrow
theorem isLeftAdjoint_iff_hasTerminal_costructuredArrow {F : C ⥤ D} :
    F.IsLeftAdjoint ↔ ∀ A, HasTerminal (CostructuredArrow F A) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D}
Goal: F.IsLeftAdjoint ↔ ∀ (A : D), CategoryTheory.Limits.HasTerminal (CategoryTheory.CostructuredArrow F A)
-- CategoryTheory.Adjunction.map_restrictFullyFaithful_unit_app
@[simp, reassoc]
lemma map_restrictFullyFaithful_unit_app (X : C) :
    iC.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).unit.app X) =
    adj.unit.app (iC.obj X) ≫ R'.map (comm1.hom.app X) ≫ comm2.hom.app (L.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {C' : Type u₃} [CategoryTheory.Category.{v₃, u₃} C'] {D' : Type u₄} [CategoryTheory.Category.{v₄, u₄} D'] {iC : CategoryTheory.Functor C C'} {iD : CategoryTheory.Functor D D'} {L' : CategoryTheory.Functor C' D'} {R' : CategoryTheory.Functor D' C'} (adj : L' ⊣ R') (hiC : iC.FullyFaithful) (hiD : iD.FullyFaithful) {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (comm1 : iC.comp L' ≅ L.comp iD) (comm2 : iD.comp R' ≅ R.comp iC) (X : C)
Goal: iC.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).unit.app X) =
  CategoryTheory.CategoryStruct.comp (adj.unit.app (iC.obj X))
    (CategoryTheory.CategoryStruct.comp (R'.map (comm1.hom.app X)) (comm2.hom.app (L.obj X)))
-- CategoryTheory.Adjunction.map_restrictFullyFaithful_counit_app
@[simp, reassoc]
lemma map_restrictFullyFaithful_counit_app (X : D) :
    iD.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).counit.app X) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {C' : Type u₃} [CategoryTheory.Category.{v₃, u₃} C'] {D' : Type u₄} [CategoryTheory.Category.{v₄, u₄} D'] {iC : CategoryTheory.Functor C C'} {iD : CategoryTheory.Functor D D'} {L' : CategoryTheory.Functor C' D'} {R' : CategoryTheory.Functor D' C'} (adj : L' ⊣ R') (hiC : iC.FullyFaithful) (hiD : iD.FullyFaithful) {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (comm1 : iC.comp L' ≅ L.comp iD) (comm2 : iD.comp R' ≅ R.comp iC) (X : D)
Goal: iD.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).counit.app X) =
  CategoryTheory.CategoryStruct.comp (comm1.inv.app (R.obj X))
    (CategoryTheory.CategoryStruct.comp (L'.map (comm2.inv.app X)) (adj.counit.app (iD.obj X)))
-- CategoryTheory.Adjunction.restrictFullyFaithful_homEquiv_apply
lemma restrictFullyFaithful_homEquiv_apply {X : C} {Y : D} (f : L.obj X ⟶ Y) :
    (adj.restrictFullyFaithful hiC hiD comm1 comm2).homEquiv X Y f =
      hiC.preimage (adj.unit.app (iC.obj X) ≫ R'.map (comm1.hom.app X) ≫
        R'.map (iD.map f) ≫ comm2.hom.app Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {C' : Type u₃} [CategoryTheory.Category.{v₃, u₃} C'] {D' : Type u₄} [CategoryTheory.Category.{v₄, u₄} D'] {iC : CategoryTheory.Functor C C'} {iD : CategoryTheory.Functor D D'} {L' : CategoryTheory.Functor C' D'} {R' : CategoryTheory.Functor D' C'} (adj : L' ⊣ R') (hiC : iC.FullyFaithful) (hiD : iD.FullyFaithful) {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (comm1 : iC.comp L' ≅ L.comp iD) (comm2 : iD.comp R' ≅ R.comp iC) {X : C} {Y : D} (f : L.obj X ⟶ Y)
Goal: ((adj.restrictFullyFaithful hiC hiD comm1 comm2).homEquiv X Y) f =
  hiC.preimage
    (CategoryTheory.CategoryStruct.comp (adj.unit.app (iC.obj X))
      (CategoryTheory.CategoryStruct.comp (R'.map (comm1.hom.app X))
        (CategoryTheory.CategoryStruct.comp (R'.map (iD.map f)) (comm2.hom.app Y))))
-- CategoryTheory.effectiveEpi_desc_iff_effectiveEpiFamily
theorem effectiveEpi_desc_iff_effectiveEpiFamily {α : Type} [Finite α]
    {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) :
    EffectiveEpi (Sigma.desc π) ↔ EffectiveEpiFamily X π 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.FinitaryPreExtensive C] {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → X a ⟶ B)
Goal: CategoryTheory.EffectiveEpi (CategoryTheory.Limits.Sigma.desc π) ↔ CategoryTheory.EffectiveEpiFamily X π
-- CategoryTheory.ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj_inv_naturality
@[reassoc]
lemma ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj_inv_naturality
    {X Y : C} (f : X ⟶ Y) (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] :
    (P.isoLeftDerivedToHomotopyCategoryObj F).inv ≫ F.leftDerivedToHomotopyCategory.map f =
      (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).map φ ≫
        (Q.isoLeftDerivedToHomotopyCategoryObj 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.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y) (φ : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp (φ.f 0) (Q.π.f 0) = CategoryTheory.CategoryStruct.comp (P.π.f 0) f) (F : CategoryTheory.Functor C D) [F.Additive]
Goal: CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedToHomotopyCategoryObj F).inv
    (F.leftDerivedToHomotopyCategory.map f) =
  CategoryTheory.CategoryStruct.comp
    (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp (HomotopyCategory.quotient D (ComplexShape.down ℕ))).map φ)
    (Q.isoLeftDerivedToHomotopyCategoryObj F).inv
-- CategoryTheory.ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj_hom_naturality
@[reassoc]
lemma ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj_hom_naturality
    {X Y : C} (f : X ⟶ Y) (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] :
    F.leftDerivedToHomotopyCategory.map f ≫ (Q.isoLeftDerivedToHomotopyCategoryObj F).hom =
      (P.isoLeftDerivedToHomotopyCategoryObj 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.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y) (φ : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp (φ.f 0) (Q.π.f 0) = CategoryTheory.CategoryStruct.comp (P.π.f 0) f) (F : CategoryTheory.Functor C D) [F.Additive]
Goal: CategoryTheory.CategoryStruct.comp (F.leftDerivedToHomotopyCategory.map f)
    (Q.isoLeftDerivedToHomotopyCategoryObj F).hom =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedToHomotopyCategoryObj F).hom
    (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp (HomotopyCategory.quotient D (ComplexShape.down ℕ))).map φ)
-- CategoryTheory.ProjectiveResolution.isoLeftDerivedObj_hom_naturality
@[reassoc]
lemma ProjectiveResolution.isoLeftDerivedObj_hom_naturality
    {X Y : C} (f : X ⟶ Y) (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] (n : ℕ) :
    (F.leftDerived n).map f ≫ (Q.isoLeftDerivedObj F n).hom =
      (P.isoLeftDerivedObj 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.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y) (φ : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp (φ.f 0) (Q.π.f 0) = CategoryTheory.CategoryStruct.comp (P.π.f 0) f) (F : CategoryTheory.Functor C D) [F.Additive] (n : ℕ)
Goal: CategoryTheory.CategoryStruct.comp ((F.leftDerived n).map f) (Q.isoLeftDerivedObj F n).hom =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F n).hom
    (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp
          (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n)).map
      φ)