ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/CategoryTheory/Sites/PreservesLocallyBijective.lean

full_name: CategoryTheory.Presheaf.isLocallyInjective_whisker
code: lemma isLocallyInjective_whisker [H.IsCocontinuous J K] [IsLocallyInjective K f] :
    IsLocallyInjective J (whiskerLeft H.op f) 
goal: CategoryTheory.Presheaf.IsLocallyInjective J (CategoryTheory.whiskerLeft H.op f)

full_name: CategoryTheory.Presheaf.isLocallyInjective_of_whisker
code: lemma isLocallyInjective_of_whisker (hH : CoverPreserving J K H)
    [H.IsCoverDense K] [IsLocallyInjective J (whiskerLeft H.op f)] : IsLocallyInjective K f 
goal: CategoryTheory.Presheaf.IsLocallyInjective K f

full_name: CategoryTheory.Presheaf.isLocallyInjective_whisker_iff
code: lemma isLocallyInjective_whisker_iff (hH : CoverPreserving J K H) [H.IsCocontinuous J K]
    [H.IsCoverDense K] : IsLocallyInjective J (whiskerLeft H.op f) ↔ IsLocallyInjective K f 
goal: CategoryTheory.Presheaf.IsLocallyInjective J (CategoryTheory.whiskerLeft H.op f) ↔
  CategoryTheory.Presheaf.IsLocallyInjective K f

full_name: CategoryTheory.Presheaf.isLocallySurjective_whisker
code: lemma isLocallySurjective_whisker [H.IsCocontinuous J K] [IsLocallySurjective K f] :
    IsLocallySurjective J (whiskerLeft H.op f) 
goal: CategoryTheory.Presheaf.IsLocallySurjective J (CategoryTheory.whiskerLeft H.op f)

full_name: CategoryTheory.Presheaf.isLocallySurjective_of_whisker
code: lemma isLocallySurjective_of_whisker (hH : CoverPreserving J K H)
    [H.IsCoverDense K] [IsLocallySurjective J (whiskerLeft H.op f)] : IsLocallySurjective K f 
goal: CategoryTheory.Presheaf.IsLocallySurjective K f

full_name: CategoryTheory.Presheaf.isLocallySurjective_whisker_iff
code: lemma isLocallySurjective_whisker_iff (hH : CoverPreserving J K H) [H.IsCocontinuous J K]
    [H.IsCoverDense K] : IsLocallySurjective J (whiskerLeft H.op f) ↔ IsLocallySurjective K f 
goal: CategoryTheory.Presheaf.IsLocallySurjective J (CategoryTheory.whiskerLeft H.op f) ↔
  CategoryTheory.Presheaf.IsLocallySurjective K f
File: Mathlib/CategoryTheory/Sites/MayerVietorisSquare.lean

full_name: CategoryTheory.GrothendieckTopology.MayerVietorisSquare
code: /-- A Mayer-Vietoris square in a category `C` equipped with a Grothendieck
topology consists of a commutative square `f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄` in `C`
such that `f₁₃` is a monomorphism and that the square becomes a
pushout square in the category of sheaves of sets. -/
structure MayerVietorisSquare extends Square C where
  mono_f₁₃ : Mono toSquare.f₁₃ := by infer_instance
  /-- the square becomes a pushout square in the category of sheaves of types -/
  isPushout : (toSquare.map (yoneda ⋙ presheafToSheaf J _)).IsPushout
goal: Type (max u v)

full_name: CategoryTheory.GrothendieckTopology.MayerVietorisSquare.mono_f₁₃
code: /-- A Mayer-Vietoris square in a category `C` equipped with a Grothendieck
topology consists of a commutative square `f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄` in `C`
such that `f₁₃` is a monomorphism and that the square becomes a
pushout square in the category of sheaves of sets. -/
structure MayerVietorisSquare extends Square C where
  mono_f₁₃ : Mono toSquare.f₁₃ := by infer_instance
  /-- the square becomes a pushout square in the category of sheaves of types -/
  isPushout : (toSquare.map (yoneda ⋙ presheafToSheaf J _)).IsPushout
goal: CategoryTheory.Mono self.f₁₃

full_name: CategoryTheory.GrothendieckTopology.MayerVietorisSquare.isPushout
code: /-- A Mayer-Vietoris square in a category `C` equipped with a Grothendieck
topology consists of a commutative square `f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄` in `C`
such that `f₁₃` is a monomorphism and that the square becomes a
pushout square in the category of sheaves of sets. -/
structure MayerVietorisSquare extends Square C where
  mono_f₁₃ : Mono toSquare.f₁₃ := by infer_instance
  /-- the square becomes a pushout square in the category of sheaves of types -/
  isPushout : (toSquare.map (yoneda ⋙ presheafToSheaf J _)).IsPushout
goal: (self.map (CategoryTheory.yoneda.comp (CategoryTheory.presheafToSheaf J (Type v)))).IsPushout
File: Mathlib/CategoryTheory/Sites/SheafCohomology/Basic.lean

full_name: CategoryTheory.Sheaf.H
code: /-- The cohomology of an abelian sheaf in degree `n`. -/
def H (n : ℕ) : Type w' 
goal: Type w'

full_name: CategoryTheory.Sheaf.instAddCommGroupH
code: noncomputable instance (n : ℕ) : AddCommGroup (F.H n) 
goal: AddCommGroup (F.H n)

full_name: CategoryTheory.Sheaf.cohomologyPresheafFunctor
code: /-- The bifunctor which sends an abelian sheaf `F` and an object `U` to the
`n`th Ext-group from the free abelian sheaf generated by the
presheaf of sets `yoneda.obj U` to `F`. -/
noncomputable def cohomologyPresheafFunctor (n : ℕ) :
    Sheaf J AddCommGrp.{v} ⥤ Cᵒᵖ ⥤ AddCommGrp.{w'} 
goal: CategoryTheory.Functor (CategoryTheory.Sheaf J AddCommGrp) (CategoryTheory.Functor Cᵒᵖ AddCommGrp)

full_name: CategoryTheory.Sheaf.cohomologyPresheaf
code: /-- Given an abelian sheaf `F`, this is the presheaf which sends `U`
to the `n`th Ext-group from the free abelian sheaf generated by the
presheaf of sets `yoneda.obj U` to `F`. -/
noncomputable abbrev cohomologyPresheaf (F : Sheaf J AddCommGrp.{v}) (n : ℕ) :
    Cᵒᵖ ⥤ AddCommGrp.{w'} 
goal: CategoryTheory.Functor Cᵒᵖ AddCommGrp
File: Mathlib/CategoryTheory/Sites/Spaces.lean

full_name: Opens.grothendieckTopology
code: /-- The Grothendieck topology associated to a topological space. -/
def grothendieckTopology : GrothendieckTopology (Opens T) 
goal: CategoryTheory.GrothendieckTopology (TopologicalSpace.Opens T)

full_name: Opens.pretopology
code: /-- The Grothendieck pretopology associated to a topological space. -/
def pretopology : Pretopology (Opens T) 
goal: CategoryTheory.Pretopology (TopologicalSpace.Opens T)

full_name: Opens.pretopology_ofGrothendieck
code: /-- The pretopology associated to a space is the largest pretopology that
    generates the Grothendieck topology associated to the space. -/
@[simp]
theorem pretopology_ofGrothendieck :
    Pretopology.ofGrothendieck _ (Opens.grothendieckTopology T) = Opens.pretopology T 
goal: CategoryTheory.Pretopology.ofGrothendieck (TopologicalSpace.Opens T) (Opens.grothendieckTopology T) =
  Opens.pretopology T

full_name: Opens.pretopology_toGrothendieck
code: /-- The pretopology associated to a space induces the Grothendieck topology associated to the space.
-/
@[simp]
theorem pretopology_toGrothendieck :
    Pretopology.toGrothendieck _ (Opens.pretopology T) = Opens.grothendieckTopology T 
goal: CategoryTheory.Pretopology.toGrothendieck (TopologicalSpace.Opens T) (Opens.pretopology T) =
  Opens.grothendieckTopology T
File: Mathlib/CategoryTheory/Sites/Pullback.lean

full_name: CategoryTheory.instCreatesLimitsSheafFunctorOppositeSheafToPresheafOfHasLimits
code: instance [HasLimits A] : CreatesLimits (sheafToPresheaf J A) 
goal: CategoryTheory.CreatesLimits (CategoryTheory.sheafToPresheaf J A)

full_name: CategoryTheory.instIsCofilteredCover
code: instance {X : C} : IsCofiltered (J.Cover X) 
goal: CategoryTheory.IsCofiltered (J.Cover X)

full_name: CategoryTheory.Functor.sheafPullback_obj
code: /-- The pullback functor `Sheaf J A ⥤ Sheaf K A` associated to a functor `G : C ⥤ D` in the
same direction as `G`. -/
@[simps!]
def Functor.sheafPullback : Sheaf J A ⥤ Sheaf K A 
goal: (G.sheafPullback A J K).obj X = (CategoryTheory.presheafToSheaf K A).obj (G.op.lan.obj X.val)

full_name: CategoryTheory.Functor.sheafPullback_map
code: /-- The pullback functor `Sheaf J A ⥤ Sheaf K A` associated to a functor `G : C ⥤ D` in the
same direction as `G`. -/
@[simps!]
def Functor.sheafPullback : Sheaf J A ⥤ Sheaf K A 
goal: ∀ {X Y : CategoryTheory.Sheaf J A} (f : X ⟶ Y),
  (G.sheafPullback A J K).map f = (CategoryTheory.presheafToSheaf K A).map (G.op.lan.map f.val)

full_name: CategoryTheory.Functor.sheafPullback
code: /-- The pullback functor `Sheaf J A ⥤ Sheaf K A` associated to a functor `G : C ⥤ D` in the
same direction as `G`. -/
@[simps!]
def Functor.sheafPullback : Sheaf J A ⥤ Sheaf K A 
goal: CategoryTheory.Functor (CategoryTheory.Sheaf J A) (CategoryTheory.Sheaf K A)

full_name: CategoryTheory.instPreservesFiniteLimitsSheafSheafPullbackOfRepresentablyFlat
code: instance [RepresentablyFlat G] : PreservesFiniteLimits (G.sheafPullback A J K) 
goal: CategoryTheory.Limits.PreservesFiniteLimits (G.sheafPullback A J K)

full_name: CategoryTheory.Functor.sheafAdjunctionContinuous
code: /-- The pullback functor is left adjoint to the pushforward functor. -/
def Functor.sheafAdjunctionContinuous [Functor.IsContinuous.{v₁} G J K] :
    G.sheafPullback A J K ⊣ G.sheafPushforwardContinuous A J K 
goal: G.sheafPullback A J K ⊣ G.sheafPushforwardContinuous A J K
File: Mathlib/CategoryTheory/Sites/ConstantSheaf.lean

full_name: CategoryTheory.constantPresheafAdj
code: /-- The constant presheaf functor is left adjoint to evaluation at a terminal object. -/
noncomputable def constantPresheafAdj {T : C} (hT : IsTerminal T) :
    Functor.const Cᵒᵖ ⊣ (evaluation Cᵒᵖ D).obj (op T) 
goal: CategoryTheory.Functor.const Cᵒᵖ ⊣ (CategoryTheory.evaluation Cᵒᵖ D).obj (Opposite.op T)

full_name: CategoryTheory.constantSheaf
code: /--
The functor which maps an object of `D` to the constant sheaf at that object, i.e. the
sheafification of the constant presheaf.
-/
noncomputable def constantSheaf : D ⥤ Sheaf J D 
goal: CategoryTheory.Functor D (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.constantSheafAdj
code: /-- The constant sheaf functor is left adjoint to evaluation at a terminal object. -/
noncomputable def constantSheafAdj {T : C} (hT : IsTerminal T) :
    constantSheaf J D ⊣ (sheafSections J D).obj (op T) 
goal: CategoryTheory.constantSheaf J D ⊣ (CategoryTheory.sheafSections J D).obj (Opposite.op T)

full_name: CategoryTheory.constantSheafAdj_counit_app
code: lemma constantSheafAdj_counit_app {T : C} (hT : IsTerminal T) (F : Sheaf J D) :
    (constantSheafAdj J D hT).counit.app F =
      (presheafToSheaf J D).map ((constantPresheafAdj D hT).counit.app F.val) ≫
        (sheafificationAdjunction J D).counit.app F 
goal: (CategoryTheory.constantSheafAdj J D hT).counit.app F =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.presheafToSheaf J D).map ((CategoryTheory.constantPresheafAdj D hT).counit.app F.val))
    ((CategoryTheory.sheafificationAdjunction J D).counit.app F)
File: Mathlib/CategoryTheory/Sites/Localization.lean

full_name: CategoryTheory.GrothendieckTopology.W
code: /-- The class of morphisms of presheaves which become isomorphisms after sheafification.
(See `GrothendieckTopology.W_iff`.) -/
abbrev W : MorphismProperty (Cᵒᵖ ⥤ A) 
goal: CategoryTheory.MorphismProperty (CategoryTheory.Functor Cᵒᵖ A)

full_name: CategoryTheory.GrothendieckTopology.W_eq_W_range_sheafToPresheaf_obj
code: lemma W_eq_W_range_sheafToPresheaf_obj :
    J.W = LeftBousfield.W (· ∈ Set.range (sheafToPresheaf J A).obj) 
goal: J.W = CategoryTheory.Localization.LeftBousfield.W fun x => x ∈ Set.range (CategoryTheory.sheafToPresheaf J A).obj

full_name: CategoryTheory.GrothendieckTopology.W_sheafToPreheaf_map_iff_isIso
code: lemma W_sheafToPreheaf_map_iff_isIso {F₁ F₂ : Sheaf J A} (φ : F₁ ⟶ F₂) :
    J.W ((sheafToPresheaf J A).map φ) ↔ IsIso φ 
goal: J.W ((CategoryTheory.sheafToPresheaf J A).map φ) ↔ CategoryTheory.IsIso φ

full_name: CategoryTheory.GrothendieckTopology.W_adj_unit_app
code: lemma W_adj_unit_app (adj : G ⊣ sheafToPresheaf J A) (P : Cᵒᵖ ⥤ A) : J.W (adj.unit.app P) 
goal: J.W (adj.unit.app P)

full_name: CategoryTheory.GrothendieckTopology.W_iff_isIso_map_of_adjunction
code: lemma W_iff_isIso_map_of_adjunction (adj : G ⊣ sheafToPresheaf J A)
    {P₁ P₂ : Cᵒᵖ ⥤ A} (f : P₁ ⟶ P₂) :
    J.W f ↔ IsIso (G.map f) 
goal: J.W f ↔ CategoryTheory.IsIso (G.map f)

full_name: CategoryTheory.GrothendieckTopology.W_eq_inverseImage_isomorphisms_of_adjunction
code: lemma W_eq_inverseImage_isomorphisms_of_adjunction (adj : G ⊣ sheafToPresheaf J A) :
    J.W = (MorphismProperty.isomorphisms _).inverseImage G 
goal: J.W = (CategoryTheory.MorphismProperty.isomorphisms (CategoryTheory.Sheaf J A)).inverseImage G

full_name: CategoryTheory.GrothendieckTopology.W_toSheafify
code: lemma W_toSheafify (P : Cᵒᵖ ⥤ A) : J.W (toSheafify J P) 
goal: J.W (CategoryTheory.toSheafify J P)

full_name: CategoryTheory.GrothendieckTopology.W_iff
code: lemma W_iff {P₁ P₂ : Cᵒᵖ ⥤ A} (f : P₁ ⟶ P₂) :
    J.W f ↔ IsIso ((presheafToSheaf J A).map f) 
goal: J.W f ↔ CategoryTheory.IsIso ((CategoryTheory.presheafToSheaf J A).map f)

full_name: CategoryTheory.GrothendieckTopology.W_eq_inverseImage_isomorphisms
code: lemma W_eq_inverseImage_isomorphisms :
    J.W = (MorphismProperty.isomorphisms _).inverseImage (presheafToSheaf J A) 
goal: J.W =
  (CategoryTheory.MorphismProperty.isomorphisms (CategoryTheory.Sheaf J A)).inverseImage
    (CategoryTheory.presheafToSheaf J A)

full_name: CategoryTheory.GrothendieckTopology.instIsLocalizationFunctorOppositeSheafPresheafToSheafW
code: instance : (presheafToSheaf J A).IsLocalization J.W 
goal: (CategoryTheory.presheafToSheaf J A).IsLocalization J.W
File: Mathlib/CategoryTheory/Groupoid/Basic.lean

full_name: CategoryTheory.Groupoid.isThin_iff
code: theorem isThin_iff : Quiver.IsThin C ↔ ∀ c : C, Subsingleton (c ⟶ c) 
goal: Quiver.IsThin C ↔ ∀ (c : C), Subsingleton (c ⟶ c)

full_name: CategoryTheory.Groupoid.IsTotallyDisconnected
code: /-- A subgroupoid is totally disconnected if it only has loops. -/
def IsTotallyDisconnected 
goal: Prop
File: Mathlib/CategoryTheory/Groupoid/VertexGroup.lean

full_name: CategoryTheory.Groupoid.vertexGroup_mul
code: /-- The vertex group at `c`. -/
@[simps mul one inv]
instance vertexGroup (c : C) : Group (c ⟶ c) 
goal: x * y = CategoryTheory.CategoryStruct.comp x y

full_name: CategoryTheory.Groupoid.vertexGroup_inv
code: /-- The vertex group at `c`. -/
@[simps mul one inv]
instance vertexGroup (c : C) : Group (c ⟶ c) 
goal: ∀ (a : c ⟶ c), a⁻¹ = CategoryTheory.Groupoid.inv a

full_name: CategoryTheory.Groupoid.vertexGroup_one
code: /-- The vertex group at `c`. -/
@[simps mul one inv]
instance vertexGroup (c : C) : Group (c ⟶ c) 
goal: 1 = CategoryTheory.CategoryStruct.id c

full_name: CategoryTheory.Groupoid.vertexGroup
code: /-- The vertex group at `c`. -/
@[simps mul one inv]
instance vertexGroup (c : C) : Group (c ⟶ c) 
goal: Group (c ⟶ c)

full_name: CategoryTheory.Groupoid.vertexGroup.inv_eq_inv
code: /-- The inverse in the group is equal to the inverse given by `CategoryTheory.inv`. -/
theorem vertexGroup.inv_eq_inv (c : C) (γ : c ⟶ c) : γ⁻¹ = CategoryTheory.inv γ 
goal: γ⁻¹ = CategoryTheory.inv γ

full_name: CategoryTheory.Groupoid.vertexGroupIsomOfMap_symm_apply
code: /-- An arrow in the groupoid defines, by conjugation, an isomorphism of groups between
its endpoints.
-/
@[simps]
def vertexGroupIsomOfMap {c d : C} (f : c ⟶ d) : (c ⟶ c) ≃* (d ⟶ d) 
goal: (CategoryTheory.Groupoid.vertexGroupIsomOfMap f).symm δ =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp δ (CategoryTheory.Groupoid.inv f))

full_name: CategoryTheory.Groupoid.vertexGroupIsomOfMap
code: /-- An arrow in the groupoid defines, by conjugation, an isomorphism of groups between
its endpoints.
-/
@[simps]
def vertexGroupIsomOfMap {c d : C} (f : c ⟶ d) : (c ⟶ c) ≃* (d ⟶ d) 
goal: (c ⟶ c) ≃* (d ⟶ d)

full_name: CategoryTheory.Groupoid.vertexGroupIsomOfMap_apply
code: /-- An arrow in the groupoid defines, by conjugation, an isomorphism of groups between
its endpoints.
-/
@[simps]
def vertexGroupIsomOfMap {c d : C} (f : c ⟶ d) : (c ⟶ c) ≃* (d ⟶ d) 
goal: (CategoryTheory.Groupoid.vertexGroupIsomOfMap f) γ =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv f) (CategoryTheory.CategoryStruct.comp γ f)

full_name: CategoryTheory.Groupoid.vertexGroupIsomOfPath
code: /-- A path in the groupoid defines an isomorphism between its endpoints.
-/
def vertexGroupIsomOfPath {c d : C} (p : Quiver.Path c d) : (c ⟶ c) ≃* (d ⟶ d) 
goal: (c ⟶ c) ≃* (d ⟶ d)

full_name: CategoryTheory.Groupoid.CategoryTheory.Functor.mapVertexGroup
code: /-- A functor defines a morphism of vertex group. -/
@[simps]
def CategoryTheory.Functor.mapVertexGroup {D : Type v} [Groupoid D] (φ : C ⥤ D) (c : C) :
    (c ⟶ c) →* (φ.obj c ⟶ φ.obj c) 
goal: (c ⟶ c) →* (φ.obj c ⟶ φ.obj c)

full_name: CategoryTheory.Groupoid.CategoryTheory.Functor.mapVertexGroup_apply
code: /-- A functor defines a morphism of vertex group. -/
@[simps]
def CategoryTheory.Functor.mapVertexGroup {D : Type v} [Groupoid D] (φ : C ⥤ D) (c : C) :
    (c ⟶ c) →* (φ.obj c ⟶ φ.obj c) 
goal: ∀ (a : c ⟶ c), (CategoryTheory.Groupoid.CategoryTheory.Functor.mapVertexGroup φ c) a = φ.map a
File: Mathlib/CategoryTheory/Core.lean

full_name: CategoryTheory.Core
code: /-- The core of a category C is the groupoid whose morphisms are all the
isomorphisms of C. -/
-- Porting note(#5171): linter not yet ported
-- @[nolint has_nonempty_instance]

def Core (C : Type u₁) 
goal: Type u₁

full_name: CategoryTheory.coreCategory
code: instance coreCategory : Groupoid.{v₁} (Core C) 
goal: CategoryTheory.Groupoid (CategoryTheory.Core C)

full_name: CategoryTheory.Core.id_hom
code: @[simp]
/- Porting note: abomination -/
theorem id_hom (X : C) : Iso.hom (coreCategory.id X) = @CategoryStruct.id C _ X 
goal: (CategoryTheory.CategoryStruct.id X).hom = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Core.comp_hom
code: @[simp]
theorem comp_hom {X Y Z : Core C} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g).hom = f.hom ≫ g.hom 
goal: (CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom

full_name: CategoryTheory.Core.inclusion
code: /-- The core of a category is naturally included in the category. -/
def inclusion : Core C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Core C) C

full_name: CategoryTheory.Core.instFaithfulInclusion
code: instance : (inclusion C).Faithful 
goal: (CategoryTheory.Core.inclusion C).Faithful

full_name: CategoryTheory.Core.functorToCore
code: /-- A functor from a groupoid to a category C factors through the core of C. -/
def functorToCore (F : G ⥤ C) : G ⥤ Core C 
goal: CategoryTheory.Functor G (CategoryTheory.Core C)

full_name: CategoryTheory.Core.forgetFunctorToCore
code: /-- We can functorially associate to any functor from a groupoid to the core of a category `C`,
a functor from the groupoid to `C`, simply by composing with the embedding `Core C ⥤ C`.
-/
def forgetFunctorToCore : (G ⥤ Core C) ⥤ G ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Functor G (CategoryTheory.Core C)) (CategoryTheory.Functor G C)

full_name: CategoryTheory.ofEquivFunctor
code: /-- `ofEquivFunctor m` lifts a type-level `EquivFunctor`
to a categorical functor `Core (Type u₁) ⥤ Core (Type u₂)`.
-/
def ofEquivFunctor (m : Type u₁ → Type u₂) [EquivFunctor m] : Core (Type u₁) ⥤ Core (Type u₂) 
goal: CategoryTheory.Functor (CategoryTheory.Core (Type u₁)) (CategoryTheory.Core (Type u₂))
File: Mathlib/CategoryTheory/Preadditive/Yoneda/Projective.lean

full_name: CategoryTheory.Projective.projective_iff_preservesEpimorphisms_preadditiveCoyoneda_obj
code: theorem projective_iff_preservesEpimorphisms_preadditiveCoyoneda_obj (P : C) :
    Projective P ↔ (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms 
goal: CategoryTheory.Projective P ↔ (CategoryTheory.preadditiveCoyoneda.obj (Opposite.op P)).PreservesEpimorphisms

full_name: CategoryTheory.Projective.projective_iff_preservesEpimorphisms_preadditiveCoyoneda_obj'
code: theorem projective_iff_preservesEpimorphisms_preadditiveCoyoneda_obj' (P : C) :
    Projective P ↔ (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms 
goal: CategoryTheory.Projective P ↔ (CategoryTheory.preadditiveCoyoneda.obj (Opposite.op P)).PreservesEpimorphisms
File: Mathlib/CategoryTheory/Preadditive/Yoneda/Limits.lean

full_name: CategoryTheory.preservesLimitsPreadditiveYonedaObj
code: instance preservesLimitsPreadditiveYonedaObj (X : C) : PreservesLimits (preadditiveYonedaObj X) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.preadditiveYonedaObj X)

full_name: CategoryTheory.preservesLimitsPreadditiveCoyonedaObj
code: instance preservesLimitsPreadditiveCoyonedaObj (X : Cᵒᵖ) :
    PreservesLimits (preadditiveCoyonedaObj X) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.preadditiveCoyonedaObj X)

full_name: CategoryTheory.PreservesLimitsPreadditiveYoneda.obj
code: instance PreservesLimitsPreadditiveYoneda.obj (X : C) : PreservesLimits (preadditiveYoneda.obj X) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.preadditiveYoneda.obj X)

full_name: CategoryTheory.PreservesLimitsPreadditiveCoyoneda.obj
code: instance PreservesLimitsPreadditiveCoyoneda.obj (X : Cᵒᵖ) :
    PreservesLimits (preadditiveCoyoneda.obj X) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.preadditiveCoyoneda.obj X)
File: Mathlib/CategoryTheory/Preadditive/Yoneda/Injective.lean

full_name: CategoryTheory.Injective.injective_iff_preservesEpimorphisms_preadditiveYoneda_obj
code: theorem injective_iff_preservesEpimorphisms_preadditiveYoneda_obj (J : C) :
    Injective J ↔ (preadditiveYoneda.obj J).PreservesEpimorphisms 
goal: CategoryTheory.Injective J ↔ (CategoryTheory.preadditiveYoneda.obj J).PreservesEpimorphisms

full_name: CategoryTheory.Injective.injective_iff_preservesEpimorphisms_preadditive_yoneda_obj'
code: theorem injective_iff_preservesEpimorphisms_preadditive_yoneda_obj' (J : C) :
    Injective J ↔ (preadditiveYonedaObj J).PreservesEpimorphisms 
goal: CategoryTheory.Injective J ↔ (CategoryTheory.preadditiveYonedaObj J).PreservesEpimorphisms
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

full_name: CategoryTheory.Preadditive.isSeparating_iff
code: theorem Preadditive.isSeparating_iff (𝒢 : Set C) :
    IsSeparating 𝒢 ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ f = 0) → f = 0 
goal: CategoryTheory.IsSeparating 𝒢 ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ f = 0) → f = 0

full_name: CategoryTheory.Preadditive.isCoseparating_iff
code: theorem Preadditive.isCoseparating_iff (𝒢 : Set C) :
    IsCoseparating 𝒢 ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = 0) → f = 0 
goal: CategoryTheory.IsCoseparating 𝒢 ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = 0) → f = 0

full_name: CategoryTheory.Preadditive.isSeparator_iff
code: theorem Preadditive.isSeparator_iff (G : C) :
    IsSeparator G ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ h : G ⟶ X, h ≫ f = 0) → f = 0 
goal: CategoryTheory.IsSeparator G ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : G ⟶ X), h ≫ f = 0) → f = 0

full_name: CategoryTheory.Preadditive.isCoseparator_iff
code: theorem Preadditive.isCoseparator_iff (G : C) :
    IsCoseparator G ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ h : Y ⟶ G, f ≫ h = 0) → f = 0 
goal: CategoryTheory.IsCoseparator G ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : Y ⟶ G), f ≫ h = 0) → f = 0

full_name: CategoryTheory.isSeparator_iff_faithful_preadditiveCoyoneda
code: theorem isSeparator_iff_faithful_preadditiveCoyoneda (G : C) :
    IsSeparator G ↔ (preadditiveCoyoneda.obj (op G)).Faithful 
goal: CategoryTheory.IsSeparator G ↔ (CategoryTheory.preadditiveCoyoneda.obj (Opposite.op G)).Faithful

full_name: CategoryTheory.isSeparator_iff_faithful_preadditiveCoyonedaObj
code: theorem isSeparator_iff_faithful_preadditiveCoyonedaObj (G : C) :
    IsSeparator G ↔ (preadditiveCoyonedaObj (op G)).Faithful 
goal: CategoryTheory.IsSeparator G ↔ (CategoryTheory.preadditiveCoyonedaObj (Opposite.op G)).Faithful

full_name: CategoryTheory.isCoseparator_iff_faithful_preadditiveYoneda
code: theorem isCoseparator_iff_faithful_preadditiveYoneda (G : C) :
    IsCoseparator G ↔ (preadditiveYoneda.obj G).Faithful 
goal: CategoryTheory.IsCoseparator G ↔ (CategoryTheory.preadditiveYoneda.obj G).Faithful

full_name: CategoryTheory.isCoseparator_iff_faithful_preadditiveYonedaObj
code: theorem isCoseparator_iff_faithful_preadditiveYonedaObj (G : C) :
    IsCoseparator G ↔ (preadditiveYonedaObj G).Faithful 
goal: CategoryTheory.IsCoseparator G ↔ (CategoryTheory.preadditiveYonedaObj G).Faithful
File: Mathlib/CategoryTheory/Preadditive/SingleObj.lean

full_name: CategoryTheory.instPreadditiveSingleObj
code: instance : Preadditive (SingleObj α) 
goal: CategoryTheory.Preadditive (CategoryTheory.SingleObj α)