ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Presheaf.isLocallyInjective_of_isLocallyInjective_of_isLocallySurjective
lemma isLocallyInjective_of_isLocallyInjective_of_isLocallySurjective
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃)
    [IsLocallyInjective J (f₁ ≫ f₂)] [IsLocallySurjective J f₁] :
    IsLocallyInjective J f₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u'} [CategoryTheory.Category.{v', u'} A] [CategoryTheory.ConcreteCategory A] {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃) [CategoryTheory.Presheaf.IsLocallyInjective J (f₁ ≫ f₂)] [CategoryTheory.Presheaf.IsLocallySurjective J f₁]
Goal: CategoryTheory.Presheaf.IsLocallyInjective J f₂
-- CategoryTheory.Presheaf.isLocallyInjective_of_isLocallyInjective_of_isLocallySurjective_fac
lemma isLocallyInjective_of_isLocallyInjective_of_isLocallySurjective_fac
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} {f₁ : F₁ ⟶ F₂} {f₂ : F₂ ⟶ F₃} (f₃ : F₁ ⟶ F₃) (fac : f₁ ≫ f₂ = f₃)
    [IsLocallyInjective J f₃] [IsLocallySurjective J f₁] :
    IsLocallyInjective J f₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u'} [CategoryTheory.Category.{v', u'} A] [CategoryTheory.ConcreteCategory A] {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} {f₁ : F₁ ⟶ F₂} {f₂ : F₂ ⟶ F₃} (f₃ : F₁ ⟶ F₃) (fac : f₁ ≫ f₂ = f₃) [CategoryTheory.Presheaf.IsLocallyInjective J f₃] [CategoryTheory.Presheaf.IsLocallySurjective J f₁]
Goal: CategoryTheory.Presheaf.IsLocallyInjective J f₂
-- CategoryTheory.Presheaf.isLocallySurjective_of_isLocallySurjective_of_isLocallyInjective
lemma isLocallySurjective_of_isLocallySurjective_of_isLocallyInjective
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃)
    [IsLocallySurjective J (f₁ ≫ f₂)] [IsLocallyInjective J f₂] :
    IsLocallySurjective J f₁ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u'} [CategoryTheory.Category.{v', u'} A] [CategoryTheory.ConcreteCategory A] {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃) [CategoryTheory.Presheaf.IsLocallySurjective J (f₁ ≫ f₂)] [CategoryTheory.Presheaf.IsLocallyInjective J f₂]
Goal: CategoryTheory.Presheaf.IsLocallySurjective J f₁
-- CategoryTheory.Presheaf.isLocallySurjective_of_isLocallySurjective_of_isLocallyInjective_fac
lemma isLocallySurjective_of_isLocallySurjective_of_isLocallyInjective_fac
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} {f₁ : F₁ ⟶ F₂} {f₂ : F₂ ⟶ F₃} (f₃ : F₁ ⟶ F₃) (fac : f₁ ≫ f₂ = f₃)
    [IsLocallySurjective J f₃] [IsLocallyInjective J f₂] :
    IsLocallySurjective J f₁ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u'} [CategoryTheory.Category.{v', u'} A] [CategoryTheory.ConcreteCategory A] {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} {f₁ : F₁ ⟶ F₂} {f₂ : F₂ ⟶ F₃} (f₃ : F₁ ⟶ F₃) (fac : f₁ ≫ f₂ = f₃) [CategoryTheory.Presheaf.IsLocallySurjective J f₃] [CategoryTheory.Presheaf.IsLocallyInjective J f₂]
Goal: CategoryTheory.Presheaf.IsLocallySurjective J f₁
-- CategoryTheory.Presheaf.comp_isLocallyInjective_iff
lemma comp_isLocallyInjective_iff
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃)
    [IsLocallyInjective J f₁] [IsLocallySurjective J f₁] :
    IsLocallyInjective J (f₁ ≫ f₂) ↔ IsLocallyInjective J f₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u'} [CategoryTheory.Category.{v', u'} A] [CategoryTheory.ConcreteCategory A] {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃) [CategoryTheory.Presheaf.IsLocallyInjective J f₁] [CategoryTheory.Presheaf.IsLocallySurjective J f₁]
Goal: CategoryTheory.Presheaf.IsLocallyInjective J (f₁ ≫ f₂) ↔ CategoryTheory.Presheaf.IsLocallyInjective J f₂
-- CategoryTheory.Presheaf.isLocallySurjective_comp_iff
lemma isLocallySurjective_comp_iff
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃)
    [IsLocallyInjective J f₂] [IsLocallySurjective J f₂] :
    IsLocallySurjective J (f₁ ≫ f₂) ↔ IsLocallySurjective J f₁ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u'} [CategoryTheory.Category.{v', u'} A] [CategoryTheory.ConcreteCategory A] {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃) [CategoryTheory.Presheaf.IsLocallyInjective J f₂] [CategoryTheory.Presheaf.IsLocallySurjective J f₂]
Goal: CategoryTheory.Presheaf.IsLocallySurjective J (f₁ ≫ f₂) ↔ CategoryTheory.Presheaf.IsLocallySurjective J f₁
-- CategoryTheory.Sheaf.isLocallySurjective_sheafToPresheaf_map_iff
lemma isLocallySurjective_sheafToPresheaf_map_iff :
    Presheaf.IsLocallySurjective J ((sheafToPresheaf J A).map φ) ↔ IsLocallySurjective φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] [CategoryTheory.ConcreteCategory A] {F₁ F₂ : CategoryTheory.Sheaf J A} (φ : F₁ ⟶ F₂)
Goal: CategoryTheory.Presheaf.IsLocallySurjective J ((CategoryTheory.sheafToPresheaf J A).map φ) ↔
  CategoryTheory.Sheaf.IsLocallySurjective φ
-- CategoryTheory.Sheaf.isLocallySurjective_iff_isIso
theorem isLocallySurjective_iff_isIso {F G : Sheaf J (Type w)} (f : F ⟶ G) :
    IsLocallySurjective f ↔ IsIso (imageSheafι f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {F G : CategoryTheory.Sheaf J (Type w)} (f : F ⟶ G)
Goal: CategoryTheory.Sheaf.IsLocallySurjective f ↔ CategoryTheory.IsIso (CategoryTheory.GrothendieckTopology.imageSheafι f)
-- CategoryTheory.Sheaf.isLocallySurjective_iff_epi
lemma isLocallySurjective_iff_epi {F G : Sheaf J (Type w)} (φ : F ⟶ G)
    [HasSheafify J (Type w)] :
    IsLocallySurjective φ ↔ Epi φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {F G : CategoryTheory.Sheaf J (Type w)} (φ : F ⟶ G) [CategoryTheory.HasSheafify J (Type w)]
Goal: CategoryTheory.Sheaf.IsLocallySurjective φ ↔ CategoryTheory.Epi φ
-- CategoryTheory.Presieve.FamilyOfElements.isAmalgamation_map_localPreimage
lemma isAmalgamation_map_localPreimage :
    ((localPreimage φ r').map φ).IsAmalgamation r' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {R R' : Cᵒᵖ ⥤ Type w} (φ : R ⟶ R') {X : Cᵒᵖ} (r' : R'.obj X)
Goal: ((CategoryTheory.Presieve.FamilyOfElements.localPreimage φ r').map φ).IsAmalgamation r'
-- CategoryTheory.Presieve.regular.single_epi
class Presieve.regular {X : C} (R : Presieve X) : Prop where
    single_epi : ∃ (Y : C) (f : Y ⟶ X), R = Presieve.ofArrows (fun (_ : Unit) ↦ Y)
    (fun (_ : Unit) ↦ f) ∧ EffectiveEpi f
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {X : C} {R : CategoryTheory.Presieve X} [self : R.regular]
Goal: ∃ Y f, (R = CategoryTheory.Presieve.ofArrows (fun x => Y) fun x => f) ∧ CategoryTheory.EffectiveEpi f
-- CategoryTheory.regularTopology.equalizerCondition_w
lemma equalizerCondition_w (P : Cᵒᵖ ⥤ D) {X B : C} {π : X ⟶ B} (c : PullbackCone π π) :
    P.map π.op ≫ P.map c.fst.op = P.map π.op ≫ P.map c.snd.op 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (P : CategoryTheory.Functor Cᵒᵖ D) {X B : C} {π : X ⟶ B} (c : CategoryTheory.Limits.PullbackCone π π)
Goal: CategoryTheory.CategoryStruct.comp (P.map π.op) (P.map c.fst.op) =
  CategoryTheory.CategoryStruct.comp (P.map π.op) (P.map c.snd.op)
-- CategoryTheory.regularTopology.equalizerCondition_of_natIso
theorem equalizerCondition_of_natIso {P P' : Cᵒᵖ ⥤ D} (i : P ≅ P')
    (hP : EqualizerCondition P) : EqualizerCondition P' 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] {P P' : CategoryTheory.Functor Cᵒᵖ D} (i : P ≅ P') (hP : CategoryTheory.regularTopology.EqualizerCondition P)
Goal: CategoryTheory.regularTopology.EqualizerCondition P'
-- CategoryTheory.regularTopology.equalizerCondition_precomp_of_preservesPullback
theorem equalizerCondition_precomp_of_preservesPullback (P : Cᵒᵖ ⥤ D) (F : E ⥤ C)
    [∀ {X B} (π : X ⟶ B) [EffectiveEpi π], PreservesLimit (cospan π π) F]
    [F.PreservesEffectiveEpis] (hP : EqualizerCondition P) : EqualizerCondition (F.op ⋙ P) 
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] (P : CategoryTheory.Functor Cᵒᵖ D) (F : CategoryTheory.Functor E C) [{X B : E} →
    (π : X ⟶ B) →
      [inst : CategoryTheory.EffectiveEpi π] →
        CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan π π) F] [F.PreservesEffectiveEpis] (hP : CategoryTheory.regularTopology.EqualizerCondition P)
Goal: CategoryTheory.regularTopology.EqualizerCondition (F.op.comp P)
-- CategoryTheory.regularTopology.EqualizerCondition.bijective_mapToEqualizer_pullback
theorem EqualizerCondition.bijective_mapToEqualizer_pullback (P : Cᵒᵖ ⥤ Type*)
    (hP : EqualizerCondition P) : ∀ (X B : C) (π : X ⟶ B) [EffectiveEpi π] [HasPullback π π],
    Function.Bijective
      (MapToEqualizer P π (pullback.fst π π) (pullback.snd π π) pullback.condition) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] (P : CategoryTheory.Functor Cᵒᵖ (Type u_4)) (hP : CategoryTheory.regularTopology.EqualizerCondition P) (X B : C) (π : X ⟶ B) [CategoryTheory.EffectiveEpi π] [CategoryTheory.Limits.HasPullback π π]
Goal: Function.Bijective
  (CategoryTheory.regularTopology.MapToEqualizer P π (CategoryTheory.Limits.pullback.fst π π)
    (CategoryTheory.Limits.pullback.snd π π) ⋯)
-- CategoryTheory.regularTopology.EqualizerCondition.mk
theorem EqualizerCondition.mk (P : Cᵒᵖ ⥤ Type*)
    (hP : ∀ (X B : C) (π : X ⟶ B) [EffectiveEpi π] [HasPullback π π], Function.Bijective
    (MapToEqualizer P π (pullback.fst π π) (pullback.snd π π)
    pullback.condition)) : EqualizerCondition P 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] (P : CategoryTheory.Functor Cᵒᵖ (Type u_4)) (hP :
  ∀ (X B : C) (π : X ⟶ B) [inst : CategoryTheory.EffectiveEpi π] [inst : CategoryTheory.Limits.HasPullback π π],
    Function.Bijective
      (CategoryTheory.regularTopology.MapToEqualizer P π (CategoryTheory.Limits.pullback.fst π π)
        (CategoryTheory.Limits.pullback.snd π π) ⋯))
Goal: CategoryTheory.regularTopology.EqualizerCondition P
-- CategoryTheory.regularTopology.equalizerCondition_w'
lemma equalizerCondition_w' (P : Cᵒᵖ ⥤ Type*) {X B : C} (π : X ⟶ B)
    [HasPullback π π] : P.map π.op ≫ P.map (pullback.fst π π).op =
    P.map π.op ≫ P.map (pullback.snd π π).op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] (P : CategoryTheory.Functor Cᵒᵖ (Type u_4)) {X B : C} (π : X ⟶ B) [CategoryTheory.Limits.HasPullback π π]
Goal: CategoryTheory.CategoryStruct.comp (P.map π.op) (P.map (CategoryTheory.Limits.pullback.fst π π).op) =
  CategoryTheory.CategoryStruct.comp (P.map π.op) (P.map (CategoryTheory.Limits.pullback.snd π π).op)
-- CategoryTheory.regularTopology.mapToEqualizer_eq_comp
lemma mapToEqualizer_eq_comp (P : Cᵒᵖ ⥤ Type*) {X B : C} (π : X ⟶ B) [HasPullback π π] :
    MapToEqualizer P π (pullback.fst π π) (pullback.snd π π) pullback.condition =
    equalizer.lift (P.map π.op) (equalizerCondition_w' P π) ≫
    (Types.equalizerIso _ _).hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] (P : CategoryTheory.Functor Cᵒᵖ (Type u_4)) {X B : C} (π : X ⟶ B) [CategoryTheory.Limits.HasPullback π π]
Goal: CategoryTheory.regularTopology.MapToEqualizer P π (CategoryTheory.Limits.pullback.fst π π)
    (CategoryTheory.Limits.pullback.snd π π) ⋯ =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizer.lift (P.map π.op) ⋯)
    (CategoryTheory.Limits.Types.equalizerIso (P.map (CategoryTheory.Limits.pullback.fst π π).op)
        (P.map (CategoryTheory.Limits.pullback.snd π π).op)).hom
-- CategoryTheory.regularTopology.equalizerCondition_iff_isIso_lift
theorem equalizerCondition_iff_isIso_lift (P : Cᵒᵖ ⥤ Type*) : EqualizerCondition P ↔
    ∀ (X B : C) (π : X ⟶ B) [EffectiveEpi π] [HasPullback π π],
      IsIso (equalizer.lift (P.map π.op) (equalizerCondition_w' P π)) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] (P : CategoryTheory.Functor Cᵒᵖ (Type u_4))
Goal: CategoryTheory.regularTopology.EqualizerCondition P ↔
  ∀ (X B : C) (π : X ⟶ B) [inst : CategoryTheory.EffectiveEpi π] [inst : CategoryTheory.Limits.HasPullback π π],
    CategoryTheory.IsIso (CategoryTheory.Limits.equalizer.lift (P.map π.op) ⋯)
-- CategoryTheory.regularTopology.equalizerCondition_iff_of_equivalence
theorem equalizerCondition_iff_of_equivalence (P : Cᵒᵖ ⥤ D)
    (e : C ≌ E) : EqualizerCondition P ↔ EqualizerCondition (e.op.inverse ⋙ P) 
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] (P : CategoryTheory.Functor Cᵒᵖ D) (e : C ≌ E)
Goal: CategoryTheory.regularTopology.EqualizerCondition P ↔
  CategoryTheory.regularTopology.EqualizerCondition (e.op.inverse.comp P)
-- CategoryTheory.regularTopology.parallelPair_pullback_initial
theorem parallelPair_pullback_initial {X B : C} (π : X ⟶ B)
    (c : PullbackCone π π) (hc : IsLimit c) :
    (parallelPair (C := (Sieve.ofArrows (fun (_ : Unit) => X) (fun _ => π)).arrows.categoryᵒᵖ)
    (Y := op ((Presieve.categoryMk _ (c.fst ≫ π) ⟨_, c.fst, π, ofArrows.mk (), rfl⟩)))
    (X := op ((Presieve.categoryMk _ π (Sieve.ofArrows_mk _ _ Unit.unit))))
    (Quiver.Hom.op (Over.homMk c.fst))
    (Quiver.Hom.op (Over.homMk c.snd c.condition.symm))).Initial 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {X B : C} (π : X ⟶ B) (c : CategoryTheory.Limits.PullbackCone π π) (hc : CategoryTheory.Limits.IsLimit c)
Goal: (CategoryTheory.Limits.parallelPair (CategoryTheory.Over.homMk c.fst ⋯).op
    (CategoryTheory.Over.homMk c.snd ⋯).op).Initial
-- CategoryTheory.regularTopology.equalizerConditionMap_iff_nonempty_isLimit
lemma equalizerConditionMap_iff_nonempty_isLimit (P : Cᵒᵖ ⥤ D) ⦃X B : C⦄ (π : X ⟶ B)
    [HasPullback π π] : SingleEqualizerCondition P π ↔
      Nonempty (IsLimit (P.mapCone
        (Sieve.ofArrows (fun (_ : Unit) => X) (fun _ => π)).arrows.cocone.op)) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (P : CategoryTheory.Functor Cᵒᵖ D) ⦃X B : C⦄ (π : X ⟶ B) [CategoryTheory.Limits.HasPullback π π]
Goal: CategoryTheory.regularTopology.SingleEqualizerCondition P π ↔
  Nonempty
    (CategoryTheory.Limits.IsLimit (P.mapCone (CategoryTheory.Sieve.ofArrows (fun x => X) fun x => π).arrows.cocone.op))
-- CategoryTheory.regularTopology.equalizerCondition_iff_isSheaf
lemma equalizerCondition_iff_isSheaf (F : Cᵒᵖ ⥤ D) [Preregular C]
    [∀ {Y X : C} (f : Y ⟶ X) [EffectiveEpi f], HasPullback f f] :
    EqualizerCondition F ↔ Presheaf.IsSheaf (regularTopology C) F 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (F : CategoryTheory.Functor Cᵒᵖ D) [CategoryTheory.Preregular C] [∀ {Y X : C} (f : Y ⟶ X) [inst : CategoryTheory.EffectiveEpi f], CategoryTheory.Limits.HasPullback f f]
Goal: CategoryTheory.regularTopology.EqualizerCondition F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology C) F
-- CategoryTheory.regularTopology.isSheafFor_regular_of_projective
lemma isSheafFor_regular_of_projective {X : C} (S : Presieve X) [S.regular] [Projective X]
    (F : Cᵒᵖ ⥤ Type*) : S.IsSheafFor F 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {X : C} (S : CategoryTheory.Presieve X) [S.regular] [CategoryTheory.Projective X] (F : CategoryTheory.Functor Cᵒᵖ (Type u_4))
Goal: CategoryTheory.Presieve.IsSheafFor F S
-- CategoryTheory.regularTopology.isSheaf_of_projective
theorem isSheaf_of_projective (F : Cᵒᵖ ⥤ D) [Preregular C] [∀ (X : C), Projective X] :
    Presheaf.IsSheaf (regularTopology C) F 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (F : CategoryTheory.Functor Cᵒᵖ D) [CategoryTheory.Preregular C] [∀ (X : C), CategoryTheory.Projective X]
Goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology C) F
-- CategoryTheory.regularTopology.isSheaf_yoneda_obj
lemma isSheaf_yoneda_obj [Preregular C] (W : C)  :
    Presieve.IsSheaf (regularTopology C) (yoneda.obj W) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preregular C] (W : C)
Goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.regularTopology C) (CategoryTheory.yoneda.obj W)
-- CategoryTheory.regularTopology.subcanonical
theorem subcanonical [Preregular C] : Sheaf.Subcanonical (regularTopology C) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preregular C]
Goal: CategoryTheory.Sheaf.Subcanonical (CategoryTheory.regularTopology C)
-- CategoryTheory.Presieve.IsSheaf.isSheafFor
theorem IsSheaf.isSheafFor {P : Cᵒᵖ ⥤ Type w} (hp : IsSheaf J P) (R : Presieve X)
    (hr : generate R ∈ J X) : IsSheafFor P R 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (J : CategoryTheory.GrothendieckTopology C) {P : CategoryTheory.Functor Cᵒᵖ (Type w)} (hp : CategoryTheory.Presieve.IsSheaf J P) (R : CategoryTheory.Presieve X) (hr : CategoryTheory.Sieve.generate R ∈ J.sieves X)
Goal: CategoryTheory.Presieve.IsSheafFor P R
-- CategoryTheory.Presieve.isSheaf_of_le
theorem isSheaf_of_le (P : Cᵒᵖ ⥤ Type w) {J₁ J₂ : GrothendieckTopology C} :
    J₁ ≤ J₂ → IsSheaf J₂ P → IsSheaf J₁ P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {J₁ J₂ : CategoryTheory.GrothendieckTopology C}
Goal: J₁ ≤ J₂ → CategoryTheory.Presieve.IsSheaf J₂ P → CategoryTheory.Presieve.IsSheaf J₁ P
-- CategoryTheory.Presieve.isSeparated_of_isSheaf
theorem isSeparated_of_isSheaf (P : Cᵒᵖ ⥤ Type w) (h : IsSheaf J P) : IsSeparated J P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ (Type w)) (h : CategoryTheory.Presieve.IsSheaf J P)
Goal: CategoryTheory.Presieve.IsSeparated J P
-- CategoryTheory.Presieve.isSheaf_iso
theorem isSheaf_iso {P' : Cᵒᵖ ⥤ Type w} (i : P ≅ P') (h : IsSheaf J P) : IsSheaf J P' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} (J : CategoryTheory.GrothendieckTopology C) {P' : CategoryTheory.Functor Cᵒᵖ (Type w)} (i : P ≅ P') (h : CategoryTheory.Presieve.IsSheaf J P)
Goal: CategoryTheory.Presieve.IsSheaf J P'
-- CategoryTheory.Presieve.isSheaf_of_yoneda
theorem isSheaf_of_yoneda {P : Cᵒᵖ ⥤ Type v}
    (h : ∀ {X} (S : Sieve X), S ∈ J X → YonedaSheafCondition P S) : IsSheaf J P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {P : CategoryTheory.Functor Cᵒᵖ (Type v)} (h : ∀ {X : C}, ∀ S ∈ J.sieves X, CategoryTheory.Presieve.YonedaSheafCondition P S)
Goal: CategoryTheory.Presieve.IsSheaf J P
-- CategoryTheory.Presieve.isSheaf_pretopology
theorem isSheaf_pretopology [HasPullbacks C] (K : Pretopology C) :
    IsSheaf (K.toGrothendieck C) P ↔ ∀ {X : C} (R : Presieve X), R ∈ K X → IsSheafFor P R 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} [CategoryTheory.Limits.HasPullbacks C] (K : CategoryTheory.Pretopology C)
Goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.Pretopology.toGrothendieck C K) P ↔
  ∀ {X : C}, ∀ R ∈ K.coverings X, CategoryTheory.Presieve.IsSheafFor P R
-- CategoryTheory.Presieve.isSheaf_bot
theorem isSheaf_bot : IsSheaf (⊥ : GrothendieckTopology C) P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)}
Goal: CategoryTheory.Presieve.IsSheaf ⊥ P
-- CategoryTheory.Sieve.yonedaFamily_fromCocone_compatible
theorem yonedaFamily_fromCocone_compatible (S : Sieve X) (s : Cocone (diagram S.arrows)) :
    FamilyOfElements.Compatible <| yonedaFamilyOfElements_fromCocone S.arrows s 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (S : CategoryTheory.Sieve X) (s : CategoryTheory.Limits.Cocone S.arrows.diagram)
Goal: (S.arrows.yonedaFamilyOfElements_fromCocone s).Compatible
-- CategoryTheory.Sieve.forallYonedaIsSheaf_iff_colimit
theorem forallYonedaIsSheaf_iff_colimit (S : Sieve X) :
    (∀ W : C, Presieve.IsSheafFor (yoneda.obj W) (S : Presieve X)) ↔
      Nonempty (IsColimit S.arrows.cocone) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (S : CategoryTheory.Sieve X)
Goal: (∀ (W : C), CategoryTheory.Presieve.IsSheafFor (CategoryTheory.yoneda.obj W) S.arrows) ↔
  Nonempty (CategoryTheory.Limits.IsColimit S.arrows.cocone)
-- CategoryTheory.SheafOfTypes.cond
structure SheafOfTypes (J : GrothendieckTopology C) : Type max u v (w + 1) where
    val : Cᵒᵖ ⥤ Type w
    cond : Presieve.IsSheaf J val
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (self : CategoryTheory.SheafOfTypes J)
Goal: CategoryTheory.Presieve.IsSheaf J self.val
-- CategoryTheory.SheafOfTypes.instCategory_comp_val
@[simps]
instance : Category (SheafOfTypes J) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
Goal: ∀ {X Y Z : CategoryTheory.SheafOfTypes J} (f : X ⟶ Y) (g : Y ⟶ Z),
  (CategoryTheory.CategoryStruct.comp f g).val = CategoryTheory.CategoryStruct.comp f.val g.val
-- CategoryTheory.SheafOfTypes.instCategory_id_val
@[simps]
instance : Category (SheafOfTypes J) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
Goal: ∀ (x : CategoryTheory.SheafOfTypes J), (CategoryTheory.CategoryStruct.id x).val = CategoryTheory.CategoryStruct.id x.val
-- CategoryTheory.SheafOfTypes.Hom.ext'
@[ext]
theorem Hom.ext' {X Y : SheafOfTypes J} (f g : X ⟶ Y) (w : f.val = g.val) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X Y : CategoryTheory.SheafOfTypes J} (f g : X ⟶ Y) (w : f.val = g.val)
Goal: f = g
-- CategoryTheory.sheafOfTypesToPresheaf_obj
@[simps]
def sheafOfTypesToPresheaf : SheafOfTypes J ⥤ Cᵒᵖ ⥤ Type w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (self : CategoryTheory.SheafOfTypes J)
Goal: (CategoryTheory.sheafOfTypesToPresheaf J).obj self = self.val
-- CategoryTheory.sheafOfTypesToPresheaf_map
@[simps]
def sheafOfTypesToPresheaf : SheafOfTypes J ⥤ Cᵒᵖ ⥤ Type w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
Goal: ∀ {X Y : CategoryTheory.SheafOfTypes J} (f : X ⟶ Y), (CategoryTheory.sheafOfTypesToPresheaf J).map f = f.val
-- CategoryTheory.sheafOfTypesBotEquiv_functor
@[simps]
def sheafOfTypesBotEquiv : SheafOfTypes (⊥ : GrothendieckTopology C) ≌ Cᵒᵖ ⥤ Type w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.sheafOfTypesBotEquiv.functor = CategoryTheory.sheafOfTypesToPresheaf ⊥
-- CategoryTheory.sheafOfTypesBotEquiv_inverse_map_val
@[simps]
def sheafOfTypesBotEquiv : SheafOfTypes (⊥ : GrothendieckTopology C) ≌ Cᵒᵖ ⥤ Type w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Functor Cᵒᵖ (Type w)} (f : X ⟶ Y), (CategoryTheory.sheafOfTypesBotEquiv.inverse.map f).val = f
-- CategoryTheory.sheafOfTypesBotEquiv_unitIso
@[simps]
def sheafOfTypesBotEquiv : SheafOfTypes (⊥ : GrothendieckTopology C) ≌ Cᵒᵖ ⥤ Type w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.sheafOfTypesBotEquiv.unitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.SheafOfTypes ⊥))
-- CategoryTheory.sheafOfTypesBotEquiv_counitIso
@[simps]
def sheafOfTypesBotEquiv : SheafOfTypes (⊥ : GrothendieckTopology C) ≌ Cᵒᵖ ⥤ Type w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.sheafOfTypesBotEquiv.counitIso =
  CategoryTheory.Iso.refl
    ({ obj := fun P => { val := P, cond := ⋯ }, map := fun {X Y} f => { val := f }, map_id := ⋯, map_comp := ⋯ }.comp
      (CategoryTheory.sheafOfTypesToPresheaf ⊥))
-- CategoryTheory.sheafOfTypesBotEquiv_inverse_obj_val
@[simps]
def sheafOfTypesBotEquiv : SheafOfTypes (⊥ : GrothendieckTopology C) ≌ Cᵒᵖ ⥤ Type w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w))
Goal: (CategoryTheory.sheafOfTypesBotEquiv.inverse.obj P).val = P