ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Dynamics/Ergodic/AddCircle.lean

full_name: AddCircle.ae_empty_or_univ_of_forall_vadd_ae_eq_self
code: /-- If a null-measurable subset of the circle is almost invariant under rotation by a family of
rational angles with denominators tending to infinity, then it must be almost empty or almost full.
-/
theorem ae_empty_or_univ_of_forall_vadd_ae_eq_self {s : Set <| AddCircle T}
    (hs : NullMeasurableSet s volume) {ι : Type*} {l : Filter ι} [l.NeBot] {u : ι → AddCircle T}
    (hu₁ : ∀ i, (u i +ᵥ s : Set _) =ᵐ[volume] s) (hu₂ : Tendsto (addOrderOf ∘ u) l atTop) :
    s =ᵐ[volume] (∅ : Set <| AddCircle T) ∨ s =ᵐ[volume] univ 
goal: s =ᵐ[MeasureTheory.volume] ∅ ∨ s =ᵐ[MeasureTheory.volume] Set.univ

full_name: AddCircle.ergodic_zsmul
code: theorem ergodic_zsmul {n : ℤ} (hn : 1 < |n|) : Ergodic fun y : AddCircle T => n • y 
goal: Ergodic (fun y => n • y) MeasureTheory.volume

full_name: AddCircle.ergodic_nsmul
code: theorem ergodic_nsmul {n : ℕ} (hn : 1 < n) : Ergodic fun y : AddCircle T => n • y 
goal: Ergodic (fun y => n • y) MeasureTheory.volume

full_name: AddCircle.ergodic_zsmul_add
code: theorem ergodic_zsmul_add (x : AddCircle T) {n : ℤ} (h : 1 < |n|) : Ergodic fun y => n • y + x 
goal: Ergodic (fun y => n • y + x) MeasureTheory.volume

full_name: AddCircle.ergodic_nsmul_add
code: theorem ergodic_nsmul_add (x : AddCircle T) {n : ℕ} (h : 1 < n) : Ergodic fun y => n • y + x 
goal: Ergodic (fun y => n • y + x) MeasureTheory.volume
File: Mathlib/CategoryTheory/Quotient/Preadditive.lean

full_name: CategoryTheory.Quotient.Preadditive.add
code: /-- The addition on the morphisms in the category `Quotient r` when `r` is compatible
with the addition. -/
def add (hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y) (_ : r f₁ f₂) (_ : r g₁ g₂), r (f₁ + g₁) (f₂ + g₂))
    {X Y : Quotient r} (f g : X ⟶ Y) : X ⟶ Y 
goal: X ⟶ Y

full_name: CategoryTheory.Quotient.Preadditive.neg
code: /-- The negation on the morphisms in the category `Quotient r` when `r` is compatible
with the addition. -/
def neg (hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y) (_ : r f₁ f₂) (_ : r g₁ g₂), r (f₁ + g₁) (f₂ + g₂))
    {X Y : Quotient r} (f : X ⟶ Y) : X ⟶ Y 
goal: X ⟶ Y

full_name: CategoryTheory.Quotient.preadditive
code: /-- The preadditive structure on the category `Quotient r` when `r` is compatible
with the addition. -/
def preadditive
    (hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y) (_ : r f₁ f₂) (_ : r g₁ g₂), r (f₁ + g₁) (f₂ + g₂)) :
    Preadditive (Quotient r) 
goal: CategoryTheory.Preadditive (CategoryTheory.Quotient r)

full_name: CategoryTheory.Quotient.functor_additive
code: lemma functor_additive
    (hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y) (_ : r f₁ f₂) (_ : r g₁ g₂), r (f₁ + g₁) (f₂ + g₂)) :
    letI := preadditive r hr
    (functor r).Additive 
goal: (CategoryTheory.Quotient.functor r).Additive
File: Mathlib/CategoryTheory/Closed/Types.lean

full_name: CategoryTheory.Types.binaryProductAdjunction
code: /-- The adjunction `Limits.Types.binaryProductFunctor.obj X ⊣ coyoneda.obj (Opposite.op X)`
for any `X : Type v₁`. -/
def Types.binaryProductAdjunction (X : Type v₁) :
    Limits.Types.binaryProductFunctor.obj X ⊣ coyoneda.obj (Opposite.op X) 
goal: CategoryTheory.Limits.Types.binaryProductFunctor.obj X ⊣ CategoryTheory.coyoneda.obj (Opposite.op X)

full_name: CategoryTheory.instIsLeftAdjointObjFunctorTypeBinaryProductFunctor
code: instance (X : Type v₁) : (Types.binaryProductFunctor.obj X).IsLeftAdjoint 
goal: (CategoryTheory.Limits.Types.binaryProductFunctor.obj X).IsLeftAdjoint

full_name: CategoryTheory.instHasFiniteProductsType
code: instance : HasFiniteProducts (Type v₁) 
goal: CategoryTheory.Limits.HasFiniteProducts (Type v₁)

full_name: CategoryTheory.instCartesianClosedType
code: instance : CartesianClosed (Type v₁) 
goal: CategoryTheory.CartesianClosed (Type v₁)

full_name: CategoryTheory.instHasFiniteProductsFunctorType
code: instance {C : Type u₁} [Category.{v₁} C] : HasFiniteProducts (C ⥤ Type u₂) 
goal: CategoryTheory.Limits.HasFiniteProducts (CategoryTheory.Functor C (Type u₂))

full_name: CategoryTheory.instCartesianClosedFunctorType
code: instance {C : Type v₁} [SmallCategory C] : CartesianClosed (C ⥤ Type v₁) 
goal: CategoryTheory.CartesianClosed (CategoryTheory.Functor C (Type v₁))
File: Mathlib/CategoryTheory/Closed/Zero.lean

full_name: CategoryTheory.uniqueHomsetOfInitialIsoTerminal
code: /-- If a cartesian closed category has an initial object which is isomorphic to the terminal object,
then each homset has exactly one element.
-/
def uniqueHomsetOfInitialIsoTerminal [HasInitial C] (i : ⊥_ C ≅ ⊤_ C) (X Y : C) : Unique (X ⟶ Y) 
goal: Unique (X ⟶ Y)

full_name: CategoryTheory.uniqueHomsetOfZero
code: /-- If a cartesian closed category has a zero object, each homset has exactly one element. -/
def uniqueHomsetOfZero [HasZeroObject C] (X Y : C) : Unique (X ⟶ Y) 
goal: Unique (X ⟶ Y)

full_name: CategoryTheory.equivPUnit
code: /-- A cartesian closed category with a zero object is equivalent to the category with one object and
one morphism.
-/
def equivPUnit [HasZeroObject C] : C ≌ Discrete PUnit.{w + 1} 
goal: C ≌ CategoryTheory.Discrete PUnit.{w + 1}
File: Mathlib/CategoryTheory/Subobject/Types.lean

full_name: subtype_val_mono
code: theorem subtype_val_mono {α : Type u} (s : Set α) : Mono (↾(Subtype.val : s → α)) 
goal: CategoryTheory.Mono (↾Subtype.val)

full_name: Types.monoOverEquivalenceSet
code: /-- The category of `MonoOver α`, for `α : Type u`, is equivalent to the partial order `Set α`.
-/
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
goal: CategoryTheory.MonoOver α ≌ Set α

full_name: Types.monoOverEquivalenceSet_inverse_obj
code: /-- The category of `MonoOver α`, for `α : Type u`, is equivalent to the partial order `Set α`.
-/
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
goal: (Types.monoOverEquivalenceSet α).inverse.obj s = CategoryTheory.MonoOver.mk' Subtype.val

full_name: Types.monoOverEquivalenceSet_functor_map
code: /-- The category of `MonoOver α`, for `α : Type u`, is equivalent to the partial order `Set α`.
-/
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
goal: (Types.monoOverEquivalenceSet α).functor.map t = CategoryTheory.homOfLE ⋯

full_name: Types.monoOverEquivalenceSet_inverse_map
code: /-- The category of `MonoOver α`, for `α : Type u`, is equivalent to the partial order `Set α`.
-/
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
goal: (Types.monoOverEquivalenceSet α).inverse.map b = CategoryTheory.MonoOver.homMk (fun w => ⟨↑w, ⋯⟩) ⋯

full_name: Types.monoOverEquivalenceSet_counitIso
code: /-- The category of `MonoOver α`, for `α : Type u`, is equivalent to the partial order `Set α`.
-/
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
goal: (Types.monoOverEquivalenceSet α).counitIso = CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.eqToIso ⋯) ⋯

full_name: Types.monoOverEquivalenceSet_unitIso
code: /-- The category of `MonoOver α`, for `α : Type u`, is equivalent to the partial order `Set α`.
-/
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
goal: (Types.monoOverEquivalenceSet α).unitIso =
  CategoryTheory.NatIso.ofComponents (fun f => CategoryTheory.MonoOver.isoMk (Equiv.ofInjective f.obj.hom ⋯).toIso ⋯) ⋯

full_name: Types.monoOverEquivalenceSet_functor_obj
code: /-- The category of `MonoOver α`, for `α : Type u`, is equivalent to the partial order `Set α`.
-/
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
goal: (Types.monoOverEquivalenceSet α).functor.obj f = Set.range f.obj.hom

full_name: instWellPoweredType
code: instance : WellPowered (Type u) 
goal: CategoryTheory.WellPowered (Type u)

full_name: Types.subobjectEquivSet
code: /-- For `α : Type u`, `Subobject α` is order isomorphic to `Set α`.
-/
noncomputable def Types.subobjectEquivSet (α : Type u) : Subobject α ≃o Set α 
goal: CategoryTheory.Subobject α ≃o Set α
File: Mathlib/CategoryTheory/Quotient/Linear.lean

full_name: CategoryTheory.Quotient.Linear.smul
code: /-- The scalar multiplications on morphisms in `Quotient R`. -/
def smul (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y) (_ : r f₁ f₂), r (a • f₁) (a • f₂))
    (X Y : Quotient r) : SMul R (X ⟶ Y) 
goal: SMul R (X ⟶ Y)

full_name: CategoryTheory.Quotient.Linear.smul_eq
code: @[simp]
lemma smul_eq (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y) (_ : r f₁ f₂), r (a • f₁) (a • f₂))
    (a : R) {X Y : C} (f : X ⟶ Y) :
    letI := smul r hr
    a • (functor r).map f = (functor r).map (a • f) 
goal: a • (CategoryTheory.Quotient.functor r).map f = (CategoryTheory.Quotient.functor r).map (a • f)

full_name: CategoryTheory.Quotient.Linear.module'
code: /-- Auxiliary definition for `Quotient.Linear.module`. -/
def module' (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y) (_ : r f₁ f₂), r (a • f₁) (a • f₂))
    [Preadditive (Quotient r)] [(functor r).Additive] (X Y : C) :
    Module R ((functor r).obj X ⟶ (functor r).obj Y) 
goal: Module R ((CategoryTheory.Quotient.functor r).obj X ⟶ (CategoryTheory.Quotient.functor r).obj Y)

full_name: CategoryTheory.Quotient.Linear.module
code: /-- Auxiliary definition for `Quotient.linear`. -/
def module (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y) (_ : r f₁ f₂), r (a • f₁) (a • f₂))
    [Preadditive (Quotient r)] [(functor r).Additive] (X Y : Quotient r) :
    Module R (X ⟶ Y) 
goal: Module R (X ⟶ Y)

full_name: CategoryTheory.Quotient.linear
code: /-- Assuming `Quotient r` has already been endowed with a preadditive category structure
such that `functor r : C ⥤ Quotient r` is additive, and that `C` has a `R`-linear category
structure compatible with `r`, this is the induced `R`-linear category structure on
`Quotient r`. -/
def linear (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y) (_ : r f₁ f₂), r (a • f₁) (a • f₂))
    [Preadditive (Quotient r)] [(functor r).Additive] : Linear R (Quotient r) 
goal: CategoryTheory.Linear R (CategoryTheory.Quotient r)

full_name: CategoryTheory.Quotient.linear_functor
code: instance linear_functor
    (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y) (_ : r f₁ f₂), r (a • f₁) (a • f₂))
    [Preadditive (Quotient r)] [(functor r).Additive] :
    letI := linear R r hr; Functor.Linear R (functor r) 
goal: CategoryTheory.Functor.Linear R (CategoryTheory.Quotient.functor r)
File: Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean

full_name: CategoryTheory.ClosedUnderIsomorphisms
code: /-- A predicate `C → Prop` on the objects of a category is closed under isomorphisms
if whenever `P X`, then all the objects `Y` that are isomorphic to `X` also satisfy `P Y`. -/
class ClosedUnderIsomorphisms : Prop where
  of_iso {X Y : C} (_ : X ≅ Y) (_ : P X) : P Y
goal: Prop

full_name: CategoryTheory.ClosedUnderIsomorphisms.of_iso
code: /-- A predicate `C → Prop` on the objects of a category is closed under isomorphisms
if whenever `P X`, then all the objects `Y` that are isomorphic to `X` also satisfy `P Y`. -/
class ClosedUnderIsomorphisms : Prop where
  of_iso {X Y : C} (_ : X ≅ Y) (_ : P X) : P Y
goal: (X ≅ Y) → P X → P Y

full_name: CategoryTheory.mem_of_iso
code: lemma mem_of_iso [ClosedUnderIsomorphisms P] {X Y : C} (e : X ≅ Y) (hX : P X) : P Y 
goal: P Y

full_name: CategoryTheory.mem_iff_of_iso
code: lemma mem_iff_of_iso [ClosedUnderIsomorphisms P] {X Y : C} (e : X ≅ Y) : P X ↔ P Y 
goal: P X ↔ P Y

full_name: CategoryTheory.mem_of_isIso
code: lemma mem_of_isIso [ClosedUnderIsomorphisms P] {X Y : C} (f : X ⟶ Y) [IsIso f] (hX : P X) : P Y 
goal: P Y

full_name: CategoryTheory.mem_iff_of_isIso
code: lemma mem_iff_of_isIso [ClosedUnderIsomorphisms P] {X Y : C} (f : X ⟶ Y) [IsIso f] : P X ↔ P Y 
goal: P X ↔ P Y

full_name: CategoryTheory.isoClosure
code: /-- The closure by isomorphisms of a predicate on objects in a category. -/
def isoClosure : C → Prop 
goal: C → Prop

full_name: CategoryTheory.mem_isoClosure_iff
code: lemma mem_isoClosure_iff (X : C) :
    isoClosure P X ↔ ∃ (Y : C) (_ : P Y), Nonempty (X ≅ Y) 
goal: CategoryTheory.isoClosure P X ↔ ∃ Y x, Nonempty (X ≅ Y)

full_name: CategoryTheory.mem_isoClosure
code: lemma mem_isoClosure {X Y : C} (h : P X) (e : X ⟶ Y) [IsIso e] : isoClosure P Y 
goal: CategoryTheory.isoClosure P Y

full_name: CategoryTheory.le_isoClosure
code: lemma le_isoClosure : P ≤ isoClosure P 
goal: P ≤ CategoryTheory.isoClosure P

full_name: CategoryTheory.monotone_isoClosure
code: lemma monotone_isoClosure (h : P ≤ Q) : isoClosure P ≤ isoClosure Q 
goal: CategoryTheory.isoClosure P ≤ CategoryTheory.isoClosure Q

full_name: CategoryTheory.isoClosure_eq_self
code: lemma isoClosure_eq_self [ClosedUnderIsomorphisms P] : isoClosure P = P 
goal: CategoryTheory.isoClosure P = P

full_name: CategoryTheory.isoClosure_le_iff
code: lemma isoClosure_le_iff [ClosedUnderIsomorphisms Q] : isoClosure P ≤ Q ↔ P ≤ Q 
goal: CategoryTheory.isoClosure P ≤ Q ↔ P ≤ Q

full_name: CategoryTheory.instClosedUnderIsomorphismsIsoClosure
code: instance : ClosedUnderIsomorphisms (isoClosure P) 
goal: CategoryTheory.ClosedUnderIsomorphisms (CategoryTheory.isoClosure P)
File: Mathlib/CategoryTheory/Sites/Abelian.lean

full_name: CategoryTheory.sheafIsAbelian
code: instance sheafIsAbelian : Abelian (Sheaf J D) 
goal: CategoryTheory.Abelian (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.presheafToSheaf_additive
code: instance presheafToSheaf_additive : (presheafToSheaf J D).Additive 
goal: (CategoryTheory.presheafToSheaf J D).Additive
File: Mathlib/CategoryTheory/Sites/EpiMono.lean

full_name: CategoryTheory.Sheaf.locallyInjective
code: /-- The class of locally injective morphisms of sheaves, see `Sheaf.IsLocallyInjective`. -/
def locallyInjective : MorphismProperty (Sheaf J A) 
goal: CategoryTheory.MorphismProperty (CategoryTheory.Sheaf J A)

full_name: CategoryTheory.Sheaf.locallySurjective
code: /-- The class of locally surjective morphisms of sheaves, see `Sheaf.IsLocallySurjective`. -/
def locallySurjective : MorphismProperty (Sheaf J A) 
goal: CategoryTheory.MorphismProperty (CategoryTheory.Sheaf J A)

full_name: CategoryTheory.Sheaf.functorialLocallySurjectiveInjectiveFactorization
code: /-- Given a functorial surjective/injective factorizations of morphisms in a concrete
category `A`, this is the induced functorial locally surjective/locally injective
factorization of morphisms in the category `Sheaf J A`. -/
noncomputable def functorialLocallySurjectiveInjectiveFactorization :
    (locallySurjective J A).FunctorialFactorizationData (locallyInjective J A) 
goal: (CategoryTheory.Sheaf.locallySurjective J A).FunctorialFactorizationData (CategoryTheory.Sheaf.locallyInjective J A)

full_name: CategoryTheory.Sheaf.instIsLocallySurjectiveAppArrowILocallySurjectiveLocallyInjectiveFunctorialLocallySurjectiveInjectiveFactorization
code: instance : IsLocallySurjective
            ((functorialLocallySurjectiveInjectiveFactorization J data).i.app f) 
goal: CategoryTheory.Sheaf.IsLocallySurjective
  ((CategoryTheory.Sheaf.functorialLocallySurjectiveInjectiveFactorization J data).i.app f)

full_name: CategoryTheory.Sheaf.instIsLocallyInjectiveAppArrowPLocallySurjectiveLocallyInjectiveFunctorialLocallySurjectiveInjectiveFactorization
code: instance : IsLocallyInjective
            ((functorialLocallySurjectiveInjectiveFactorization J data).p.app f) 
goal: CategoryTheory.Sheaf.IsLocallyInjective
  ((CategoryTheory.Sheaf.functorialLocallySurjectiveInjectiveFactorization J data).p.app f)

full_name: CategoryTheory.Sheaf.instEpiAppArrowILocallySurjectiveLocallyInjectiveFunctorialLocallySurjectiveInjectiveFactorization
code: instance : Epi ((functorialLocallySurjectiveInjectiveFactorization J data).i.app f) 
goal: CategoryTheory.Epi ((CategoryTheory.Sheaf.functorialLocallySurjectiveInjectiveFactorization J data).i.app f)

full_name: CategoryTheory.Sheaf.instMonoAppArrowPLocallySurjectiveLocallyInjectiveFunctorialLocallySurjectiveInjectiveFactorization
code: instance : Mono ((functorialLocallySurjectiveInjectiveFactorization J data).p.app f) 
goal: CategoryTheory.Mono ((CategoryTheory.Sheaf.functorialLocallySurjectiveInjectiveFactorization J data).p.app f)

full_name: CategoryTheory.Sheaf.instHasFunctorialFactorizationLocallySurjectiveLocallyInjective
code: instance : (locallySurjective J A).HasFunctorialFactorization (locallyInjective J A) 
goal: (CategoryTheory.Sheaf.locallySurjective J A).HasFunctorialFactorization (CategoryTheory.Sheaf.locallyInjective J A)

full_name: CategoryTheory.Sheaf.isLocallySurjective_iff_epi'
code: lemma isLocallySurjective_iff_epi' :
    IsLocallySurjective φ ↔ Epi φ 
goal: CategoryTheory.Sheaf.IsLocallySurjective φ ↔ CategoryTheory.Epi φ
File: Mathlib/CategoryTheory/Sites/Coherent/CoherentSheaves.lean

full_name: CategoryTheory.isSheaf_coherent
code: lemma isSheaf_coherent (P : Cᵒᵖ ⥤ Type w) :
    Presieve.IsSheaf (coherentTopology C) P ↔
    (∀ (B : C) (α : Type) [Finite α] (X : α → C) (π : (a : α) → (X a ⟶ B)),
      EffectiveEpiFamily X π → (Presieve.ofArrows X π).IsSheafFor P) 
goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.coherentTopology C) P ↔
  ∀ (B : C) (α : Type) [inst : Finite α] (X : α → C) (π : (a : α) → X a ⟶ B),
    CategoryTheory.EffectiveEpiFamily X π → CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Presieve.ofArrows X π)

full_name: CategoryTheory.coherentTopology.isSheaf_yoneda_obj
code: /-- Every Yoneda-presheaf is a sheaf for the coherent topology. -/
theorem isSheaf_yoneda_obj (W : C) : Presieve.IsSheaf (coherentTopology C) (yoneda.obj W) 
goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.coherentTopology C) (CategoryTheory.yoneda.obj W)

full_name: CategoryTheory.coherentTopology.subcanonical
code: /-- The coherent topology on a precoherent category is subcanonical. -/
theorem subcanonical : Sheaf.Subcanonical (coherentTopology C) 
goal: CategoryTheory.Sheaf.Subcanonical (CategoryTheory.coherentTopology C)
File: Mathlib/CategoryTheory/Sites/Coherent/ReflectsPrecoherent.lean

full_name: CategoryTheory.Functor.reflects_precoherent
code: lemma Functor.reflects_precoherent : Precoherent C 
goal: CategoryTheory.Precoherent C
File: Mathlib/CategoryTheory/Sites/Coherent/CoherentTopology.lean

full_name: CategoryTheory.coherentTopology.mem_sieves_of_hasEffectiveEpiFamily
code: /--
For a precoherent category, any sieve that contains an `EffectiveEpiFamily` is a sieve of the
coherent topology.
Note: This is one direction of `mem_sieves_iff_hasEffectiveEpiFamily`, but is needed for the proof.
-/
theorem coherentTopology.mem_sieves_of_hasEffectiveEpiFamily (S : Sieve X) :
    (∃ (α : Type) (_ : Finite α) (Y : α → C) (π : (a : α) → (Y a ⟶ X)),
      EffectiveEpiFamily Y π ∧ (∀ a : α, (S.arrows) (π a)) ) →
        (S ∈ GrothendieckTopology.sieves (coherentTopology C) X) 
goal: (∃ α, ∃ (_ : Finite α), ∃ Y π, CategoryTheory.EffectiveEpiFamily Y π ∧ ∀ (a : α), S.arrows (π a)) →
  S ∈ (CategoryTheory.coherentTopology C).sieves X

full_name: CategoryTheory.EffectiveEpiFamily.transitive_of_finite
code: /--
Effective epi families in a precoherent category are transitive, in the sense that an
`EffectiveEpiFamily` and an `EffectiveEpiFamily` over each member, the composition is an
`EffectiveEpiFamily`.
Note: The finiteness condition is an artifact of the proof and is probably unnecessary.
-/
theorem EffectiveEpiFamily.transitive_of_finite {α : Type} [Finite α] {Y : α → C}
    (π : (a : α) → (Y a ⟶ X)) (h : EffectiveEpiFamily Y π) {β : α → Type} [∀ (a : α), Finite (β a)]
    {Y_n : (a : α) → β a → C} (π_n : (a : α) → (b : β a) → (Y_n a b ⟶ Y a))
    (H : ∀ a, EffectiveEpiFamily (Y_n a) (π_n a)) :
    EffectiveEpiFamily
      (fun (c : Σ a, β a) => Y_n c.fst c.snd) (fun c => π_n c.fst c.snd ≫ π c.fst) 
goal: CategoryTheory.EffectiveEpiFamily (fun c => Y_n c.fst c.snd) fun c =>
  CategoryTheory.CategoryStruct.comp (π_n c.fst c.snd) (π c.fst)

full_name: CategoryTheory.precoherentEffectiveEpiFamilyCompEffectiveEpis
code: instance precoherentEffectiveEpiFamilyCompEffectiveEpis
    {α : Type} [Finite α] {Y Z : α → C} (π : (a : α) → (Y a ⟶ X)) [EffectiveEpiFamily Y π]
    (f : (a : α) → Z a ⟶ Y a) [h : ∀ a, EffectiveEpi (f a)] :
    EffectiveEpiFamily _ fun a ↦ f a ≫ π a 
goal: CategoryTheory.EffectiveEpiFamily Z fun a => CategoryTheory.CategoryStruct.comp (f a) (π a)

full_name: CategoryTheory.coherentTopology.mem_sieves_iff_hasEffectiveEpiFamily
code: /--
A sieve belongs to the coherent topology if and only if it contains a finite
`EffectiveEpiFamily`.
-/
theorem coherentTopology.mem_sieves_iff_hasEffectiveEpiFamily (S : Sieve X) :
    (S ∈ GrothendieckTopology.sieves (coherentTopology C) X) ↔
    (∃ (α : Type) (_ : Finite α) (Y : α → C) (π : (a : α) → (Y a ⟶ X)),
        EffectiveEpiFamily Y π ∧ (∀ a : α, (S.arrows) (π a)) )  
goal: S ∈ (CategoryTheory.coherentTopology C).sieves X ↔
  ∃ α, ∃ (_ : Finite α), ∃ Y π, CategoryTheory.EffectiveEpiFamily Y π ∧ ∀ (a : α), S.arrows (π a)
File: Mathlib/CategoryTheory/Sites/Coherent/ReflectsPreregular.lean

full_name: CategoryTheory.Functor.reflects_preregular
code: lemma Functor.reflects_preregular : Preregular C 
goal: CategoryTheory.Preregular C
File: Mathlib/CategoryTheory/Sites/Coherent/ExtensiveTopology.lean

full_name: CategoryTheory.extensiveTopology.mem_sieves_iff_contains_colimit_cofan
code: lemma extensiveTopology.mem_sieves_iff_contains_colimit_cofan {X : C} (S : Sieve X) :
    S ∈ (extensiveTopology C).sieves X ↔
      (∃ (α : Type) (_ : Finite α) (Y : α → C) (π : (a : α) → (Y a ⟶ X)),
        Nonempty (IsColimit (Cofan.mk X π)) ∧ (∀ a : α, (S.arrows) (π a))) 
goal: S ∈ (CategoryTheory.extensiveTopology C).sieves X ↔
  ∃ α,
    ∃ (_ : Finite α),
      ∃ Y π, Nonempty (CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofan.mk X π)) ∧ ∀ (a : α), S.arrows (π a)
File: Mathlib/CategoryTheory/Sites/Coherent/Comparison.lean

full_name: CategoryTheory.instPreregularOfPrecoherentOfHasFiniteCoproducts
code: instance [Precoherent C] [HasFiniteCoproducts C] : Preregular C 
goal: CategoryTheory.Preregular C

full_name: CategoryTheory.instPrecoherentOfFinitaryPreExtensiveOfPreregular
code: instance [FinitaryPreExtensive C] [Preregular C] : Precoherent C 
goal: CategoryTheory.Precoherent C

full_name: CategoryTheory.extensive_regular_generate_coherent
code: /-- The union of the extensive and regular coverages generates the coherent topology on `C`. -/
theorem extensive_regular_generate_coherent [Preregular C] [FinitaryPreExtensive C] :
    ((extensiveCoverage C) ⊔ (regularCoverage C)).toGrothendieck =
    (coherentTopology C) 
goal: CategoryTheory.Coverage.toGrothendieck C (CategoryTheory.extensiveCoverage C ⊔ CategoryTheory.regularCoverage C) =
  CategoryTheory.coherentTopology C
File: Mathlib/CategoryTheory/Sites/Coherent/RegularTopology.lean

full_name: CategoryTheory.regularTopology.mem_sieves_of_hasEffectiveEpi
code: /--
For a preregular category, any sieve that contains an `EffectiveEpi` is a covering sieve of the
regular topology.
Note: This is one direction of `mem_sieves_iff_hasEffectiveEpi`, but is needed for the proof.
-/
theorem mem_sieves_of_hasEffectiveEpi (S : Sieve X) :
    (∃ (Y : C) (π : Y ⟶ X), EffectiveEpi π ∧ S.arrows π) → (S ∈ (regularTopology C).sieves X) 
goal: (∃ Y π, CategoryTheory.EffectiveEpi π ∧ S.arrows π) → S ∈ (CategoryTheory.regularTopology C).sieves X

full_name: CategoryTheory.regularTopology.instEffectiveEpiComp
code: /-- Effective epis in a preregular category are stable under composition. -/
instance {Y Y' : C} (π : Y ⟶ X) [EffectiveEpi π]
    (π' : Y' ⟶ Y) [EffectiveEpi π'] : EffectiveEpi (π' ≫ π) 
goal: CategoryTheory.EffectiveEpi (CategoryTheory.CategoryStruct.comp π' π)

full_name: CategoryTheory.regularTopology.mem_sieves_iff_hasEffectiveEpi
code: /-- A sieve is a cover for the regular topology if and only if it contains an `EffectiveEpi`. -/
theorem mem_sieves_iff_hasEffectiveEpi (S : Sieve X) :
    (S ∈ (regularTopology C).sieves  X) ↔
    ∃ (Y : C) (π : Y ⟶ X), EffectiveEpi π ∧ (S.arrows π) 
goal: S ∈ (CategoryTheory.regularTopology C).sieves X ↔ ∃ Y π, CategoryTheory.EffectiveEpi π ∧ S.arrows π