ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PowerBasis.equivAdjoinSimple_symm_aeval
@[simp]
theorem equivAdjoinSimple_symm_aeval (pb : PowerBasis K L) (f : K[X]) :
    pb.equivAdjoinSimple.symm (aeval pb.gen f) = aeval (AdjoinSimple.gen K pb.gen) f 
Arguments: {K : Type u_1} {L : Type u_2} [Field K] [Field L] [Algebra K L] (pb : PowerBasis K L) (f : K[X])
Goal: pb.equivAdjoinSimple.symm ((Polynomial.aeval pb.gen) f) =
  (Polynomial.aeval (IntermediateField.AdjoinSimple.gen K pb.gen)) f
-- PowerBasis.equivAdjoinSimple_symm_gen
@[simp]
theorem equivAdjoinSimple_symm_gen (pb : PowerBasis K L) :
    pb.equivAdjoinSimple.symm pb.gen = AdjoinSimple.gen K pb.gen 
Arguments: {K : Type u_1} {L : Type u_2} [Field K] [Field L] [Algebra K L] (pb : PowerBasis K L)
Goal: pb.equivAdjoinSimple.symm pb.gen = IntermediateField.AdjoinSimple.gen K pb.gen
-- IntermediateField.map_comap_eq
theorem map_comap_eq (f : L →ₐ[K] L') (S : IntermediateField K L') :
    (S.comap f).map f = S ⊓ f.fieldRange 
Arguments: {K : Type u_1} {L : Type u_2} {L' : Type u_3} [Field K] [Field L] [Field L'] [Algebra K L] [Algebra K L'] (f : L →ₐ[K] L') (S : IntermediateField K L')
Goal: IntermediateField.map f (IntermediateField.comap f S) = S ⊓ f.fieldRange
-- IntermediateField.map_comap_eq_self
theorem map_comap_eq_self {f : L →ₐ[K] L'} {S : IntermediateField K L'} (h : S ≤ f.fieldRange) :
    (S.comap f).map f = S 
Arguments: {K : Type u_1} {L : Type u_2} {L' : Type u_3} [Field K] [Field L] [Field L'] [Algebra K L] [Algebra K L'] {f : L →ₐ[K] L'} {S : IntermediateField K L'} (h : S ≤ f.fieldRange)
Goal: IntermediateField.map f (IntermediateField.comap f S) = S
-- IntermediateField.map_comap_eq_self_of_surjective
theorem map_comap_eq_self_of_surjective {f : L →ₐ[K] L'} (hf : Function.Surjective f)
    (S : IntermediateField K L') : (S.comap f).map f = S 
Arguments: {K : Type u_1} {L : Type u_2} {L' : Type u_3} [Field K] [Field L] [Field L'] [Algebra K L] [Algebra K L'] {f : L →ₐ[K] L'} (hf : Function.Surjective ⇑f) (S : IntermediateField K L')
Goal: IntermediateField.map f (IntermediateField.comap f S) = S
-- IntermediateField.comap_map
theorem comap_map (f : L →ₐ[K] L') (S : IntermediateField K L) : (S.map f).comap f = S 
Arguments: {K : Type u_1} {L : Type u_2} {L' : Type u_3} [Field K] [Field L] [Field L'] [Algebra K L] [Algebra K L'] (f : L →ₐ[K] L') (S : IntermediateField K L)
Goal: IntermediateField.comap f (IntermediateField.map f S) = S
-- CategoryTheory.Functor.LocallyCoverDense.functorPushforward_functorPullback_mem
class LocallyCoverDense : Prop where
  functorPushforward_functorPullback_mem :
    ∀ ⦃X : C⦄ (T : K (G.obj X)), (T.val.functorPullback G).functorPushforward G ∈ K (G.obj X)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] {G : CategoryTheory.Functor C D} {K : CategoryTheory.GrothendieckTopology D} [self : G.LocallyCoverDense K] ⦃X : C⦄ (T : ↑(K.sieves (G.obj X)))
Goal: CategoryTheory.Sieve.functorPushforward G (CategoryTheory.Sieve.functorPullback G ↑T) ∈ K.sieves (G.obj X)
-- CategoryTheory.Functor.pushforward_cover_iff_cover_pullback
theorem pushforward_cover_iff_cover_pullback [G.Full] [G.Faithful] {X : C} (S : Sieve X) :
    K _ (S.functorPushforward G) ↔ ∃ T : K (G.obj X), T.val.functorPullback G = S 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (G : CategoryTheory.Functor C D) (K : CategoryTheory.GrothendieckTopology D) [G.LocallyCoverDense K] [G.Full] [G.Faithful] {X : C} (S : CategoryTheory.Sieve X)
Goal: K.sieves (G.obj X) (CategoryTheory.Sieve.functorPushforward G S) ↔ ∃ T, CategoryTheory.Sieve.functorPullback G ↑T = S
-- CategoryTheory.Functor.inducedTopology_sieves
@[simps]
def inducedTopology : GrothendieckTopology C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (G : CategoryTheory.Functor C D) (K : CategoryTheory.GrothendieckTopology D) [G.LocallyCoverDense K] [G.IsLocallyFull K] [G.IsLocallyFaithful K] (X : C) (S : CategoryTheory.Sieve X)
Goal: (G.inducedTopology K).sieves X S = K.sieves (G.obj X) (CategoryTheory.Sieve.functorPushforward G S)
-- CategoryTheory.Functor.inducedTopology_coverPreserving
theorem inducedTopology_coverPreserving : CoverPreserving (G.inducedTopology K) K G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (G : CategoryTheory.Functor C D) (K : CategoryTheory.GrothendieckTopology D) [G.LocallyCoverDense K] [G.IsLocallyFull K] [G.IsLocallyFaithful K]
Goal: CategoryTheory.CoverPreserving (G.inducedTopology K) K G
-- CategoryTheory.CoverPreserving.cover_preserve
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure CoverPreserving (G : C ⥤ D) : Prop where
  cover_preserve : ∀ {U : C} {S : Sieve U} (_ : S ∈ J U), S.functorPushforward G ∈ K (G.obj U)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} {G : C ⥤ D} (self : CategoryTheory.CoverPreserving J K G) {U : C} {S : CategoryTheory.Sieve U}
Goal: S ∈ J.sieves U → CategoryTheory.Sieve.functorPushforward G S ∈ K.sieves (G.obj U)
-- CategoryTheory.idCoverPreserving
theorem idCoverPreserving : CoverPreserving J J (𝟭 _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C)
Goal: CategoryTheory.CoverPreserving J J (𝟭 C)
-- CategoryTheory.CoverPreserving.comp
theorem CoverPreserving.comp {F} (hF : CoverPreserving J K F) {G} (hG : CoverPreserving K L G) :
    CoverPreserving J L (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) {L : CategoryTheory.GrothendieckTopology A} {F : C ⥤ D} (hF : CategoryTheory.CoverPreserving J K F) {G : D ⥤ A} (hG : CategoryTheory.CoverPreserving K L G)
Goal: CategoryTheory.CoverPreserving J L (F ⋙ G)
-- CategoryTheory.CompatiblePreserving.compatible
-- Porting note(#5171): linter not ported yet @[nolint has_nonempty_instance]
structure CompatiblePreserving (K : GrothendieckTopology D) (G : C ⥤ D) : Prop where
  compatible :
    ∀ (ℱ : SheafOfTypes.{w} K) {Z} {T : Presieve Z} {x : FamilyOfElements (G.op ⋙ ℱ.val) T}
      (_ : x.Compatible) {Y₁ Y₂} {X} (f₁ : X ⟶ G.obj Y₁) (f₂ : X ⟶ G.obj Y₂) {g₁ : Y₁ ⟶ Z}
      {g₂ : Y₂ ⟶ Z} (hg₁ : T g₁) (hg₂ : T g₂) (_ : f₁ ≫ G.map g₁ = f₂ ≫ G.map g₂),
      ℱ.val.map f₁.op (x g₁ hg₁) = ℱ.val.map f₂.op (x g₂ hg₂)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {K : CategoryTheory.GrothendieckTopology D} {G : C ⥤ D} (self : CategoryTheory.CompatiblePreserving K G) (ℱ : CategoryTheory.SheafOfTypes K) {Z : C} {T : CategoryTheory.Presieve Z} {x : CategoryTheory.Presieve.FamilyOfElements (G.op ⋙ ℱ.val) T}
Goal: x.Compatible →
  ∀ {Y₁ Y₂ : C} {X : D} (f₁ : X ⟶ G.obj Y₁) (f₂ : X ⟶ G.obj Y₂) {g₁ : Y₁ ⟶ Z} {g₂ : Y₂ ⟶ Z} (hg₁ : T g₁) (hg₂ : T g₂),
    f₁ ≫ G.map g₁ = f₂ ≫ G.map g₂ → ℱ.val.map f₁.op (x g₁ hg₁) = ℱ.val.map f₂.op (x g₂ hg₂)
-- CategoryTheory.Presieve.FamilyOfElements.Compatible.functorPushforward
theorem Presieve.FamilyOfElements.Compatible.functorPushforward :
    (x.functorPushforward G).Compatible 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {K : CategoryTheory.GrothendieckTopology D} {G : C ⥤ D} (hG : CategoryTheory.CompatiblePreserving K G) (ℱ : CategoryTheory.SheafOfTypes K) {Z : C} {T : CategoryTheory.Presieve Z} {x : CategoryTheory.Presieve.FamilyOfElements (G.op ⋙ ℱ.val) T} (h : x.Compatible)
Goal: (CategoryTheory.Presieve.FamilyOfElements.functorPushforward G x).Compatible
-- CategoryTheory.CompatiblePreserving.apply_map
@[simp]
theorem CompatiblePreserving.apply_map {Y : C} {f : Y ⟶ Z} (hf : T f) :
    x.functorPushforward G (G.map f) (image_mem_functorPushforward G T hf) = x f hf 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {K : CategoryTheory.GrothendieckTopology D} {G : C ⥤ D} (hG : CategoryTheory.CompatiblePreserving K G) (ℱ : CategoryTheory.SheafOfTypes K) {Z : C} {T : CategoryTheory.Presieve Z} {x : CategoryTheory.Presieve.FamilyOfElements (G.op ⋙ ℱ.val) T} (h : x.Compatible) {Y : C} {f : Y ⟶ Z} (hf : T f)
Goal: CategoryTheory.Presieve.FamilyOfElements.functorPushforward G x (G.map f) ⋯ = x f hf
-- CategoryTheory.compatiblePreservingOfFlat
theorem compatiblePreservingOfFlat {C : Type u₁} [Category.{v₁} C] {D : Type u₁} [Category.{v₁} D]
    (K : GrothendieckTopology D) (G : C ⥤ D) [RepresentablyFlat G] : CompatiblePreserving K G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (K : CategoryTheory.GrothendieckTopology D) (G : C ⥤ D) [CategoryTheory.RepresentablyFlat G]
Goal: CategoryTheory.CompatiblePreserving K G
-- CategoryTheory.compatiblePreservingOfDownwardsClosed
theorem compatiblePreservingOfDownwardsClosed (F : C ⥤ D) [F.Full] [F.Faithful]
    (hF : ∀ {c : C} {d : D} (_ : d ⟶ F.obj c), Σc', F.obj c' ≅ d) : CompatiblePreserving K F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {K : CategoryTheory.GrothendieckTopology D} (F : C ⥤ D) [F.Full] [F.Faithful] (hF : {c : C} → {d : D} → (d ⟶ F.obj c) → (c' : C) × (F.obj c' ≅ d))
Goal: CategoryTheory.CompatiblePreserving K F
-- CategoryTheory.Functor.isContinuous_of_coverPreserving
lemma Functor.isContinuous_of_coverPreserving (hF₁ : CompatiblePreserving.{w} K F)
    (hF₂ : CoverPreserving J K F) : Functor.IsContinuous.{w} F J K 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C ⥤ D} {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} (hF₁ : CategoryTheory.CompatiblePreserving K F) (hF₂ : CategoryTheory.CoverPreserving J K F)
Goal: F.IsContinuous J K
-- CategoryTheory.PreOneHypercover.w
structure PreOneHypercover (S : C) where
    I₀ : Type w
    X (i : I₀) : C
    f (i : I₀) : X i ⟶ S
    I₁ (i₁ i₂ : I₀) : Type w
    Y ⦃i₁ i₂ : I₀⦄ (j : I₁ i₁ i₂) : C
    p₁ ⦃i₁ i₂ : I₀⦄ (j : I₁ i₁ i₂) : Y j ⟶ X i₁
    p₂ ⦃i₁ i₂ : I₀⦄ (j : I₁ i₁ i₂) : Y j ⟶ X i₂
  w ⦃i₁ i₂ : I₀⦄ (j : I₁ i₁ i₂) : p₁ j ≫ f i₁ = p₂ j ≫ f i₂
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (self : CategoryTheory.PreOneHypercover S) ⦃i₁ i₂ : self.I₀⦄ (j : self.I₁ i₁ i₂)
Goal: CategoryTheory.CategoryStruct.comp (self.p₁ j) (self.f i₁) = CategoryTheory.CategoryStruct.comp (self.p₂ j) (self.f i₂)
-- CategoryTheory.PreOneHypercover.sieve₁_apply
@[simps]
def sieve₁ {i₁ i₂ : E.I₀} {W : C} (p₁ : W ⟶ E.X i₁) (p₂ : W ⟶ E.X i₂) : Sieve W 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S) {i₁ i₂ : E.I₀} {W : C} (p₁ : W ⟶ E.X i₁) (p₂ : W ⟶ E.X i₂) (Z : C) (g : Z ⟶ W)
Goal: (E.sieve₁ p₁ p₂).arrows g =
  ∃ j h,
    CategoryTheory.CategoryStruct.comp g p₁ = CategoryTheory.CategoryStruct.comp h (E.p₁ j) ∧
      CategoryTheory.CategoryStruct.comp g p₂ = CategoryTheory.CategoryStruct.comp h (E.p₂ j)
-- CategoryTheory.PreOneHypercover.sieve₁_eq_pullback_sieve₁'
lemma sieve₁_eq_pullback_sieve₁' {W : C} (p₁ : W ⟶ E.X i₁) (p₂ : W ⟶ E.X i₂)
    (w : p₁ ≫ E.f i₁ = p₂ ≫ E.f i₂) :
    E.sieve₁ p₁ p₂ = (E.sieve₁' i₁ i₂).pullback (pullback.lift _ _ w) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S) {i₁ i₂ : E.I₀} [CategoryTheory.Limits.HasPullback (E.f i₁) (E.f i₂)] {W : C} (p₁ : W ⟶ E.X i₁) (p₂ : W ⟶ E.X i₂) (w : CategoryTheory.CategoryStruct.comp p₁ (E.f i₁) = CategoryTheory.CategoryStruct.comp p₂ (E.f i₂))
Goal: E.sieve₁ p₁ p₂ = CategoryTheory.Sieve.pullback (CategoryTheory.Limits.pullback.lift p₁ p₂ w) (E.sieve₁' i₁ i₂)
-- CategoryTheory.PreOneHypercover.sieve₁'_eq_sieve₁
lemma sieve₁'_eq_sieve₁ : E.sieve₁' i₁ i₂ = E.sieve₁ (pullback.fst _ _) (pullback.snd _ _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S) (i₁ i₂ : E.I₀) [CategoryTheory.Limits.HasPullback (E.f i₁) (E.f i₂)]
Goal: E.sieve₁' i₁ i₂ =
  E.sieve₁ (CategoryTheory.Limits.pullback.fst (E.f i₁) (E.f i₂)) (CategoryTheory.Limits.pullback.snd (E.f i₁) (E.f i₂))
-- CategoryTheory.PreOneHypercover.multicospanIndex_right
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (j : E.I₁')
Goal: (E.multicospanIndex F).right j = F.obj (Opposite.op (E.Y j.snd))
-- CategoryTheory.PreOneHypercover.multicospanIndex_fst
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (j : E.I₁')
Goal: (E.multicospanIndex F).fst j = F.map (E.p₁ j.snd).op
-- CategoryTheory.PreOneHypercover.multicospanIndex_snd
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (j : E.I₁')
Goal: (E.multicospanIndex F).snd j = F.map (E.p₂ j.snd).op
-- CategoryTheory.PreOneHypercover.multicospanIndex_sndTo
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (j : E.I₁')
Goal: (E.multicospanIndex F).sndTo j = j.fst.2
-- CategoryTheory.PreOneHypercover.multicospanIndex_L
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A)
Goal: (E.multicospanIndex F).L = E.I₀
-- CategoryTheory.PreOneHypercover.multicospanIndex_left
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (i : E.I₀)
Goal: (E.multicospanIndex F).left i = F.obj (Opposite.op (E.X i))
-- CategoryTheory.PreOneHypercover.multicospanIndex_fstTo
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (j : E.I₁')
Goal: (E.multicospanIndex F).fstTo j = j.fst.1
-- CategoryTheory.PreOneHypercover.multicospanIndex_R
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A)
Goal: (E.multicospanIndex F).R = E.I₁'
-- CategoryTheory.GrothendieckTopology.OneHypercover.mem₀
structure OneHypercover (S : C) extends PreOneHypercover.{w} S where
  mem₀ : toPreOneHypercover.sieve₀ ∈ J S
  mem₁ (i₁ i₂ : I₀) ⦃W : C⦄ (p₁ : W ⟶ X i₁) (p₂ : W ⟶ X i₂) (w : p₁ ≫ f i₁ = p₂ ≫ f i₂) :
    toPreOneHypercover.sieve₁ p₁ p₂ ∈ J W
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (self : J.OneHypercover S)
Goal: self.sieve₀ ∈ J.sieves S
-- CategoryTheory.GrothendieckTopology.OneHypercover.mem₁
structure OneHypercover (S : C) extends PreOneHypercover.{w} S where
  mem₀ : toPreOneHypercover.sieve₀ ∈ J S
  mem₁ (i₁ i₂ : I₀) ⦃W : C⦄ (p₁ : W ⟶ X i₁) (p₂ : W ⟶ X i₂) (w : p₁ ≫ f i₁ = p₂ ≫ f i₂) :
    toPreOneHypercover.sieve₁ p₁ p₂ ∈ J W
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (self : J.OneHypercover S) (i₁ i₂ : self.I₀) ⦃W : C⦄ (p₁ : W ⟶ self.X i₁) (p₂ : W ⟶ self.X i₂) (w : CategoryTheory.CategoryStruct.comp p₁ (self.f i₁) = CategoryTheory.CategoryStruct.comp p₂ (self.f i₂))
Goal: self.sieve₁ p₁ p₂ ∈ J.sieves W
-- CategoryTheory.GrothendieckTopology.OneHypercover.mem_sieve₁'
lemma OneHypercover.mem_sieve₁' {S : C} (E : J.OneHypercover S)
    (i₁ i₂ : E.I₀) [HasPullback (E.f i₁) (E.f i₂)] :
    E.sieve₁' i₁ i₂ ∈ J _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : J.OneHypercover S) (i₁ i₂ : E.I₀) [CategoryTheory.Limits.HasPullback (E.f i₁) (E.f i₂)]
Goal: E.sieve₁' i₁ i₂ ∈ J.sieves (CategoryTheory.Limits.pullback (E.f i₁) (E.f i₂))
-- CategoryTheory.GrothendieckTopology.OneHypercover.mk'_toPreOneHypercover
@[simps toPreOneHypercover]
def mk' {S : C} (E : PreOneHypercover S) [E.HasPullbacks]
    (mem₀ : E.sieve₀ ∈ J S) (mem₁' : ∀ (i₁ i₂ : E.I₀), E.sieve₁' i₁ i₂ ∈ J _) :
    J.OneHypercover S 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : CategoryTheory.PreOneHypercover S) [E.HasPullbacks] (mem₀ : E.sieve₀ ∈ J.sieves S) (mem₁' : ∀ (i₁ i₂ : E.I₀), E.sieve₁' i₁ i₂ ∈ J.sieves (CategoryTheory.Limits.pullback (E.f i₁) (E.f i₂)))
Goal: (CategoryTheory.GrothendieckTopology.OneHypercover.mk' E mem₀ mem₁').toPreOneHypercover = E
-- CategoryTheory.GrothendieckTopology.OneHypercover.multiforkLift_map
@[reassoc]
lemma multiforkLift_map (i₀ : E.I₀) : multiforkLift c ≫ F.val.map (E.f i₀).op = c.ι i₀ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{u_3, u_1} A] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E : J.OneHypercover S} {F : CategoryTheory.Sheaf J A} (c : CategoryTheory.Limits.Multifork (E.multicospanIndex F.val)) (i₀ : E.I₀)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.OneHypercover.multiforkLift c)
    (F.val.map (E.f i₀).op) =
  c.ι i₀
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_Y
@[simps]
def preOneHypercover : PreOneHypercover.{max u v} X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X)
Goal: ∀ (x x_1 : S.Arrow) (r : x.Relation x_1), S.preOneHypercover.Y r = r.Z
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_I₀
@[simps]
def preOneHypercover : PreOneHypercover.{max u v} X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X)
Goal: S.preOneHypercover.I₀ = S.Arrow
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_p₂
@[simps]
def preOneHypercover : PreOneHypercover.{max u v} X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X)
Goal: ∀ (x x_1 : S.Arrow) (r : x.Relation x_1), S.preOneHypercover.p₂ r = r.g₂
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_I₁
@[simps]
def preOneHypercover : PreOneHypercover.{max u v} X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X) (f₁ f₂ : S.Arrow)
Goal: S.preOneHypercover.I₁ f₁ f₂ = f₁.Relation f₂
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_p₁
@[simps]
def preOneHypercover : PreOneHypercover.{max u v} X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X)
Goal: ∀ (x x_1 : S.Arrow) (r : x.Relation x_1), S.preOneHypercover.p₁ r = r.g₁
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_X
@[simps]
def preOneHypercover : PreOneHypercover.{max u v} X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X) (f : S.Arrow)
Goal: S.preOneHypercover.X f = f.Y
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_f
@[simps]
def preOneHypercover : PreOneHypercover.{max u v} X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X) (f : S.Arrow)
Goal: S.preOneHypercover.f f = f.f
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_sieve₀
@[simp]
lemma preOneHypercover_sieve₀ : S.preOneHypercover.sieve₀ = S.1 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X)
Goal: S.preOneHypercover.sieve₀ = ↑S
-- CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_sieve₁
lemma preOneHypercover_sieve₁ (f₁ f₂ : S.Arrow) {W : C} (p₁ : W ⟶ f₁.Y) (p₂ : W ⟶ f₂.Y)
    (w : p₁ ≫ f₁.f = p₂ ≫ f₂.f) :
    S.preOneHypercover.sieve₁ p₁ p₂ = ⊤ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X) (f₁ f₂ : S.Arrow) {W : C} (p₁ : W ⟶ f₁.Y) (p₂ : W ⟶ f₂.Y) (w : CategoryTheory.CategoryStruct.comp p₁ f₁.f = CategoryTheory.CategoryStruct.comp p₂ f₂.f)
Goal: S.preOneHypercover.sieve₁ p₁ p₂ = ⊤
-- CategoryTheory.GrothendieckTopology.Cover.oneHypercover_toPreOneHypercover
@[simps toPreOneHypercover]
def oneHypercover : J.OneHypercover X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X)
Goal: S.oneHypercover.toPreOneHypercover = S.preOneHypercover
-- CategoryTheory.HasSheafify.isRightAdjoint
class HasSheafify : Prop where
  isRightAdjoint : HasWeakSheafify J A
  isLeftExact : Nonempty (PreservesFiniteLimits ((sheafToPresheaf J A).leftAdjoint))
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [self : CategoryTheory.HasSheafify J A]
Goal: CategoryTheory.HasWeakSheafify J A
-- CategoryTheory.HasSheafify.isLeftExact
class HasSheafify : Prop where
  isRightAdjoint : HasWeakSheafify J A
  isLeftExact : Nonempty (PreservesFiniteLimits ((sheafToPresheaf J A).leftAdjoint))
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [self : CategoryTheory.HasSheafify J A]
Goal: Nonempty (CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.sheafToPresheaf J A).leftAdjoint)
-- CategoryTheory.HasSheafify.mk'
theorem HasSheafify.mk' {F : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A} (adj : F ⊣ sheafToPresheaf J A)
    [PreservesFiniteLimits F] : HasSheafify J A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] {F : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A)} (adj : F ⊣ CategoryTheory.sheafToPresheaf J A) [CategoryTheory.Limits.PreservesFiniteLimits F]
Goal: CategoryTheory.HasSheafify J A
-- CategoryTheory.sheafificationAdjunction_unit_app
@[simp]
theorem sheafificationAdjunction_unit_app (P : Cᵒᵖ ⥤ D) :
    (sheafificationAdjunction J D).unit.app P = toSheafify J P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.HasWeakSheafify J D] (P : CategoryTheory.Functor Cᵒᵖ D)
Goal: (CategoryTheory.sheafificationAdjunction J D).unit.app P = CategoryTheory.toSheafify J P
-- CategoryTheory.sheafifyMap_id
@[simp]
theorem sheafifyMap_id (P : Cᵒᵖ ⥤ D) : sheafifyMap J (𝟙 P) = 𝟙 (sheafify J P) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.HasWeakSheafify J D] (P : CategoryTheory.Functor Cᵒᵖ D)
Goal: CategoryTheory.sheafifyMap J (CategoryTheory.CategoryStruct.id P) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.sheafify J P)