ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Equalizer.Sieve.w
theorem w : forkMap P (S : Presieve X) ≫ firstMap P S = forkMap P S ≫ secondMap P S 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) {X : C} (S : CategoryTheory.Sieve X)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Equalizer.forkMap P S.arrows)
    (CategoryTheory.Equalizer.Sieve.firstMap P S) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Equalizer.forkMap P S.arrows)
    (CategoryTheory.Equalizer.Sieve.secondMap P S)
-- CategoryTheory.Equalizer.Sieve.compatible_iff
theorem compatible_iff (x : FirstObj P S) :
    ((firstObjEqFamily P S).hom x).Compatible ↔ firstMap P S x = secondMap P S x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) {X : C} (S : CategoryTheory.Sieve X) (x : CategoryTheory.Equalizer.FirstObj P S.arrows)
Goal: ((CategoryTheory.Equalizer.firstObjEqFamily P S.arrows).hom x).Compatible ↔
  CategoryTheory.Equalizer.Sieve.firstMap P S x = CategoryTheory.Equalizer.Sieve.secondMap P S x
-- CategoryTheory.Equalizer.Sieve.equalizer_sheaf_condition
theorem equalizer_sheaf_condition :
    Presieve.IsSheafFor P (S : Presieve X) ↔ Nonempty (IsLimit (Fork.ofι _ (w P S))) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) {X : C} (S : CategoryTheory.Sieve X)
Goal: CategoryTheory.Presieve.IsSheafFor P S.arrows ↔
  Nonempty
    (CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fork.ofι (CategoryTheory.Equalizer.forkMap P S.arrows) ⋯))
-- CategoryTheory.Equalizer.Presieve.w
theorem w : forkMap P R ≫ firstMap P R = forkMap P R ≫ secondMap P R 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) {X : C} (R : CategoryTheory.Presieve X) [R.hasPullbacks]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Equalizer.forkMap P R)
    (CategoryTheory.Equalizer.Presieve.firstMap P R) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Equalizer.forkMap P R)
    (CategoryTheory.Equalizer.Presieve.secondMap P R)
-- CategoryTheory.Equalizer.Presieve.compatible_iff
theorem compatible_iff (x : FirstObj P R) :
    ((firstObjEqFamily P R).hom x).Compatible ↔ firstMap P R x = secondMap P R x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) {X : C} (R : CategoryTheory.Presieve X) [R.hasPullbacks] (x : CategoryTheory.Equalizer.FirstObj P R)
Goal: ((CategoryTheory.Equalizer.firstObjEqFamily P R).hom x).Compatible ↔
  CategoryTheory.Equalizer.Presieve.firstMap P R x = CategoryTheory.Equalizer.Presieve.secondMap P R x
-- CategoryTheory.Equalizer.Presieve.sheaf_condition
theorem sheaf_condition : R.IsSheafFor P ↔ Nonempty (IsLimit (Fork.ofι _ (w P R))) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) {X : C} (R : CategoryTheory.Presieve X) [R.hasPullbacks]
Goal: CategoryTheory.Presieve.IsSheafFor P R ↔
  Nonempty (CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fork.ofι (CategoryTheory.Equalizer.forkMap P R) ⋯))
-- CategoryTheory.Equalizer.Presieve.Arrows.FirstObj.ext
@[ext]
lemma FirstObj.ext (z₁ z₂ : FirstObj P X) (h : ∀ i, (Pi.π _ i : FirstObj P X ⟶ _) z₁ =
    (Pi.π _ i : FirstObj P X ⟶ _) z₂) : z₁ = z₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {I : Type} (X : I → C) (z₁ z₂ : CategoryTheory.Equalizer.Presieve.Arrows.FirstObj P X) (h :
  ∀ (i : I),
    CategoryTheory.Limits.Pi.π (fun i => P.obj (Opposite.op (X i))) i z₁ =
      CategoryTheory.Limits.Pi.π (fun i => P.obj (Opposite.op (X i))) i z₂)
Goal: z₁ = z₂
-- CategoryTheory.Equalizer.Presieve.Arrows.SecondObj.ext
@[ext]
lemma SecondObj.ext (z₁ z₂ : SecondObj P X π) (h : ∀ ij, (Pi.π _ ij : SecondObj P X π ⟶ _) z₁ =
    (Pi.π _ ij : SecondObj P X π ⟶ _) z₂) : z₁ = z₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C} {I : Type} (X : I → C) (π : (i : I) → X i ⟶ B) [(CategoryTheory.Presieve.ofArrows X π).hasPullbacks] (z₁ z₂ : CategoryTheory.Equalizer.Presieve.Arrows.SecondObj P X π) (h :
  ∀ (ij : I × I),
    CategoryTheory.Limits.Pi.π (fun ij => P.obj (Opposite.op (CategoryTheory.Limits.pullback (π ij.1) (π ij.2)))) ij
        z₁ =
      CategoryTheory.Limits.Pi.π (fun ij => P.obj (Opposite.op (CategoryTheory.Limits.pullback (π ij.1) (π ij.2)))) ij
        z₂)
Goal: z₁ = z₂
-- CategoryTheory.Equalizer.Presieve.Arrows.w
theorem w : forkMap P X π ≫ firstMap P X π = forkMap P X π ≫ secondMap P X π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C} {I : Type} (X : I → C) (π : (i : I) → X i ⟶ B) [(CategoryTheory.Presieve.ofArrows X π).hasPullbacks]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Equalizer.Presieve.Arrows.forkMap P X π)
    (CategoryTheory.Equalizer.Presieve.Arrows.firstMap P X π) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Equalizer.Presieve.Arrows.forkMap P X π)
    (CategoryTheory.Equalizer.Presieve.Arrows.secondMap P X π)
-- CategoryTheory.Equalizer.Presieve.Arrows.compatible_iff
theorem compatible_iff (x : FirstObj P X) : (Arrows.Compatible P π ((Types.productIso _).hom x)) ↔
    firstMap P X π x = secondMap P X π x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C} {I : Type} (X : I → C) (π : (i : I) → X i ⟶ B) [(CategoryTheory.Presieve.ofArrows X π).hasPullbacks] (x : CategoryTheory.Equalizer.Presieve.Arrows.FirstObj P X)
Goal: CategoryTheory.Presieve.Arrows.Compatible P π
    ((CategoryTheory.Limits.Types.productIso fun i => P.obj (Opposite.op (X i))).hom x) ↔
  CategoryTheory.Equalizer.Presieve.Arrows.firstMap P X π x = CategoryTheory.Equalizer.Presieve.Arrows.secondMap P X π x
-- CategoryTheory.Equalizer.Presieve.Arrows.sheaf_condition
theorem sheaf_condition : (Presieve.ofArrows X π).IsSheafFor P ↔
    Nonempty (IsLimit (Fork.ofι (forkMap P X π) (w P X π))) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C} {I : Type} (X : I → C) (π : (i : I) → X i ⟶ B) [(CategoryTheory.Presieve.ofArrows X π).hasPullbacks]
Goal: CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Presieve.ofArrows X π) ↔
  Nonempty
    (CategoryTheory.Limits.IsLimit
      (CategoryTheory.Limits.Fork.ofι (CategoryTheory.Equalizer.Presieve.Arrows.forkMap P X π) ⋯))
-- CategoryTheory.Sieve.generateSingleton_eq
lemma Sieve.generateSingleton_eq {X Y : C} (f : Y ⟶ X) :
    Sieve.generate (Presieve.singleton f) = Sieve.generateSingleton f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f : Y ⟶ X)
Goal: CategoryTheory.Sieve.generate (CategoryTheory.Presieve.singleton f) = CategoryTheory.Sieve.generateSingleton f
-- CategoryTheory.Sieve.effectiveEpimorphic_singleton
theorem Sieve.effectiveEpimorphic_singleton {X Y : C} (f : Y ⟶ X) :
    (Presieve.singleton f).EffectiveEpimorphic ↔ (EffectiveEpi f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f : Y ⟶ X)
Goal: (CategoryTheory.Presieve.singleton f).EffectiveEpimorphic ↔ CategoryTheory.EffectiveEpi f
-- CategoryTheory.Sieve.generateFamily_eq
lemma Sieve.generateFamily_eq {B : C} {α : Type*} (X : α → C) (π : (a : α) → (X a ⟶ B)) :
    Sieve.generate (Presieve.ofArrows X π) = Sieve.generateFamily X π 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B : C} {α : Type u_2} (X : α → C) (π : (a : α) → X a ⟶ B)
Goal: CategoryTheory.Sieve.generate (CategoryTheory.Presieve.ofArrows X π) = CategoryTheory.Sieve.generateFamily X π
-- CategoryTheory.Sieve.effectiveEpimorphic_family
theorem Sieve.effectiveEpimorphic_family {B : C} {α : Type*}
    (X : α → C) (π : (a : α) → (X a ⟶ B)) :
    (Presieve.ofArrows X π).EffectiveEpimorphic ↔ EffectiveEpiFamily X π 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {B : C} {α : Type u_2} (X : α → C) (π : (a : α) → X a ⟶ B)
Goal: (CategoryTheory.Presieve.ofArrows X π).EffectiveEpimorphic ↔ CategoryTheory.EffectiveEpiFamily X π
-- CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily_symm_apply_app
@[simps]
def conesEquivSieveCompatibleFamily :
    (S.arrows.diagram.op ⋙ P).cones.obj E ≃
      { x : FamilyOfElements (P ⋙ coyoneda.obj E) (S : Presieve X) // x.SieveCompatible } 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X) (E : Aᵒᵖ) (x : { x // x.SieveCompatible }) (f : S.arrows.categoryᵒᵖ)
Goal: ((CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily P S E).symm x).app f = ↑x (Opposite.unop f).obj.hom ⋯
-- CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily_apply_coe
@[simps]
def conesEquivSieveCompatibleFamily :
    (S.arrows.diagram.op ⋙ P).cones.obj E ≃
      { x : FamilyOfElements (P ⋙ coyoneda.obj E) (S : Presieve X) // x.SieveCompatible } 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X) (E : Aᵒᵖ) (π : (S.arrows.diagram.op.comp P).cones.obj E) (Y : C) (f : Y ⟶ X) (h : S.arrows f)
Goal: ↑((CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily P S E) π) f h =
  π.app (Opposite.op { obj := CategoryTheory.Over.mk f, property := h })
-- CategoryTheory.Presheaf.isLimit_iff_isSheafFor
theorem isLimit_iff_isSheafFor :
    Nonempty (IsLimit (P.mapCone S.arrows.cocone.op)) ↔
      ∀ E : Aᵒᵖ, IsSheafFor (P ⋙ coyoneda.obj E) S.arrows 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X)
Goal: Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone S.arrows.cocone.op)) ↔
  ∀ (E : Aᵒᵖ), CategoryTheory.Presieve.IsSheafFor (P.comp (CategoryTheory.coyoneda.obj E)) S.arrows
-- CategoryTheory.Presheaf.subsingleton_iff_isSeparatedFor
theorem subsingleton_iff_isSeparatedFor :
    (∀ c, Subsingleton (c ⟶ P.mapCone S.arrows.cocone.op)) ↔
      ∀ E : Aᵒᵖ, IsSeparatedFor (P ⋙ coyoneda.obj E) S.arrows 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X)
Goal: (∀ (c : CategoryTheory.Limits.Cone (S.arrows.diagram.op.comp P)), Subsingleton (c ⟶ P.mapCone S.arrows.cocone.op)) ↔
  ∀ (E : Aᵒᵖ), CategoryTheory.Presieve.IsSeparatedFor (P.comp (CategoryTheory.coyoneda.obj E)) S.arrows
-- CategoryTheory.Presheaf.isSheaf_iff_isLimit
theorem isSheaf_iff_isLimit :
    IsSheaf J P ↔
      ∀ ⦃X : C⦄ (S : Sieve X), S ∈ J X → Nonempty (IsLimit (P.mapCone S.arrows.cocone.op)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A)
Goal: CategoryTheory.Presheaf.IsSheaf J P ↔
  ∀ ⦃X : C⦄, ∀ S ∈ J.sieves X, Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone S.arrows.cocone.op))
-- CategoryTheory.Presheaf.isSeparated_iff_subsingleton
theorem isSeparated_iff_subsingleton :
    (∀ E : A, Presieve.IsSeparated J (P ⋙ coyoneda.obj (op E))) ↔
      ∀ ⦃X : C⦄ (S : Sieve X), S ∈ J X → ∀ c, Subsingleton (c ⟶ P.mapCone S.arrows.cocone.op) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A)
Goal: (∀ (E : A), CategoryTheory.Presieve.IsSeparated J (P.comp (CategoryTheory.coyoneda.obj (Opposite.op E)))) ↔
  ∀ ⦃X : C⦄,
    ∀ S ∈ J.sieves X,
      ∀ (c : CategoryTheory.Limits.Cone (S.arrows.diagram.op.comp P)), Subsingleton (c ⟶ P.mapCone S.arrows.cocone.op)
-- CategoryTheory.Presheaf.isLimit_iff_isSheafFor_presieve
theorem isLimit_iff_isSheafFor_presieve :
    Nonempty (IsLimit (P.mapCone (generate R).arrows.cocone.op)) ↔
      ∀ E : Aᵒᵖ, IsSheafFor (P ⋙ coyoneda.obj E) R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (R : CategoryTheory.Presieve X)
Goal: Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone (CategoryTheory.Sieve.generate R).arrows.cocone.op)) ↔
  ∀ (E : Aᵒᵖ), CategoryTheory.Presieve.IsSheafFor (P.comp (CategoryTheory.coyoneda.obj E)) R
-- CategoryTheory.Presheaf.isSheaf_iff_isLimit_pretopology
theorem isSheaf_iff_isLimit_pretopology [HasPullbacks C] (K : Pretopology C) :
    IsSheaf (K.toGrothendieck C) P ↔
      ∀ ⦃X : C⦄ (R : Presieve X),
        R ∈ K X → Nonempty (IsLimit (P.mapCone (generate R).arrows.cocone.op)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasPullbacks C] (K : CategoryTheory.Pretopology C)
Goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.Pretopology.toGrothendieck C K) P ↔
  ∀ ⦃X : C⦄,
    ∀ R ∈ K.coverings X,
      Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone (CategoryTheory.Sieve.generate R).arrows.cocone.op))
-- CategoryTheory.Presheaf.IsSheaf.amalgamate_map
@[reassoc (attr := simp)]
theorem IsSheaf.amalgamate_map {A : Type u₂} [Category.{v₂} A] {E : A} {X : C} {P : Cᵒᵖ ⥤ A}
    (hP : Presheaf.IsSheaf J P) (S : J.Cover X) (x : ∀ I : S.Arrow, E ⟶ P.obj (op I.Y))
    (hx : ∀ ⦃I₁ I₂ : S.Arrow⦄ (r : I₁.Relation I₂),
       x I₁ ≫ P.map r.g₁.op = x I₂ ≫ P.map r.g₂.op)
    (I : S.Arrow) :
    hP.amalgamate S x hx ≫ P.map I.f.op = x _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) (S : J.Cover X) (x : (I : S.Arrow) → E ⟶ P.obj (Opposite.op I.Y)) (hx :
  ∀ ⦃I₁ I₂ : S.Arrow⦄ (r : I₁.Relation I₂),
    CategoryTheory.CategoryStruct.comp (x I₁) (P.map r.g₁.op) =
      CategoryTheory.CategoryStruct.comp (x I₂) (P.map r.g₂.op)) (I : S.Arrow)
Goal: CategoryTheory.CategoryStruct.comp (hP.amalgamate S x hx) (P.map I.f.op) = x I
-- CategoryTheory.Presheaf.IsSheaf.hom_ext
theorem IsSheaf.hom_ext {A : Type u₂} [Category.{v₂} A] {E : A} {X : C} {P : Cᵒᵖ ⥤ A}
    (hP : Presheaf.IsSheaf J P) (S : J.Cover X) (e₁ e₂ : E ⟶ P.obj (op X))
    (h : ∀ I : S.Arrow, e₁ ≫ P.map I.f.op = e₂ ≫ P.map I.f.op) : e₁ = e₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) (S : J.Cover X) (e₁ e₂ : E ⟶ P.obj (Opposite.op X)) (h :
  ∀ (I : S.Arrow),
    CategoryTheory.CategoryStruct.comp e₁ (P.map I.f.op) = CategoryTheory.CategoryStruct.comp e₂ (P.map I.f.op))
Goal: e₁ = e₂
-- CategoryTheory.Presheaf.IsSheaf.hom_ext_ofArrows
lemma IsSheaf.hom_ext_ofArrows
    {P : Cᵒᵖ ⥤ A} (hP : Presheaf.IsSheaf J P) {I : Type*} {S : C} {X : I → C}
    (f : ∀ i, X i ⟶ S) (hf : Sieve.ofArrows _ f ∈ J S) {E : A}
    {x y : E ⟶ P.obj (op S)} (h : ∀ i, x ≫ P.map (f i).op = y ≫ P.map (f i).op) :
    x = y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) {I : Type u_1} {S : C} {X : I → C} (f : (i : I) → X i ⟶ S) (hf : CategoryTheory.Sieve.ofArrows X f ∈ J.sieves S) {E : A} {x y : E ⟶ P.obj (Opposite.op S)} (h :
  ∀ (i : I),
    CategoryTheory.CategoryStruct.comp x (P.map (f i).op) = CategoryTheory.CategoryStruct.comp y (P.map (f i).op))
Goal: x = y
-- CategoryTheory.Presheaf.IsSheaf.exists_unique_amalgamation_ofArrows
lemma IsSheaf.exists_unique_amalgamation_ofArrows :
    ∃! (g : E ⟶ P.obj (op S)), ∀ (i : I), g ≫ P.map (f i).op = x i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) {I : Type u_1} {S : C} {X : I → C} (f : (i : I) → X i ⟶ S) (hf : CategoryTheory.Sieve.ofArrows X f ∈ J.sieves S) {E : A} (x : (i : I) → E ⟶ P.obj (Opposite.op (X i))) (hx :
  ∀ ⦃W : C⦄ ⦃i j : I⦄ (a : W ⟶ X i) (b : W ⟶ X j),
    CategoryTheory.CategoryStruct.comp a (f i) = CategoryTheory.CategoryStruct.comp b (f j) →
      CategoryTheory.CategoryStruct.comp (x i) (P.map a.op) = CategoryTheory.CategoryStruct.comp (x j) (P.map b.op))
Goal: ∃! g, ∀ (i : I), CategoryTheory.CategoryStruct.comp g (P.map (f i).op) = x i
-- CategoryTheory.Presheaf.IsSheaf.amalgamateOfArrows_map
@[reassoc (attr := simp)]
lemma IsSheaf.amalgamateOfArrows_map (i : I) :
    hP.amalgamateOfArrows f hf x hx ≫ P.map (f i).op = x i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) {I : Type u_1} {S : C} {X : I → C} (f : (i : I) → X i ⟶ S) (hf : CategoryTheory.Sieve.ofArrows X f ∈ J.sieves S) {E : A} (x : (i : I) → E ⟶ P.obj (Opposite.op (X i))) (hx :
  ∀ ⦃W : C⦄ ⦃i j : I⦄ (a : W ⟶ X i) (b : W ⟶ X j),
    CategoryTheory.CategoryStruct.comp a (f i) = CategoryTheory.CategoryStruct.comp b (f j) →
      CategoryTheory.CategoryStruct.comp (x i) (P.map a.op) = CategoryTheory.CategoryStruct.comp (x j) (P.map b.op)) (i : I)
Goal: CategoryTheory.CategoryStruct.comp (hP.amalgamateOfArrows f hf x hx) (P.map (f i).op) = x i
-- CategoryTheory.Presheaf.isSheaf_of_iso_iff
theorem isSheaf_of_iso_iff {P P' : Cᵒᵖ ⥤ A} (e : P ≅ P') : IsSheaf J P ↔ IsSheaf J P' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} {P P' : CategoryTheory.Functor Cᵒᵖ A} (e : P ≅ P')
Goal: CategoryTheory.Presheaf.IsSheaf J P ↔ CategoryTheory.Presheaf.IsSheaf J P'
-- CategoryTheory.Presheaf.isSheaf_of_isTerminal
theorem isSheaf_of_isTerminal {X : A} (hX : IsTerminal X) :
    Presheaf.IsSheaf J ((CategoryTheory.Functor.const _).obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) {X : A} (hX : CategoryTheory.Limits.IsTerminal X)
Goal: CategoryTheory.Presheaf.IsSheaf J ((CategoryTheory.Functor.const Cᵒᵖ).obj X)
-- CategoryTheory.Sheaf.cond
structure Sheaf where
    val : Cᵒᵖ ⥤ A
    cond : Presheaf.IsSheaf J val
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (self : CategoryTheory.Sheaf J A)
Goal: CategoryTheory.Presheaf.IsSheaf J self.val
-- CategoryTheory.Sheaf.instCategorySheaf_id_val
@[simps id_val comp_val]
instance instCategorySheaf : Category (Sheaf J A) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A]
Goal: ∀ (x : CategoryTheory.Sheaf J A), (CategoryTheory.CategoryStruct.id x).val = CategoryTheory.CategoryStruct.id x.val
-- CategoryTheory.Sheaf.instCategorySheaf_comp_val
@[simps id_val comp_val]
instance instCategorySheaf : Category (Sheaf J A) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A]
Goal: ∀ {X Y Z : CategoryTheory.Sheaf J A} (f : X ⟶ Y) (g : Y ⟶ Z),
  (CategoryTheory.CategoryStruct.comp f g).val = CategoryTheory.CategoryStruct.comp f.val g.val
-- CategoryTheory.Sheaf.hom_ext
@[ext]
lemma hom_ext {X Y : Sheaf J A} (x y : X ⟶ Y) (h : x.val = y.val) : x = y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {X Y : CategoryTheory.Sheaf J A} (x y : X ⟶ Y) (h : x.val = y.val)
Goal: x = y
-- CategoryTheory.sheafToPresheaf_obj
@[simps]
def sheafToPresheaf : Sheaf J A ⥤ Cᵒᵖ ⥤ A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] (self : CategoryTheory.Sheaf J A)
Goal: (CategoryTheory.sheafToPresheaf J A).obj self = self.val
-- CategoryTheory.sheafToPresheaf_map
@[simps]
def sheafToPresheaf : Sheaf J A ⥤ Cᵒᵖ ⥤ A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A]
Goal: ∀ {X Y : CategoryTheory.Sheaf J A} (f : X ⟶ Y), (CategoryTheory.sheafToPresheaf J A).map f = f.val
-- CategoryTheory.fullyFaithfulSheafToPresheaf_preimage_val
@[simps]
def fullyFaithfulSheafToPresheaf : (sheafToPresheaf J A).FullyFaithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A]
Goal: ∀ {X Y : CategoryTheory.Sheaf J A}
  (f : (CategoryTheory.sheafToPresheaf J A).obj X ⟶ (CategoryTheory.sheafToPresheaf J A).obj Y),
  ((CategoryTheory.fullyFaithfulSheafToPresheaf J A).preimage f).val = f
-- CategoryTheory.Sheaf.Hom.mono_of_presheaf_mono
theorem Sheaf.Hom.mono_of_presheaf_mono {F G : Sheaf J A} (f : F ⟶ G) [h : Mono f.1] : Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] {F G : CategoryTheory.Sheaf J A} (f : F ⟶ G) [h : CategoryTheory.Mono f.val]
Goal: CategoryTheory.Mono f
-- CategoryTheory.sheafOver_val
@[simps]
def sheafOver {A : Type u₂} [Category.{v₂} A] {J : GrothendieckTopology C} (ℱ : Sheaf J A) (E : A) :
    SheafOfTypes J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} (ℱ : CategoryTheory.Sheaf J A) (E : A)
Goal: (CategoryTheory.sheafOver ℱ E).val = ℱ.val.comp (CategoryTheory.coyoneda.obj (Opposite.op E))
-- CategoryTheory.isSheaf_iff_isSheaf_of_type
theorem isSheaf_iff_isSheaf_of_type (P : Cᵒᵖ ⥤ Type w) :
    Presheaf.IsSheaf J P ↔ Presieve.IsSheaf J P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ (Type w))
Goal: CategoryTheory.Presheaf.IsSheaf J P ↔ CategoryTheory.Presieve.IsSheaf J P
-- CategoryTheory.Presheaf.IsSheaf.isSheafFor
lemma Presheaf.IsSheaf.isSheafFor {P : Cᵒᵖ ⥤ Type w} (hP : Presheaf.IsSheaf J P)
    {X : C} (S : Sieve X) (hS : S ∈ J X) : Presieve.IsSheafFor P S.arrows 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {P : CategoryTheory.Functor Cᵒᵖ (Type w)} (hP : CategoryTheory.Presheaf.IsSheaf J P) {X : C} (S : CategoryTheory.Sieve X) (hS : S ∈ J.sieves X)
Goal: CategoryTheory.Presieve.IsSheafFor P S.arrows
-- CategoryTheory.sheafEquivSheafOfTypes_unitIso
@[simps]
def sheafEquivSheafOfTypes : Sheaf J (Type w) ≌ SheafOfTypes J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C)
Goal: (CategoryTheory.sheafEquivSheafOfTypes J).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun X => CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Sheaf J (Type w))).obj X)) ⋯
-- CategoryTheory.sheafEquivSheafOfTypes_counitIso
@[simps]
def sheafEquivSheafOfTypes : Sheaf J (Type w) ≌ SheafOfTypes J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C)
Goal: (CategoryTheory.sheafEquivSheafOfTypes J).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun X =>
      CategoryTheory.Iso.refl
        (({ obj := fun S => { val := S.val, cond := ⋯ }, map := fun {X Y} f => { val := f.val }, map_id := ⋯,
                  map_comp := ⋯ }.comp
              { obj := fun S => { val := S.val, cond := ⋯ }, map := fun {X Y} f => { val := f.val }, map_id := ⋯,
                map_comp := ⋯ }).obj
          X))
    ⋯