ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.PreOneHypercover.map_I₁
@[simps]
def map : PreOneHypercover (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (i₁ i₂ : E.I₀)
Goal: (E.map F).I₁ i₁ i₂ = E.I₁ i₁ i₂
-- CategoryTheory.GrothendieckTopology.OneHypercover.IsPreservedBy.mem₁
class IsPreservedBy (F : C ⥤ D) (K : GrothendieckTopology D) : Prop where
  mem₀ : (E.toPreOneHypercover.map F).sieve₀ ∈ K (F.obj X)
  mem₁ (i₁ i₂ : E.I₀) ⦃W : D⦄ (p₁ : W ⟶ F.obj (E.X i₁)) (p₂ : W ⟶ F.obj (E.X i₂))
    (w : p₁ ≫ F.map (E.f i₁) = p₂ ≫ F.map (E.f i₂)) :
      (E.toPreOneHypercover.map F).sieve₁ p₁ p₂ ∈ K W
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : CategoryTheory.GrothendieckTopology C} {X : C} {E : J.OneHypercover X} {F : CategoryTheory.Functor C D} {K : CategoryTheory.GrothendieckTopology D} [self : E.IsPreservedBy F K] (i₁ i₂ : E.I₀) ⦃W : D⦄ (p₁ : W ⟶ F.obj (E.X i₁)) (p₂ : W ⟶ F.obj (E.X i₂)) (w : CategoryTheory.CategoryStruct.comp p₁ (F.map (E.f i₁)) = CategoryTheory.CategoryStruct.comp p₂ (F.map (E.f i₂)))
Goal: (E.map F).sieve₁ p₁ p₂ ∈ K.sieves W
-- CategoryTheory.GrothendieckTopology.OneHypercover.IsPreservedBy.mem₀
class IsPreservedBy (F : C ⥤ D) (K : GrothendieckTopology D) : Prop where
  mem₀ : (E.toPreOneHypercover.map F).sieve₀ ∈ K (F.obj X)
  mem₁ (i₁ i₂ : E.I₀) ⦃W : D⦄ (p₁ : W ⟶ F.obj (E.X i₁)) (p₂ : W ⟶ F.obj (E.X i₂))
    (w : p₁ ≫ F.map (E.f i₁) = p₂ ≫ F.map (E.f i₂)) :
      (E.toPreOneHypercover.map F).sieve₁ p₁ p₂ ∈ K W
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : CategoryTheory.GrothendieckTopology C} {X : C} {E : J.OneHypercover X} {F : CategoryTheory.Functor C D} {K : CategoryTheory.GrothendieckTopology D} [self : E.IsPreservedBy F K]
Goal: (E.map F).sieve₀ ∈ K.sieves (F.obj X)
-- CategoryTheory.GrothendieckTopology.OneHypercover.map_toPreOneHypercover
@[simps toPreOneHypercover]
def map (F : C ⥤ D) (K : GrothendieckTopology D) [E.IsPreservedBy F K] :
    K.OneHypercover (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : CategoryTheory.GrothendieckTopology C} {X : C} (E : J.OneHypercover X) (F : CategoryTheory.Functor C D) (K : CategoryTheory.GrothendieckTopology D) [E.IsPreservedBy F K]
Goal: (E.map F K).toPreOneHypercover = E.map F
-- CategoryTheory.Functor.IsContinuous.op_comp_isSheafOfTypes
class IsContinuous : Prop where
  op_comp_isSheafOfTypes (G : SheafOfTypes.{t} K) : Presieve.IsSheaf J (F.op ⋙ G.val)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [self : F.IsContinuous J K] (G : CategoryTheory.SheafOfTypes K)
Goal: CategoryTheory.Presieve.IsSheaf J (F.op.comp G.val)
-- CategoryTheory.Functor.op_comp_isSheafOfTypes
lemma op_comp_isSheafOfTypes [Functor.IsContinuous.{t} F J K] (G : SheafOfTypes.{t} K) :
    Presieve.IsSheaf J (F.op ⋙ G.val) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.IsContinuous J K] (G : CategoryTheory.SheafOfTypes K)
Goal: CategoryTheory.Presieve.IsSheaf J (F.op.comp G.val)
-- CategoryTheory.Functor.op_comp_isSheaf
lemma op_comp_isSheaf [Functor.IsContinuous.{t} F J K] (G : Sheaf K A) :
    Presheaf.IsSheaf J (F.op ⋙ G.val) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {A : Type u} [CategoryTheory.Category.{t, u} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.IsContinuous J K] (G : CategoryTheory.Sheaf K A)
Goal: CategoryTheory.Presheaf.IsSheaf J (F.op.comp G.val)
-- CategoryTheory.Functor.isContinuous_of_iso
lemma isContinuous_of_iso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂)
    (J : GrothendieckTopology C) (K : GrothendieckTopology D)
    [Functor.IsContinuous.{t} F₁ J K] : Functor.IsContinuous.{t} F₂ J K 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F₁ F₂ : CategoryTheory.Functor C D} (e : F₁ ≅ F₂) (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F₁.IsContinuous J K]
Goal: F₂.IsContinuous J K
-- CategoryTheory.Functor.isContinuous_comp
lemma isContinuous_comp (F₁ : C ⥤ D) (F₂ : D ⥤ E) (J : GrothendieckTopology C)
    (K : GrothendieckTopology D) (L : GrothendieckTopology E)
    [Functor.IsContinuous.{t} F₁ J K] [Functor.IsContinuous.{t} F₂ K L] :
    Functor.IsContinuous.{t} (F₁ ⋙ F₂) J L 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F₁ : CategoryTheory.Functor C D) (F₂ : CategoryTheory.Functor D E) (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) (L : CategoryTheory.GrothendieckTopology E) [F₁.IsContinuous J K] [F₂.IsContinuous K L]
Goal: (F₁.comp F₂).IsContinuous J L
-- CategoryTheory.Functor.isContinuous_comp'
lemma isContinuous_comp' {F₁ : C ⥤ D} {F₂ : D ⥤ E} {F₁₂ : C ⥤ E}
    (e : F₁ ⋙ F₂ ≅ F₁₂) (J : GrothendieckTopology C)
    (K : GrothendieckTopology D) (L : GrothendieckTopology E)
    [Functor.IsContinuous.{t} F₁ J K] [Functor.IsContinuous.{t} F₂ K L] :
    Functor.IsContinuous.{t} F₁₂ J L 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F₁ : CategoryTheory.Functor C D} {F₂ : CategoryTheory.Functor D E} {F₁₂ : CategoryTheory.Functor C E} (e : F₁.comp F₂ ≅ F₁₂) (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) (L : CategoryTheory.GrothendieckTopology E) [F₁.IsContinuous J K] [F₂.IsContinuous K L]
Goal: F₁₂.IsContinuous J L
-- CategoryTheory.Functor.op_comp_isSheaf_of_preservesOneHypercovers
lemma op_comp_isSheaf_of_preservesOneHypercovers
    [PreservesOneHypercovers.{w} F J K] [GrothendieckTopology.IsGeneratedByOneHypercovers.{w} J]
    (P : Dᵒᵖ ⥤ A) (hP : Presheaf.IsSheaf K P) :
    Presheaf.IsSheaf J (F.op ⋙ P) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {A : Type u} [CategoryTheory.Category.{t, u} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.PreservesOneHypercovers J K] [J.IsGeneratedByOneHypercovers] (P : CategoryTheory.Functor Dᵒᵖ A) (hP : CategoryTheory.Presheaf.IsSheaf K P)
Goal: CategoryTheory.Presheaf.IsSheaf J (F.op.comp P)
-- CategoryTheory.Functor.isContinuous_of_preservesOneHypercovers
lemma isContinuous_of_preservesOneHypercovers
    [PreservesOneHypercovers.{w} F J K] [GrothendieckTopology.IsGeneratedByOneHypercovers.{w} J] :
    IsContinuous.{t} F J K 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.PreservesOneHypercovers J K] [J.IsGeneratedByOneHypercovers]
Goal: F.IsContinuous J K
-- CategoryTheory.Functor.sheafPushforwardContinuous_obj_val_obj
@[simps!]
def sheafPushforwardContinuous : Sheaf K A ⥤ Sheaf J A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (A : Type u) [CategoryTheory.Category.{t, u} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.IsContinuous J K] (ℱ : CategoryTheory.Sheaf K A) (X : Cᵒᵖ)
Goal: ((F.sheafPushforwardContinuous A J K).obj ℱ).val.obj X = ℱ.val.obj (Opposite.op (F.obj (Opposite.unop X)))
-- CategoryTheory.Functor.sheafPushforwardContinuous_obj_val_map
@[simps!]
def sheafPushforwardContinuous : Sheaf K A ⥤ Sheaf J A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (A : Type u) [CategoryTheory.Category.{t, u} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.IsContinuous J K] (ℱ : CategoryTheory.Sheaf K A)
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), ((F.sheafPushforwardContinuous A J K).obj ℱ).val.map f = ℱ.val.map (F.map f.unop).op
-- CategoryTheory.Functor.sheafPushforwardContinuous_map_val_app
@[simps!]
def sheafPushforwardContinuous : Sheaf K A ⥤ Sheaf J A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (A : Type u) [CategoryTheory.Category.{t, u} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.IsContinuous J K]
Goal: ∀ {X Y : CategoryTheory.Sheaf K A} (f : X ⟶ Y) (X_1 : Cᵒᵖ),
  ((F.sheafPushforwardContinuous A J K).map f).val.app X_1 = f.val.app (Opposite.op (F.obj (Opposite.unop X_1)))
-- CategoryTheory.Functor.sheafPushforwardContinuousCompSheafToPresheafIso_inv_app_app
@[simps!]
def sheafPushforwardContinuousCompSheafToPresheafIso :
    F.sheafPushforwardContinuous A J K ⋙ sheafToPresheaf J A ≅
      sheafToPresheaf K A ⋙ (whiskeringLeft _ _ _).obj F.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (A : Type u) [CategoryTheory.Category.{t, u} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.IsContinuous J K] (X : CategoryTheory.Sheaf K A)
Goal: ∀ (X_1 : Cᵒᵖ),
  ((F.sheafPushforwardContinuousCompSheafToPresheafIso A J K).inv.app X).app X_1 =
    CategoryTheory.CategoryStruct.id (X.val.obj (Opposite.op (F.obj (Opposite.unop X_1))))
-- CategoryTheory.Functor.sheafPushforwardContinuousCompSheafToPresheafIso_hom_app_app
@[simps!]
def sheafPushforwardContinuousCompSheafToPresheafIso :
    F.sheafPushforwardContinuous A J K ⋙ sheafToPresheaf J A ≅
      sheafToPresheaf K A ⋙ (whiskeringLeft _ _ _).obj F.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (A : Type u) [CategoryTheory.Category.{t, u} A] (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [F.IsContinuous J K] (X : CategoryTheory.Sheaf K A)
Goal: ∀ (X_1 : Cᵒᵖ),
  ((F.sheafPushforwardContinuousCompSheafToPresheafIso A J K).hom.app X).app X_1 =
    CategoryTheory.CategoryStruct.id (X.val.obj (Opposite.op (F.obj (Opposite.unop X_1))))
-- CategoryTheory.Functor.imageSieve_map
@[simp]
lemma Functor.imageSieve_map {U V : C} (f : U ⟶ V) : G.imageSieve (G.map f) = ⊤ 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {D : Type uD} [CategoryTheory.Category.{vD, uD} D] (G : CategoryTheory.Functor C D) {U V : C} (f : U ⟶ V)
Goal: G.imageSieve (G.map f) = ⊤
-- CategoryTheory.Sieve.equalizer_apply
@[simps]
def Sieve.equalizer {U V : C} (f₁ f₂ : U ⟶ V) : Sieve U 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {U V : C} (f₁ f₂ : U ⟶ V) (Y : C) (i : Y ⟶ U)
Goal: (CategoryTheory.Sieve.equalizer f₁ f₂).arrows i =
  (CategoryTheory.CategoryStruct.comp i f₁ = CategoryTheory.CategoryStruct.comp i f₂)
-- CategoryTheory.Sieve.equalizer_self
@[simp]
lemma Sieve.equalizer_self {U V : C} (f : U ⟶ V) : equalizer f f = ⊤ 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {U V : C} (f : U ⟶ V)
Goal: CategoryTheory.Sieve.equalizer f f = ⊤
-- CategoryTheory.Sieve.equalizer_eq_equalizerSieve
lemma Sieve.equalizer_eq_equalizerSieve {U V : C} (f₁ f₂ : U ⟶ V) :
    Sieve.equalizer f₁ f₂ = Presheaf.equalizerSieve (F := yoneda.obj _) f₁ f₂ 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {U V : C} (f₁ f₂ : U ⟶ V)
Goal: CategoryTheory.Sieve.equalizer f₁ f₂ = CategoryTheory.Presheaf.equalizerSieve f₁ f₂
-- CategoryTheory.Functor.imageSieve_eq_imageSieve
lemma Functor.imageSieve_eq_imageSieve {D : Type uD} [Category.{vC} D] (G : C ⥤ D) {U V : C}
    (f : G.obj U ⟶ G.obj V) :
    G.imageSieve f = Presheaf.imageSieve (yonedaMap G V) f 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {D : Type uD} [CategoryTheory.Category.{vC, uD} D] (G : CategoryTheory.Functor C D) {U V : C} (f : G.obj U ⟶ G.obj V)
Goal: G.imageSieve f = CategoryTheory.Presheaf.imageSieve (CategoryTheory.yonedaMap G V) f
-- CategoryTheory.Functor.IsLocallyFull.functorPushforward_imageSieve_mem
class IsLocallyFull : Prop where
  functorPushforward_imageSieve_mem : ∀ {U V} (f : G.obj U ⟶ G.obj V),
    (G.imageSieve f).functorPushforward G ∈ K _
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {D : Type uD} [CategoryTheory.Category.{vD, uD} D] {G : CategoryTheory.Functor C D} {K : CategoryTheory.GrothendieckTopology D} [self : G.IsLocallyFull K] {U V : C} (f : G.obj U ⟶ G.obj V)
Goal: CategoryTheory.Sieve.functorPushforward G (G.imageSieve f) ∈ K.sieves (G.obj U)
-- CategoryTheory.Functor.IsLocallyFaithful.functorPushforward_equalizer_mem
class IsLocallyFaithful : Prop where
  functorPushforward_equalizer_mem : ∀ {U V : C} (f₁ f₂ : U ⟶ V), G.map f₁ = G.map f₂ →
    (Sieve.equalizer f₁ f₂).functorPushforward G ∈ K _
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {D : Type uD} [CategoryTheory.Category.{vD, uD} D] {G : CategoryTheory.Functor C D} {K : CategoryTheory.GrothendieckTopology D} [self : G.IsLocallyFaithful K] {U V : C} (f₁ f₂ : U ⟶ V)
Goal: G.map f₁ = G.map f₂ →
  CategoryTheory.Sieve.functorPushforward G (CategoryTheory.Sieve.equalizer f₁ f₂) ∈ K.sieves (G.obj U)
-- CategoryTheory.Functor.functorPushforward_imageSieve_mem
lemma functorPushforward_imageSieve_mem [G.IsLocallyFull K] {U V} (f : G.obj U ⟶ G.obj V) :
    (G.imageSieve f).functorPushforward G ∈ K _ 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {D : Type uD} [CategoryTheory.Category.{vD, uD} D] (G : CategoryTheory.Functor C D) (K : CategoryTheory.GrothendieckTopology D) [G.IsLocallyFull K] {U V : C} (f : G.obj U ⟶ G.obj V)
Goal: CategoryTheory.Sieve.functorPushforward G (G.imageSieve f) ∈ K.sieves (G.obj U)
-- CategoryTheory.Functor.functorPushforward_equalizer_mem
lemma functorPushforward_equalizer_mem
    [G.IsLocallyFaithful K] {U V} (f₁ f₂ : U ⟶ V) (e : G.map f₁ = G.map f₂) :
      (Sieve.equalizer f₁ f₂).functorPushforward G ∈ K _ 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {D : Type uD} [CategoryTheory.Category.{vD, uD} D] (G : CategoryTheory.Functor C D) (K : CategoryTheory.GrothendieckTopology D) [G.IsLocallyFaithful K] {U V : C} (f₁ f₂ : U ⟶ V) (e : G.map f₁ = G.map f₂)
Goal: CategoryTheory.Sieve.functorPushforward G (CategoryTheory.Sieve.equalizer f₁ f₂) ∈ K.sieves (G.obj U)
-- CategoryTheory.Functor.IsLocallyFull.ext
theorem IsLocallyFull.ext [G.IsLocallyFull K]
    (ℱ : SheafOfTypes K) {X Y : C} (i : G.obj X ⟶ G.obj Y)
    {s t : ℱ.val.obj (op (G.obj X))}
    (h : ∀ ⦃Z : C⦄ (j : Z ⟶ X) (f : Z ⟶ Y), G.map f = G.map j ≫ i →
      ℱ.1.map (G.map j).op s = ℱ.1.map (G.map j).op t) : s = t 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {D : Type uD} [CategoryTheory.Category.{vD, uD} D] {K : CategoryTheory.GrothendieckTopology D} (G : CategoryTheory.Functor C D) [G.IsLocallyFull K] (ℱ : CategoryTheory.SheafOfTypes K) {X Y : C} (i : G.obj X ⟶ G.obj Y) {s t : ℱ.val.obj (Opposite.op (G.obj X))} (h :
  ∀ ⦃Z : C⦄ (j : Z ⟶ X) (f : Z ⟶ Y),
    G.map f = CategoryTheory.CategoryStruct.comp (G.map j) i → ℱ.val.map (G.map j).op s = ℱ.val.map (G.map j).op t)
Goal: s = t
-- CategoryTheory.Functor.IsLocallyFaithful.ext
theorem IsLocallyFaithful.ext [G.IsLocallyFaithful K] (ℱ : SheafOfTypes K)
    {X Y : C} (i₁ i₂ : X ⟶ Y) (e : G.map i₁ = G.map i₂)
    {s t : ℱ.val.obj (op (G.obj X))}
    (h : ∀ ⦃Z : C⦄ (j : Z ⟶ X), j ≫ i₁ = j ≫ i₂ →
      ℱ.1.map (G.map j).op s = ℱ.1.map (G.map j).op t) : s = t 
Arguments: {C : Type uC} [CategoryTheory.Category.{vC, uC} C] {D : Type uD} [CategoryTheory.Category.{vD, uD} D] {K : CategoryTheory.GrothendieckTopology D} (G : CategoryTheory.Functor C D) [G.IsLocallyFaithful K] (ℱ : CategoryTheory.SheafOfTypes K) {X Y : C} (i₁ i₂ : X ⟶ Y) (e : G.map i₁ = G.map i₂) {s t : ℱ.val.obj (Opposite.op (G.obj X))} (h :
  ∀ ⦃Z : C⦄ (j : Z ⟶ X),
    CategoryTheory.CategoryStruct.comp j i₁ = CategoryTheory.CategoryStruct.comp j i₂ →
      ℱ.val.map (G.map j).op s = ℱ.val.map (G.map j).op t)
Goal: s = t
-- Opens.pretopology_ofGrothendieck
@[simp]
theorem pretopology_ofGrothendieck :
    Pretopology.ofGrothendieck _ (Opens.grothendieckTopology T) = Opens.pretopology T 
Arguments: (T : Type u) [TopologicalSpace T]
Goal: CategoryTheory.Pretopology.ofGrothendieck (TopologicalSpace.Opens T) (Opens.grothendieckTopology T) =
  Opens.pretopology T
-- Opens.pretopology_toGrothendieck
@[simp]
theorem pretopology_toGrothendieck :
    Pretopology.toGrothendieck _ (Opens.pretopology T) = Opens.grothendieckTopology T 
Arguments: (T : Type u) [TopologicalSpace T]
Goal: CategoryTheory.Pretopology.toGrothendieck (TopologicalSpace.Opens T) (Opens.pretopology T) =
  Opens.grothendieckTopology T
-- CategoryTheory.MonoOver.top_left
@[simp]
theorem top_left (X : C) : ((⊤ : MonoOver X) : C) = X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: ⊤.obj.left = X
-- CategoryTheory.MonoOver.top_arrow
@[simp]
theorem top_arrow (X : C) : (⊤ : MonoOver X).arrow = 𝟙 X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: ⊤.arrow = 𝟙 X
-- CategoryTheory.MonoOver.bot_left
@[simp]
theorem bot_left (X : C) : ((⊥ : MonoOver X) : C) = ⊥_ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.InitialMonoClass C] (X : C)
Goal: ⊥.obj.left = ⊥_ C
-- CategoryTheory.MonoOver.bot_arrow
@[simp]
theorem bot_arrow {X : C} : (⊥ : MonoOver X).arrow = initial.to X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.InitialMonoClass C] {X : C}
Goal: ⊥.arrow = CategoryTheory.Limits.initial.to X
-- CategoryTheory.MonoOver.bot_arrow_eq_zero
theorem bot_arrow_eq_zero [HasZeroMorphisms C] {B : C} : (⊥ : MonoOver B).arrow = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {B : C}
Goal: ⊥.arrow = 0
-- CategoryTheory.MonoOver.inf_map_app
@[simps]
def inf {A : C} : MonoOver A ⥤ MonoOver A ⥤ MonoOver A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A : C}
Goal: ∀ {X Y : CategoryTheory.MonoOver A} (k : X ⟶ Y) (g : CategoryTheory.MonoOver A),
  (CategoryTheory.MonoOver.inf.map k).app g =
    CategoryTheory.MonoOver.homMk
      (CategoryTheory.Limits.pullback.lift
        (CategoryTheory.Limits.pullback.fst ((CategoryTheory.MonoOver.forget A).obj g).hom X.arrow)
        (CategoryTheory.Limits.pullback.snd ((CategoryTheory.MonoOver.forget A).obj g).hom X.arrow ≫ k.left) ⋯)
      ⋯
-- CategoryTheory.MonoOver.inf_obj
@[simps]
def inf {A : C} : MonoOver A ⥤ MonoOver A ⥤ MonoOver A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A : C} (f : CategoryTheory.MonoOver A)
Goal: CategoryTheory.MonoOver.inf.obj f = CategoryTheory.MonoOver.pullback f.arrow ⋙ CategoryTheory.MonoOver.map f.arrow
-- CategoryTheory.Subobject.top_eq_id
theorem top_eq_id (B : C) : (⊤ : Subobject B) = Subobject.mk (𝟙 B) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (B : C)
Goal: ⊤ = CategoryTheory.Subobject.mk (𝟙 B)
-- CategoryTheory.Subobject.underlyingIso_top_hom
theorem underlyingIso_top_hom {B : C} : (underlyingIso (𝟙 B)).hom = (⊤ : Subobject B).arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C}
Goal: (CategoryTheory.Subobject.underlyingIso (𝟙 B)).hom = ⊤.arrow
-- CategoryTheory.Subobject.underlyingIso_inv_top_arrow
@[reassoc (attr := simp)]
theorem underlyingIso_inv_top_arrow {B : C} :
    (underlyingIso _).inv ≫ (⊤ : Subobject B).arrow = 𝟙 B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C}
Goal: (CategoryTheory.Subobject.underlyingIso (𝟙 B)).inv ≫ ⊤.arrow = 𝟙 B
-- CategoryTheory.Subobject.map_top
@[simp]
theorem map_top (f : X ⟶ Y) [Mono f] : (map f).obj ⊤ = Subobject.mk f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: (CategoryTheory.Subobject.map f).obj ⊤ = CategoryTheory.Subobject.mk f
-- CategoryTheory.Subobject.top_factors
theorem top_factors {A B : C} (f : A ⟶ B) : (⊤ : Subobject B).Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A B : C} (f : A ⟶ B)
Goal: ⊤.Factors f
-- CategoryTheory.Subobject.isIso_iff_mk_eq_top
theorem isIso_iff_mk_eq_top {X Y : C} (f : X ⟶ Y) [Mono f] : IsIso f ↔ mk f = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.IsIso f ↔ CategoryTheory.Subobject.mk f = ⊤
-- CategoryTheory.Subobject.isIso_arrow_iff_eq_top
theorem isIso_arrow_iff_eq_top {Y : C} (P : Subobject Y) : IsIso P.arrow ↔ P = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Y : C} (P : CategoryTheory.Subobject Y)
Goal: CategoryTheory.IsIso P.arrow ↔ P = ⊤
-- CategoryTheory.Subobject.mk_eq_top_of_isIso
theorem mk_eq_top_of_isIso {X Y : C} (f : X ⟶ Y) [IsIso f] : mk f = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: CategoryTheory.Subobject.mk f = ⊤
-- CategoryTheory.Subobject.eq_top_of_isIso_arrow
theorem eq_top_of_isIso_arrow {Y : C} (P : Subobject Y) [IsIso P.arrow] : P = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Y : C} (P : CategoryTheory.Subobject Y) [CategoryTheory.IsIso P.arrow]
Goal: P = ⊤
-- CategoryTheory.Subobject.pullback_top
theorem pullback_top (f : X ⟶ Y) : (pullback f).obj ⊤ = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] (f : X ⟶ Y)
Goal: (CategoryTheory.Subobject.pullback f).obj ⊤ = ⊤
-- CategoryTheory.Subobject.pullback_self
theorem pullback_self {A B : C} (f : A ⟶ B) [Mono f] : (pullback f).obj (mk f) = ⊤ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {A B : C} (f : A ⟶ B) [CategoryTheory.Mono f]
Goal: (CategoryTheory.Subobject.pullback f).obj (CategoryTheory.Subobject.mk f) = ⊤
-- CategoryTheory.Subobject.bot_eq_initial_to
theorem bot_eq_initial_to {B : C} : (⊥ : Subobject B) = Subobject.mk (initial.to B) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.InitialMonoClass C] {B : C}
Goal: ⊥ = CategoryTheory.Subobject.mk (CategoryTheory.Limits.initial.to B)
-- CategoryTheory.Subobject.map_bot
theorem map_bot (f : X ⟶ Y) [Mono f] : (map f).obj ⊥ = ⊥ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.InitialMonoClass C] (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: (CategoryTheory.Subobject.map f).obj ⊥ = ⊥
-- CategoryTheory.Subobject.bot_eq_zero
theorem bot_eq_zero {B : C} : (⊥ : Subobject B) = Subobject.mk (0 : 0 ⟶ B) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {B : C}
Goal: ⊥ = CategoryTheory.Subobject.mk 0
-- CategoryTheory.Subobject.bot_arrow
@[simp]
theorem bot_arrow {B : C} : (⊥ : Subobject B).arrow = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {B : C}
Goal: ⊥.arrow = 0