ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Presieve.is_compatible_of_exists_amalgamation
theorem is_compatible_of_exists_amalgamation (x : FamilyOfElements P R)
    (h : ∃ t, x.IsAmalgamation t) : x.Compatible 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X} (x : CategoryTheory.Presieve.FamilyOfElements P R) (h : ∃ t, x.IsAmalgamation t)
Goal: x.Compatible
-- CategoryTheory.Presieve.isAmalgamation_restrict
theorem isAmalgamation_restrict {R₁ R₂ : Presieve X} (h : R₁ ≤ R₂) (x : FamilyOfElements P R₂)
    (t : P.obj (op X)) (ht : x.IsAmalgamation t) : (x.restrict h).IsAmalgamation t 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R₁ R₂ : CategoryTheory.Presieve X} (h : R₁ ≤ R₂) (x : CategoryTheory.Presieve.FamilyOfElements P R₂) (t : P.obj (Opposite.op X)) (ht : x.IsAmalgamation t)
Goal: (CategoryTheory.Presieve.FamilyOfElements.restrict h x).IsAmalgamation t
-- CategoryTheory.Presieve.isAmalgamation_sieveExtend
theorem isAmalgamation_sieveExtend {R : Presieve X} (x : FamilyOfElements P R) (t : P.obj (op X))
    (ht : x.IsAmalgamation t) : x.sieveExtend.IsAmalgamation t 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X} (x : CategoryTheory.Presieve.FamilyOfElements P R) (t : P.obj (Opposite.op X)) (ht : x.IsAmalgamation t)
Goal: x.sieveExtend.IsAmalgamation t
-- CategoryTheory.Presieve.IsSeparatedFor.ext
theorem IsSeparatedFor.ext {R : Presieve X} (hR : IsSeparatedFor P R) {t₁ t₂ : P.obj (op X)}
    (h : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄ (_ : R f), P.map f.op t₁ = P.map f.op t₂) : t₁ = t₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X} (hR : CategoryTheory.Presieve.IsSeparatedFor P R) {t₁ t₂ : P.obj (Opposite.op X)} (h : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, R f → P.map f.op t₁ = P.map f.op t₂)
Goal: t₁ = t₂
-- CategoryTheory.Presieve.isSeparatedFor_iff_generate
theorem isSeparatedFor_iff_generate :
    IsSeparatedFor P R ↔ IsSeparatedFor P (generate R : Presieve X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X}
Goal: CategoryTheory.Presieve.IsSeparatedFor P R ↔
  CategoryTheory.Presieve.IsSeparatedFor P (CategoryTheory.Sieve.generate R).arrows
-- CategoryTheory.Presieve.isSeparatedFor_top
theorem isSeparatedFor_top (P : Cᵒᵖ ⥤ Type w) : IsSeparatedFor P (⊤ : Presieve X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (P : CategoryTheory.Functor Cᵒᵖ (Type w))
Goal: CategoryTheory.Presieve.IsSeparatedFor P ⊤
-- CategoryTheory.Presieve.extension_iff_amalgamation
theorem extension_iff_amalgamation {P : Cᵒᵖ ⥤ Type v₁} (x : S.functor ⟶ P) (g : yoneda.obj X ⟶ P) :
    S.functorInclusion ≫ g = x ↔
      (natTransEquivCompatibleFamily x).1.IsAmalgamation (yonedaEquiv g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X} {P : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (x : S.functor ⟶ P) (g : CategoryTheory.yoneda.obj X ⟶ P)
Goal: CategoryTheory.CategoryStruct.comp S.functorInclusion g = x ↔
  (↑(CategoryTheory.Presieve.natTransEquivCompatibleFamily x)).IsAmalgamation (CategoryTheory.yonedaEquiv g)
-- CategoryTheory.Presieve.isSheafFor_iff_yonedaSheafCondition
theorem isSheafFor_iff_yonedaSheafCondition {P : Cᵒᵖ ⥤ Type v₁} :
    IsSheafFor P (S : Presieve X) ↔ YonedaSheafCondition P S 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X} {P : CategoryTheory.Functor Cᵒᵖ (Type v₁)}
Goal: CategoryTheory.Presieve.IsSheafFor P S.arrows ↔ CategoryTheory.Presieve.YonedaSheafCondition P S
-- CategoryTheory.Presieve.IsSheafFor.functorInclusion_comp_extend
@[reassoc (attr := simp)]
theorem IsSheafFor.functorInclusion_comp_extend {P : Cᵒᵖ ⥤ Type v₁} (h : IsSheafFor P S)
    (f : S.functor ⟶ P) : S.functorInclusion ≫ h.extend f = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X} {P : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (h : CategoryTheory.Presieve.IsSheafFor P S.arrows) (f : S.functor ⟶ P)
Goal: CategoryTheory.CategoryStruct.comp S.functorInclusion (h.extend f) = f
-- CategoryTheory.Presieve.IsSheafFor.unique_extend
theorem IsSheafFor.unique_extend {P : Cᵒᵖ ⥤ Type v₁} (h : IsSheafFor P S) {f : S.functor ⟶ P}
    (t : yoneda.obj X ⟶ P) (ht : S.functorInclusion ≫ t = f) : t = h.extend f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X} {P : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (h : CategoryTheory.Presieve.IsSheafFor P S.arrows) {f : S.functor ⟶ P} (t : CategoryTheory.yoneda.obj X ⟶ P) (ht : CategoryTheory.CategoryStruct.comp S.functorInclusion t = f)
Goal: t = h.extend f
-- CategoryTheory.Presieve.IsSheafFor.hom_ext
theorem IsSheafFor.hom_ext {P : Cᵒᵖ ⥤ Type v₁} (h : IsSheafFor P (S : Presieve X))
    (t₁ t₂ : yoneda.obj X ⟶ P) (ht : S.functorInclusion ≫ t₁ = S.functorInclusion ≫ t₂) :
    t₁ = t₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X} {P : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (h : CategoryTheory.Presieve.IsSheafFor P S.arrows) (t₁ t₂ : CategoryTheory.yoneda.obj X ⟶ P) (ht :
  CategoryTheory.CategoryStruct.comp S.functorInclusion t₁ = CategoryTheory.CategoryStruct.comp S.functorInclusion t₂)
Goal: t₁ = t₂
-- CategoryTheory.Presieve.isSeparatedFor_and_exists_isAmalgamation_iff_isSheafFor
theorem isSeparatedFor_and_exists_isAmalgamation_iff_isSheafFor :
    (IsSeparatedFor P R ∧ ∀ x : FamilyOfElements P R, x.Compatible → ∃ t, x.IsAmalgamation t) ↔
      IsSheafFor P R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X}
Goal: (CategoryTheory.Presieve.IsSeparatedFor P R ∧
    ∀ (x : CategoryTheory.Presieve.FamilyOfElements P R), x.Compatible → ∃ t, x.IsAmalgamation t) ↔
  CategoryTheory.Presieve.IsSheafFor P R
-- CategoryTheory.Presieve.IsSeparatedFor.isSheafFor
theorem IsSeparatedFor.isSheafFor (t : IsSeparatedFor P R) :
    (∀ x : FamilyOfElements P R, x.Compatible → ∃ t, x.IsAmalgamation t) → IsSheafFor P R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X} (t : CategoryTheory.Presieve.IsSeparatedFor P R)
Goal: (∀ (x : CategoryTheory.Presieve.FamilyOfElements P R), x.Compatible → ∃ t, x.IsAmalgamation t) →
  CategoryTheory.Presieve.IsSheafFor P R
-- CategoryTheory.Presieve.IsSheafFor.isSeparatedFor
theorem IsSheafFor.isSeparatedFor : IsSheafFor P R → IsSeparatedFor P R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X}
Goal: CategoryTheory.Presieve.IsSheafFor P R → CategoryTheory.Presieve.IsSeparatedFor P R
-- CategoryTheory.Presieve.IsSheafFor.isAmalgamation
theorem IsSheafFor.isAmalgamation (t : IsSheafFor P R) {x : FamilyOfElements P R}
    (hx : x.Compatible) : x.IsAmalgamation (t.amalgamate x hx) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X} (t : CategoryTheory.Presieve.IsSheafFor P R) {x : CategoryTheory.Presieve.FamilyOfElements P R} (hx : x.Compatible)
Goal: x.IsAmalgamation (t.amalgamate x hx)
-- CategoryTheory.Presieve.IsSheafFor.valid_glue
@[simp]
theorem IsSheafFor.valid_glue (t : IsSheafFor P R) {x : FamilyOfElements P R} (hx : x.Compatible)
    (f : Y ⟶ X) (Hf : R f) : P.map f.op (t.amalgamate x hx) = x f Hf 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X Y : C} {R : CategoryTheory.Presieve X} (t : CategoryTheory.Presieve.IsSheafFor P R) {x : CategoryTheory.Presieve.FamilyOfElements P R} (hx : x.Compatible) (f : Y ⟶ X) (Hf : R f)
Goal: P.map f.op (t.amalgamate x hx) = x f Hf
-- CategoryTheory.Presieve.isSheafFor_iff_generate
theorem isSheafFor_iff_generate (R : Presieve X) :
    IsSheafFor P R ↔ IsSheafFor P (generate R : Presieve X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} (R : CategoryTheory.Presieve X)
Goal: CategoryTheory.Presieve.IsSheafFor P R ↔ CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Sieve.generate R).arrows
-- CategoryTheory.Presieve.isSheafFor_singleton_iso
theorem isSheafFor_singleton_iso (P : Cᵒᵖ ⥤ Type w) : IsSheafFor P (Presieve.singleton (𝟙 X)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (P : CategoryTheory.Functor Cᵒᵖ (Type w))
Goal: CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Presieve.singleton (CategoryTheory.CategoryStruct.id X))
-- CategoryTheory.Presieve.isSheafFor_top_sieve
theorem isSheafFor_top_sieve (P : Cᵒᵖ ⥤ Type w) : IsSheafFor P ((⊤ : Sieve X) : Presieve X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (P : CategoryTheory.Functor Cᵒᵖ (Type w))
Goal: CategoryTheory.Presieve.IsSheafFor P ⊤.arrows
-- CategoryTheory.Presieve.isSheafFor_iso
theorem isSheafFor_iso {P' : Cᵒᵖ ⥤ Type w} (i : P ≅ P') : IsSheafFor P R → IsSheafFor P' R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C} {R : CategoryTheory.Presieve X} {P' : CategoryTheory.Functor Cᵒᵖ (Type w)} (i : P ≅ P')
Goal: CategoryTheory.Presieve.IsSheafFor P R → CategoryTheory.Presieve.IsSheafFor P' R
-- CategoryTheory.Presieve.isSheafFor_subsieve_aux
theorem isSheafFor_subsieve_aux (P : Cᵒᵖ ⥤ Type w) {S : Sieve X} {R : Presieve X}
    (h : (S : Presieve X) ≤ R) (hS : IsSheafFor P (S : Presieve X))
    (trans : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, R f → IsSeparatedFor P (S.pullback f : Presieve Y)) :
    IsSheafFor P R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {S : CategoryTheory.Sieve X} {R : CategoryTheory.Presieve X} (h : S.arrows ≤ R) (hS : CategoryTheory.Presieve.IsSheafFor P S.arrows) (trans :
  ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, R f → CategoryTheory.Presieve.IsSeparatedFor P (CategoryTheory.Sieve.pullback f S).arrows)
Goal: CategoryTheory.Presieve.IsSheafFor P R
-- CategoryTheory.Presieve.isSheafFor_subsieve
theorem isSheafFor_subsieve (P : Cᵒᵖ ⥤ Type w) {S : Sieve X} {R : Presieve X}
    (h : (S : Presieve X) ≤ R) (trans : ∀ ⦃Y⦄ (f : Y ⟶ X),
      IsSheafFor P (S.pullback f : Presieve Y)) :
    IsSheafFor P R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {S : CategoryTheory.Sieve X} {R : CategoryTheory.Presieve X} (h : S.arrows ≤ R) (trans : ∀ ⦃Y : C⦄ (f : Y ⟶ X), CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Sieve.pullback f S).arrows)
Goal: CategoryTheory.Presieve.IsSheafFor P R
-- CategoryTheory.Presieve.FamilyOfElements.isAmalgamation_iff_ofArrows
lemma FamilyOfElements.isAmalgamation_iff_ofArrows (x : FamilyOfElements P (ofArrows X π))
    (t : P.obj (op B)) :
    x.IsAmalgamation t ↔ ∀ (i : I), P.map (π i).op t = x _ (ofArrows.mk i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C} {I : Type u_1} {X : I → C} (π : (i : I) → X i ⟶ B) (x : CategoryTheory.Presieve.FamilyOfElements P (CategoryTheory.Presieve.ofArrows X π)) (t : P.obj (Opposite.op B))
Goal: x.IsAmalgamation t ↔ ∀ (i : I), P.map (π i).op t = x (π i) ⋯
-- CategoryTheory.Presieve.Arrows.Compatible.exists_familyOfElements
theorem exists_familyOfElements (hx : Compatible P π x) :
    ∃ (x' : FamilyOfElements P (ofArrows X π)), ∀ (i : I), x' _ (ofArrows.mk i) = x i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {B : C} {I : Type u_1} {X : I → C} {π : (i : I) → X i ⟶ B} {x : (i : I) → P.obj (Opposite.op (X i))} (hx : CategoryTheory.Presieve.Arrows.Compatible P π x)
Goal: ∃ x', ∀ (i : I), x' (π i) ⋯ = x i
-- CategoryTheory.Presieve.Arrows.Compatible.familyOfElements_ofArrows_mk
@[simp]
theorem familyOfElements_ofArrows_mk (i : I) :
    hx.familyOfElements _ (ofArrows.mk i) = x i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {B : C} {I : Type u_1} {X : I → C} {π : (i : I) → X i ⟶ B} {x : (i : I) → P.obj (Opposite.op (X i))} (hx : CategoryTheory.Presieve.Arrows.Compatible P π x) (i : I)
Goal: hx.familyOfElements (π i) ⋯ = x i
-- CategoryTheory.Presieve.Arrows.Compatible.familyOfElements_compatible
theorem familyOfElements_compatible : hx.familyOfElements.Compatible 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {B : C} {I : Type u_1} {X : I → C} {π : (i : I) → X i ⟶ B} {x : (i : I) → P.obj (Opposite.op (X i))} (hx : CategoryTheory.Presieve.Arrows.Compatible P π x)
Goal: hx.familyOfElements.Compatible
-- CategoryTheory.Presieve.isSheafFor_arrows_iff
theorem isSheafFor_arrows_iff : (ofArrows X π).IsSheafFor P ↔
    (∀ (x : (i : I) → P.obj (op (X i))), Arrows.Compatible P π x →
    ∃! t, ∀ i, P.map (π i).op t = x i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C} {I : Type u_1} {X : I → C} (π : (i : I) → X i ⟶ B)
Goal: CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Presieve.ofArrows X π) ↔
  ∀ (x : (i : I) → P.obj (Opposite.op (X i))),
    CategoryTheory.Presieve.Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i
-- CategoryTheory.Presieve.Arrows.pullbackCompatible_iff
theorem Arrows.pullbackCompatible_iff (x : (i : I) → P.obj (op (X i))) :
    Compatible P π x ↔ PullbackCompatible P π x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C} {I : Type u_1} {X : I → C} (π : (i : I) → X i ⟶ B) [(CategoryTheory.Presieve.ofArrows X π).hasPullbacks] (x : (i : I) → P.obj (Opposite.op (X i)))
Goal: CategoryTheory.Presieve.Arrows.Compatible P π x ↔ CategoryTheory.Presieve.Arrows.PullbackCompatible P π x
-- CategoryTheory.Presieve.isSheafFor_arrows_iff_pullbacks
theorem isSheafFor_arrows_iff_pullbacks : (ofArrows X π).IsSheafFor P ↔
    (∀ (x : (i : I) → P.obj (op (X i))), Arrows.PullbackCompatible P π x →
    ∃! t, ∀ i, P.map (π i).op t = x i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C} {I : Type u_1} {X : I → C} (π : (i : I) → X i ⟶ B) [(CategoryTheory.Presieve.ofArrows X π).hasPullbacks]
Goal: CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Presieve.ofArrows X π) ↔
  ∀ (x : (i : I) → P.obj (Opposite.op (X i))),
    CategoryTheory.Presieve.Arrows.PullbackCompatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i
-- CategoryTheory.Pretopology.transitive
@[ext]
structure Pretopology where
  coverings : ∀ X : C, Set (Presieve X)
  has_isos : ∀ ⦃X Y⦄ (f : Y ⟶ X) [IsIso f], Presieve.singleton f ∈ coverings X
  pullbacks : ∀ ⦃X Y⦄ (f : Y ⟶ X) (S), S ∈ coverings X → pullbackArrows f S ∈ coverings Y
  transitive :
    ∀ ⦃X : C⦄ (S : Presieve X) (Ti : ∀ ⦃Y⦄ (f : Y ⟶ X), S f → Presieve Y),
      S ∈ coverings X → (∀ ⦃Y⦄ (f) (H : S f), Ti f H ∈ coverings Y) → S.bind Ti ∈ coverings X
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] (self : CategoryTheory.Pretopology C) ⦃X : C⦄ (S : CategoryTheory.Presieve X) (Ti : ⦃Y : C⦄ → (f : Y ⟶ X) → S f → CategoryTheory.Presieve Y)
Goal: S ∈ self.coverings X → (∀ ⦃Y : C⦄ (f : Y ⟶ X) (H : S f), Ti f H ∈ self.coverings Y) → S.bind Ti ∈ self.coverings X
-- CategoryTheory.Pretopology.has_isos
@[ext]
structure Pretopology where
  coverings : ∀ X : C, Set (Presieve X)
  has_isos : ∀ ⦃X Y⦄ (f : Y ⟶ X) [IsIso f], Presieve.singleton f ∈ coverings X
  pullbacks : ∀ ⦃X Y⦄ (f : Y ⟶ X) (S), S ∈ coverings X → pullbackArrows f S ∈ coverings Y
  transitive :
    ∀ ⦃X : C⦄ (S : Presieve X) (Ti : ∀ ⦃Y⦄ (f : Y ⟶ X), S f → Presieve Y),
      S ∈ coverings X → (∀ ⦃Y⦄ (f) (H : S f), Ti f H ∈ coverings Y) → S.bind Ti ∈ coverings X
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] (self : CategoryTheory.Pretopology C) ⦃X Y : C⦄ (f : Y ⟶ X) [CategoryTheory.IsIso f]
Goal: CategoryTheory.Presieve.singleton f ∈ self.coverings X
-- CategoryTheory.Pretopology.pullbacks
@[ext]
structure Pretopology where
  coverings : ∀ X : C, Set (Presieve X)
  has_isos : ∀ ⦃X Y⦄ (f : Y ⟶ X) [IsIso f], Presieve.singleton f ∈ coverings X
  pullbacks : ∀ ⦃X Y⦄ (f : Y ⟶ X) (S), S ∈ coverings X → pullbackArrows f S ∈ coverings Y
  transitive :
    ∀ ⦃X : C⦄ (S : Presieve X) (Ti : ∀ ⦃Y⦄ (f : Y ⟶ X), S f → Presieve Y),
      S ∈ coverings X → (∀ ⦃Y⦄ (f) (H : S f), Ti f H ∈ coverings Y) → S.bind Ti ∈ coverings X
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] (self : CategoryTheory.Pretopology C) ⦃X Y : C⦄ (f : Y ⟶ X) (S : CategoryTheory.Presieve X)
Goal: S ∈ self.coverings X → CategoryTheory.Presieve.pullbackArrows f S ∈ self.coverings Y
-- CategoryTheory.Pretopology.le_def
theorem le_def {K₁ K₂ : Pretopology C} : K₁ ≤ K₂ ↔ (K₁ : ∀ X : C, Set (Presieve X)) ≤ K₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] {K₁ K₂ : CategoryTheory.Pretopology C}
Goal: K₁ ≤ K₂ ↔ K₁.coverings ≤ K₂.coverings
-- CategoryTheory.Pretopology.mem_toGrothendieck
theorem mem_toGrothendieck (K : Pretopology C) (X S) :
    S ∈ toGrothendieck C K X ↔ ∃ R ∈ K X, R ≤ (S : Presieve X) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] (K : CategoryTheory.Pretopology C) (X : C) (S : CategoryTheory.Sieve X)
Goal: S ∈ (CategoryTheory.Pretopology.toGrothendieck C K).sieves X ↔ ∃ R ∈ K.coverings X, R ≤ S.arrows
-- CategoryTheory.Pretopology.toGrothendieck_bot
theorem toGrothendieck_bot : toGrothendieck C ⊥ = ⊥ 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C]
Goal: CategoryTheory.Pretopology.toGrothendieck C ⊥ = ⊥
-- CategoryTheory.discreteSieve_apply
@[simps]
def discreteSieve (α : Type u) : Sieve α 
Arguments: (α : Type u)
Goal: ∀ (x : Type u) (f : x ⟶ α), (CategoryTheory.discreteSieve α).arrows f = ∃ x_1, ∀ (y : x), f y = x_1
-- CategoryTheory.discreteSieve_mem
theorem discreteSieve_mem (α : Type u) : discreteSieve α ∈ typesGrothendieckTopology α 
Arguments: (α : Type u)
Goal: CategoryTheory.discreteSieve α ∈ CategoryTheory.typesGrothendieckTopology.sieves α
-- CategoryTheory.generate_discretePresieve_mem
theorem generate_discretePresieve_mem (α : Type u) :
    Sieve.generate (discretePresieve α) ∈ typesGrothendieckTopology α 
Arguments: (α : Type u)
Goal: CategoryTheory.Sieve.generate (CategoryTheory.discretePresieve α) ∈ CategoryTheory.typesGrothendieckTopology.sieves α
-- CategoryTheory.isSheaf_yoneda'
theorem isSheaf_yoneda' {α : Type u} : IsSheaf typesGrothendieckTopology (yoneda.obj α) 
Arguments: {α : Type u}
Goal: CategoryTheory.Presieve.IsSheaf CategoryTheory.typesGrothendieckTopology (CategoryTheory.yoneda.obj α)
-- CategoryTheory.yoneda'_map_val
@[simps]
def yoneda' : Type u ⥤ SheafOfTypes typesGrothendieckTopology 
Goal: ∀ {X Y : Type u} (f : X ⟶ Y), (CategoryTheory.yoneda'.map f).val = CategoryTheory.yoneda.map f
-- CategoryTheory.yoneda'_obj_val
@[simps]
def yoneda' : Type u ⥤ SheafOfTypes typesGrothendieckTopology 
Arguments: (α : Type u)
Goal: (CategoryTheory.yoneda'.obj α).val = CategoryTheory.yoneda.obj α
-- CategoryTheory.yoneda'_comp
@[simp]
theorem yoneda'_comp : yoneda'.{u} ⋙ sheafOfTypesToPresheaf _ = yoneda 
Goal: CategoryTheory.yoneda'.comp (CategoryTheory.sheafOfTypesToPresheaf CategoryTheory.typesGrothendieckTopology) =
  CategoryTheory.yoneda
-- CategoryTheory.eval_typesGlue
theorem eval_typesGlue {S hs α} (f) : eval.{u} S α (typesGlue S hs α f) = f 
Arguments: {S : CategoryTheory.Functor Type uᵒᵖ (Type u)} {hs : CategoryTheory.Presieve.IsSheaf CategoryTheory.typesGrothendieckTopology S} {α : Type u} (f : α → S.obj (Opposite.op PUnit.{u + 1}))
Goal: CategoryTheory.eval S α (CategoryTheory.typesGlue S hs α f) = f
-- CategoryTheory.typesGlue_eval
theorem typesGlue_eval {S hs α} (s) : typesGlue.{u} S hs α (eval S α s) = s 
Arguments: {S : CategoryTheory.Functor Type uᵒᵖ (Type u)} {hs : CategoryTheory.Presieve.IsSheaf CategoryTheory.typesGrothendieckTopology S} {α : Type u} (s : S.obj (Opposite.op α))
Goal: CategoryTheory.typesGlue S hs α (CategoryTheory.eval S α s) = s
-- CategoryTheory.evalEquiv_apply
@[simps]
noncomputable def evalEquiv (S : Type uᵒᵖ ⥤ Type u) (hs : IsSheaf typesGrothendieckTopology S)
    (α : Type u) : S.obj (op α) ≃ (α → S.obj (op PUnit)) 
Arguments: (S : CategoryTheory.Functor Type uᵒᵖ (Type u)) (hs : CategoryTheory.Presieve.IsSheaf CategoryTheory.typesGrothendieckTopology S) (α : Type u) (s : S.obj (Opposite.op α)) (x : α)
Goal: (CategoryTheory.evalEquiv S hs α) s x = CategoryTheory.eval S α s x
-- CategoryTheory.evalEquiv_symm_apply
@[simps]
noncomputable def evalEquiv (S : Type uᵒᵖ ⥤ Type u) (hs : IsSheaf typesGrothendieckTopology S)
    (α : Type u) : S.obj (op α) ≃ (α → S.obj (op PUnit)) 
Arguments: (S : CategoryTheory.Functor Type uᵒᵖ (Type u)) (hs : CategoryTheory.Presieve.IsSheaf CategoryTheory.typesGrothendieckTopology S) (α : Type u) (f : α → S.obj (Opposite.op PUnit.{u + 1}))
Goal: (CategoryTheory.evalEquiv S hs α).symm f = CategoryTheory.typesGlue S hs α f
-- CategoryTheory.eval_map
theorem eval_map (S : Type uᵒᵖ ⥤ Type u) (α β) (f : β ⟶ α) (s x) :
    eval S β (S.map f.op s) x = eval S α s (f x) 
Arguments: (S : CategoryTheory.Functor Type uᵒᵖ (Type u)) (α β : Type u) (f : β ⟶ α) (s : S.obj (Opposite.op α)) (x : β)
Goal: CategoryTheory.eval S β (S.map f.op s) x = CategoryTheory.eval S α s (f x)
-- CategoryTheory.equivYoneda_hom_app
@[simps!]
noncomputable def equivYoneda (S : Type uᵒᵖ ⥤ Type u) (hs : IsSheaf typesGrothendieckTopology S) :
    S ≅ yoneda.obj (S.obj (op PUnit)) 
Arguments: (S : CategoryTheory.Functor Type uᵒᵖ (Type u)) (hs : CategoryTheory.Presieve.IsSheaf CategoryTheory.typesGrothendieckTopology S) (X : Type uᵒᵖ)
Goal: ∀ (a : S.obj X), (CategoryTheory.equivYoneda S hs).hom.app X a = (CategoryTheory.evalEquiv S hs (Opposite.unop X)) a
-- CategoryTheory.equivYoneda_inv_app
@[simps!]
noncomputable def equivYoneda (S : Type uᵒᵖ ⥤ Type u) (hs : IsSheaf typesGrothendieckTopology S) :
    S ≅ yoneda.obj (S.obj (op PUnit)) 
Arguments: (S : CategoryTheory.Functor Type uᵒᵖ (Type u)) (hs : CategoryTheory.Presieve.IsSheaf CategoryTheory.typesGrothendieckTopology S) (X : Type uᵒᵖ)
Goal: ∀ (a : (CategoryTheory.yoneda.obj (S.obj (Opposite.op PUnit.{u + 1}))).obj X),
  (CategoryTheory.equivYoneda S hs).inv.app X a = (CategoryTheory.evalEquiv S hs (Opposite.unop X)).symm a
-- CategoryTheory.equivYoneda'_hom_val
@[simps]
noncomputable def equivYoneda' (S : SheafOfTypes typesGrothendieckTopology) :
    S ≅ yoneda'.obj (S.1.obj (op PUnit)) 
Arguments: (S : CategoryTheory.SheafOfTypes CategoryTheory.typesGrothendieckTopology)
Goal: (CategoryTheory.equivYoneda' S).hom.val = (CategoryTheory.equivYoneda S.val ⋯).hom
-- CategoryTheory.equivYoneda'_inv_val
@[simps]
noncomputable def equivYoneda' (S : SheafOfTypes typesGrothendieckTopology) :
    S ≅ yoneda'.obj (S.1.obj (op PUnit)) 
Arguments: (S : CategoryTheory.SheafOfTypes CategoryTheory.typesGrothendieckTopology)
Goal: (CategoryTheory.equivYoneda' S).inv.val = (CategoryTheory.equivYoneda S.val ⋯).inv
-- CategoryTheory.eval_app
theorem eval_app (S₁ S₂ : SheafOfTypes.{u} typesGrothendieckTopology) (f : S₁ ⟶ S₂) (α : Type u)
    (s : S₁.1.obj (op α)) (x : α) :
    eval S₂.1 α (f.val.app (op α) s) x = f.val.app (op PUnit) (eval S₁.1 α s x) 
Arguments: (S₁ S₂ : CategoryTheory.SheafOfTypes CategoryTheory.typesGrothendieckTopology) (f : S₁ ⟶ S₂) (α : Type u) (s : S₁.val.obj (Opposite.op α)) (x : α)
Goal: CategoryTheory.eval S₂.val α (f.val.app (Opposite.op α) s) x =
  f.val.app (Opposite.op PUnit.{u + 1}) (CategoryTheory.eval S₁.val α s x)