ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LocallyFinite.sum_elim
theorem LocallyFinite.sum_elim {g : ι' → Set X} (hf : LocallyFinite f) (hg : LocallyFinite g) :
    LocallyFinite (Sum.elim f g) 
Arguments: {ι : Type u_1} {ι' : Type u_2} {X : Type u_4} [TopologicalSpace X] {f : ι → Set X} {g : ι' → Set X} (hf : LocallyFinite f) (hg : LocallyFinite g)
Goal: LocallyFinite (Sum.elim f g)
-- locallyFinite_option
theorem locallyFinite_option {f : Option ι → Set X} :
    LocallyFinite f ↔ LocallyFinite (f ∘ some) 
Arguments: {ι : Type u_1} {X : Type u_4} [TopologicalSpace X] {f : Option ι → Set X}
Goal: LocallyFinite f ↔ LocallyFinite (f ∘ some)
-- LocallyFinite.option_elim'
theorem LocallyFinite.option_elim' (hf : LocallyFinite f) (s : Set X) :
    LocallyFinite (Option.elim' s f) 
Arguments: {ι : Type u_1} {X : Type u_4} [TopologicalSpace X] {f : ι → Set X} (hf : LocallyFinite f) (s : Set X)
Goal: LocallyFinite (Option.elim' s f)
-- LocallyFinite.eventually_subset
theorem LocallyFinite.eventually_subset {s : ι → Set X}
    (hs : LocallyFinite s) (hs' : ∀ i, IsClosed (s i)) (x : X) :
    ∀ᶠ y in 𝓝 x, {i | y ∈ s i} ⊆ {i | x ∈ s i} 
Arguments: {ι : Type u_1} {X : Type u_4} [TopologicalSpace X] {s : ι → Set X} (hs : LocallyFinite s) (hs' : ∀ (i : ι), IsClosed (s i)) (x : X)
Goal: ∀ᶠ (y : X) in 𝓝 x, {i | y ∈ s i} ⊆ {i | x ∈ s i}
-- TopCat.Presheaf.comp_app
@[simp] theorem comp_app {X : TopCat} {U : (Opens X)ᵒᵖ} {P Q R : Presheaf C X}
    (f : P ⟶ Q) (g : Q ⟶ R) :
    (f ≫ g).app U = f.app U ≫ g.app U 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} {U : (TopologicalSpace.Opens ↑X)ᵒᵖ} {P Q R : TopCat.Presheaf C X} (f : P ⟶ Q) (g : Q ⟶ R)
Goal: (f ≫ g).app U = f.app U ≫ g.app U
-- TopCat.Presheaf.ext
@[ext]
lemma ext {X : TopCat} {P Q : Presheaf C X} {f g : P ⟶ Q}
    (w : ∀ U : Opens X, f.app (op U) = g.app (op U)) :
    f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} {P Q : TopCat.Presheaf C X} {f g : P ⟶ Q} (w : ∀ (U : TopologicalSpace.Opens ↑X), f.app (Opposite.op U) = g.app (Opposite.op U))
Goal: f = g
-- TopCat.Presheaf.restrict_restrict
theorem restrict_restrict {X : TopCat} {C : Type*} [Category C] [ConcreteCategory C]
    {F : X.Presheaf C} {U V W : Opens X} (e₁ : U ≤ V) (e₂ : V ≤ W) (x : F.obj (op W)) :
    x |_ V |_ U = x |_ U 
Arguments: {X : TopCat} {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.ConcreteCategory C] {F : TopCat.Presheaf C X} {U V W : TopologicalSpace.Opens ↑X} (e₁ : U ≤ V) (e₂ : V ≤ W) (x : (CategoryTheory.forget C).obj (F.obj (Opposite.op W)))
Goal: TopCat.Presheaf.restrictOpen (TopCat.Presheaf.restrictOpen x V e₂) U e₁ = TopCat.Presheaf.restrictOpen x U ⋯
-- TopCat.Presheaf.map_restrict
theorem map_restrict {X : TopCat} {C : Type*} [Category C] [ConcreteCategory C]
    {F G : X.Presheaf C} (e : F ⟶ G) {U V : Opens X} (h : U ≤ V) (x : F.obj (op V)) :
    e.app _ (x |_ U) = e.app _ x |_ U 
Arguments: {X : TopCat} {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.ConcreteCategory C] {F G : TopCat.Presheaf C X} (e : F ⟶ G) {U V : TopologicalSpace.Opens ↑X} (h : U ≤ V) (x : (CategoryTheory.forget C).obj (F.obj (Opposite.op V)))
Goal: (e.app (Opposite.op U)) (TopCat.Presheaf.restrictOpen x U h) =
  TopCat.Presheaf.restrictOpen ((e.app (Opposite.op V)) x) U h
-- TopCat.Presheaf.pushforward_obj_obj
@[simps!]
def pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (f : X ⟶ Y) (G : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C)
Goal: ∀ (X_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.pushforward C f).obj G).obj X_1 =
    G.obj (Opposite.op ((TopologicalSpace.Opens.map f).obj (Opposite.unop X_1)))
-- TopCat.Presheaf.pushforward_map_app
@[simps!]
def pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (f : X ⟶ Y)
Goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C} (α : X_1 ⟶ Y_1) (X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.pushforward C f).map α).app X_2 =
    α.app (Opposite.op ((TopologicalSpace.Opens.map f).obj (Opposite.unop X_2)))
-- TopCat.Presheaf.pushforward_obj_map
@[simps!]
def pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (f : X ⟶ Y) (G : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C)
Goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ} (f_1 : X_1 ⟶ Y_1),
  ((TopCat.Presheaf.pushforward C f).obj G).map f_1 = G.map ((TopologicalSpace.Opens.map f).map f_1.unop).op
-- TopCat.Presheaf.pushforward_map_app'
@[simp]
theorem pushforward_map_app' {X Y : TopCat.{w}} (f : X ⟶ Y) {ℱ 𝒢 : X.Presheaf C} (α : ℱ ⟶ 𝒢)
    {U : (Opens Y)ᵒᵖ} : ((pushforward C f).map α).app U = α.app (op <| (Opens.map f).obj U.unop) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (f : X ⟶ Y) {ℱ 𝒢 : TopCat.Presheaf C X} (α : ℱ ⟶ 𝒢) {U : (TopologicalSpace.Opens ↑Y)ᵒᵖ}
Goal: ((TopCat.Presheaf.pushforward C f).map α).app U =
  α.app (Opposite.op ((TopologicalSpace.Opens.map f).obj (Opposite.unop U)))
-- TopCat.Presheaf.id_pushforward
lemma id_pushforward (X : TopCat.{w}) : pushforward C (𝟙 X) = 𝟭 (X.Presheaf C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (X : TopCat)
Goal: TopCat.Presheaf.pushforward C (𝟙 X) = 𝟭 (TopCat.Presheaf C X)
-- TopCat.Presheaf.Pushforward.id_hom_app
@[simp]
theorem id_hom_app {X : TopCat.{w}} (ℱ : X.Presheaf C) (U) : (id ℱ).hom.app U = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} (ℱ : TopCat.Presheaf C X) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (TopCat.Presheaf.Pushforward.id ℱ).hom.app U = 𝟙 (((TopCat.Presheaf.pushforward C (𝟙 X)).obj ℱ).obj U)
-- TopCat.Presheaf.Pushforward.id_inv_app
@[simp]
theorem id_inv_app {X : TopCat.{w}} (ℱ : X.Presheaf C) (U) :
    (id ℱ).inv.app U = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} (ℱ : TopCat.Presheaf C X) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (TopCat.Presheaf.Pushforward.id ℱ).inv.app U = 𝟙 (ℱ.obj U)
-- TopCat.Presheaf.Pushforward.id_eq
theorem id_eq {X : TopCat.{w}} (ℱ : X.Presheaf C) : 𝟙 X _* ℱ = ℱ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} (ℱ : TopCat.Presheaf C X)
Goal: (TopCat.Presheaf.pushforward C (𝟙 X)).obj ℱ = ℱ
-- TopCat.Presheaf.Pushforward.comp_eq
theorem comp_eq {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) :
    (f ≫ g) _* ℱ = g _* (f _* ℱ) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : TopCat.Presheaf C X)
Goal: (TopCat.Presheaf.pushforward C (f ≫ g)).obj ℱ =
  (TopCat.Presheaf.pushforward C g).obj ((TopCat.Presheaf.pushforward C f).obj ℱ)
-- TopCat.Presheaf.Pushforward.comp_hom_app
@[simp]
theorem comp_hom_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
    (comp f g ℱ).hom.app U = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : TopCat.Presheaf C X) (U : (TopologicalSpace.Opens ↑Z)ᵒᵖ)
Goal: (TopCat.Presheaf.Pushforward.comp f g ℱ).hom.app U = 𝟙 (((TopCat.Presheaf.pushforward C (f ≫ g)).obj ℱ).obj U)
-- TopCat.Presheaf.Pushforward.comp_inv_app
@[simp]
theorem comp_inv_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
    (comp f g ℱ).inv.app U = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : TopCat.Presheaf C X) (U : (TopologicalSpace.Opens ↑Z)ᵒᵖ)
Goal: (TopCat.Presheaf.Pushforward.comp f g ℱ).inv.app U =
  𝟙 (((TopCat.Presheaf.pushforward C g).obj ((TopCat.Presheaf.pushforward C f).obj ℱ)).obj U)
-- TopCat.Presheaf.pushforward_eq'
theorem pushforward_eq' {X Y : TopCat.{w}} {f g : X ⟶ Y} (h : f = g) (ℱ : X.Presheaf C) :
    f _* ℱ = g _* ℱ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : TopCat} {f g : X ⟶ Y} (h : f = g) (ℱ : TopCat.Presheaf C X)
Goal: (TopCat.Presheaf.pushforward C f).obj ℱ = (TopCat.Presheaf.pushforward C g).obj ℱ
-- TopCat.Presheaf.pushforwardEq_hom_app
@[simp]
theorem pushforwardEq_hom_app {X Y : TopCat.{w}} {f g : X ⟶ Y}
    (h : f = g) (ℱ : X.Presheaf C) (U) :
    (pushforwardEq h ℱ).hom.app U = ℱ.map (eqToHom (by aesop_cat)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : TopCat} {f g : X ⟶ Y} (h : f = g) (ℱ : TopCat.Presheaf C X) (U : (TopologicalSpace.Opens ↑Y)ᵒᵖ)
Goal: (TopCat.Presheaf.pushforwardEq h ℱ).hom.app U = ℱ.map (CategoryTheory.eqToHom ⋯)
-- TopCat.Presheaf.presheafEquivOfIso_functor_obj_obj
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y) (G : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C)
Goal: ∀ (X_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).functor.obj G).obj X_1 =
    G.obj (Opposite.op ((TopologicalSpace.Opens.map H.hom).obj (Opposite.unop X_1)))
-- TopCat.Presheaf.presheafEquivOfIso_inverse_obj_obj
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y) (G : (TopologicalSpace.Opens ↑Y)ᵒᵖ ⥤ C)
Goal: ∀ (X_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).inverse.obj G).obj X_1 =
    G.obj (Opposite.op ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_1)))
-- TopCat.Presheaf.presheafEquivOfIso_unitIso_inv_app_app
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y)
Goal: ∀ (X_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C) (X_2 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).unitIso.inv.app X_1).app X_2 =
    X_1.map
        ((TopologicalSpace.Opens.mapMapIso H).symm.op.unit.app
          (Opposite.op
            ((TopologicalSpace.Opens.map H.hom).obj ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2))))) ≫
      X_1.map
          ((TopologicalSpace.Opens.map H.hom).map
              ((TopologicalSpace.Opens.mapMapIso H).symm.op.counit.app
                  (Opposite.op ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2)))).unop).op ≫
        X_1.map ((TopologicalSpace.Opens.mapMapIso H).symm.op.unitInv.app X_2)
-- TopCat.Presheaf.presheafEquivOfIso_inverse_obj_map
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y) (G : (TopologicalSpace.Opens ↑Y)ᵒᵖ ⥤ C)
Goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ} (f : X_1 ⟶ Y_1),
  ((TopCat.Presheaf.presheafEquivOfIso C H).inverse.obj G).map f =
    G.map ((TopologicalSpace.Opens.map H.inv).map f.unop).op
-- TopCat.Presheaf.presheafEquivOfIso_unitIso_hom_app_app
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y)
Goal: ∀ (X_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C) (X_2 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).unitIso.hom.app X_1).app X_2 =
    X_1.map ((TopologicalSpace.Opens.mapMapIso H).symm.op.unit.app X_2) ≫
      X_1.map
          ((TopologicalSpace.Opens.map H.hom).map
              ((TopologicalSpace.Opens.mapMapIso H).symm.op.counitInv.app
                  (Opposite.op ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2)))).unop).op ≫
        X_1.map
          ((TopologicalSpace.Opens.mapMapIso H).symm.op.unitInv.app
            (Opposite.op
              ((TopologicalSpace.Opens.map H.hom).obj ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2)))))
-- TopCat.Presheaf.presheafEquivOfIso_functor_map_app
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y)
Goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C} (α : X_1 ⟶ Y_1) (X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).functor.map α).app X_2 =
    α.app (Opposite.op ((TopologicalSpace.Opens.map H.hom).obj (Opposite.unop X_2)))
-- TopCat.Presheaf.presheafEquivOfIso_counitIso_hom_app_app
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y)
Goal: ∀ (X_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ ⥤ C) (X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).counitIso.hom.app X_1).app X_2 = X_1.map (CategoryTheory.eqToHom ⋯)
-- TopCat.Presheaf.presheafEquivOfIso_counitIso_inv_app_app
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y)
Goal: ∀ (X_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ ⥤ C) (X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).counitIso.inv.app X_1).app X_2 = X_1.map (CategoryTheory.eqToHom ⋯)
-- TopCat.Presheaf.presheafEquivOfIso_functor_obj_map
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y) (G : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C)
Goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ} (f : X_1 ⟶ Y_1),
  ((TopCat.Presheaf.presheafEquivOfIso C H).functor.obj G).map f =
    G.map ((TopologicalSpace.Opens.map H.hom).map f.unop).op
-- TopCat.Presheaf.presheafEquivOfIso_inverse_map_app
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H : X ≅ Y)
Goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ ⥤ C} (α : X_1 ⟶ Y_1) (X_2 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).inverse.map α).app X_2 =
    α.app (Opposite.op ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2)))
-- TopCat.Presheaf.toPushforwardOfIso_app
@[simp]
theorem toPushforwardOfIso_app {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : X.Presheaf C} {𝒢 : Y.Presheaf C}
    (H₂ : H₁.hom _* ℱ ⟶ 𝒢) (U : (Opens X)ᵒᵖ) :
    (toPushforwardOfIso H₁ H₂).app U =
      ℱ.map (eqToHom (by simp [Opens.map, Set.preimage_preimage])) ≫
        H₂.app (op ((Opens.map H₁.inv).obj (unop U))) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : TopCat.Presheaf C X} {𝒢 : TopCat.Presheaf C Y} (H₂ : (TopCat.Presheaf.pushforward C H₁.hom).obj ℱ ⟶ 𝒢) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (TopCat.Presheaf.toPushforwardOfIso H₁ H₂).app U =
  ℱ.map (CategoryTheory.eqToHom ⋯) ≫ H₂.app (Opposite.op ((TopologicalSpace.Opens.map H₁.inv).obj (Opposite.unop U)))
-- TopCat.Presheaf.pushforwardToOfIso_app
@[simp]
theorem pushforwardToOfIso_app {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : Y.Presheaf C} {𝒢 : X.Presheaf C}
    (H₂ : ℱ ⟶ H₁.hom _* 𝒢) (U : (Opens X)ᵒᵖ) :
    (pushforwardToOfIso H₁ H₂).app U =
      H₂.app (op ((Opens.map H₁.inv).obj (unop U))) ≫
        𝒢.map (eqToHom (by simp [Opens.map, Set.preimage_preimage])) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : TopCat.Presheaf C Y} {𝒢 : TopCat.Presheaf C X} (H₂ : ℱ ⟶ (TopCat.Presheaf.pushforward C H₁.hom).obj 𝒢) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (TopCat.Presheaf.pushforwardToOfIso H₁ H₂).app U =
  H₂.app (Opposite.op ((TopologicalSpace.Opens.map H₁.inv).obj (Opposite.unop U))) ≫ 𝒢.map (CategoryTheory.eqToHom ⋯)
-- TopCat.Presheaf.generateEquivalenceOpensLe_functor'_obj_obj
@[simps]
def generateEquivalenceOpensLe_functor' :
    (FullSubcategory fun f : Over Y => (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) ⥤
    OpensLeCover U 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U) (f :
  CategoryTheory.FullSubcategory fun f =>
    (CategoryTheory.Sieve.generate (TopCat.Presheaf.presieveOfCoveringAux U Y)).arrows f.hom)
Goal: ((TopCat.Presheaf.generateEquivalenceOpensLe_functor' U hY).obj f).obj = f.obj.left
-- TopCat.Presheaf.generateEquivalenceOpensLe_functor'_map
@[simps]
def generateEquivalenceOpensLe_functor' :
    (FullSubcategory fun f : Over Y => (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) ⥤
    OpensLeCover U 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U)
Goal: ∀
  {x x_1 :
    CategoryTheory.FullSubcategory fun f =>
      (CategoryTheory.Sieve.generate (TopCat.Presheaf.presieveOfCoveringAux U Y)).arrows f.hom}
  (g : x ⟶ x_1), (TopCat.Presheaf.generateEquivalenceOpensLe_functor' U hY).map g = g.left
-- TopCat.Presheaf.generateEquivalenceOpensLe_inverse'_map
@[simps]
def generateEquivalenceOpensLe_inverse' :
    OpensLeCover U ⥤
    (FullSubcategory fun f : Over Y =>
      (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U)
Goal: ∀ {x x_1 : TopCat.Presheaf.SheafCondition.OpensLeCover U} (g : x ⟶ x_1),
  (TopCat.Presheaf.generateEquivalenceOpensLe_inverse' U hY).map g = CategoryTheory.Over.homMk g ⋯
-- TopCat.Presheaf.generateEquivalenceOpensLe_inverse'_obj_obj_hom
@[simps]
def generateEquivalenceOpensLe_inverse' :
    OpensLeCover U ⥤
    (FullSubcategory fun f : Over Y =>
      (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U) (V : TopCat.Presheaf.SheafCondition.OpensLeCover U)
Goal: ((TopCat.Presheaf.generateEquivalenceOpensLe_inverse' U hY).obj V).obj.hom = CategoryTheory.homOfLE ⋯
-- TopCat.Presheaf.generateEquivalenceOpensLe_inverse'_obj_obj_left
@[simps]
def generateEquivalenceOpensLe_inverse' :
    OpensLeCover U ⥤
    (FullSubcategory fun f : Over Y =>
      (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U) (V : TopCat.Presheaf.SheafCondition.OpensLeCover U)
Goal: ((TopCat.Presheaf.generateEquivalenceOpensLe_inverse' U hY).obj V).obj.left = V.obj
-- TopCat.Presheaf.generateEquivalenceOpensLe_inverse'_obj_obj_right_as
@[simps]
def generateEquivalenceOpensLe_inverse' :
    OpensLeCover U ⥤
    (FullSubcategory fun f : Over Y =>
      (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U) (V : TopCat.Presheaf.SheafCondition.OpensLeCover U)
Goal: ((TopCat.Presheaf.generateEquivalenceOpensLe_inverse' U hY).obj V).obj.right.as = PUnit.unit
-- TopCat.Presheaf.generateEquivalenceOpensLe_counitIso
@[simps]
def generateEquivalenceOpensLe :
    (FullSubcategory fun f : Over Y => (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) ≌
    OpensLeCover U 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U)
Goal: (TopCat.Presheaf.generateEquivalenceOpensLe U hY).counitIso = CategoryTheory.eqToIso ⋯
-- TopCat.Presheaf.generateEquivalenceOpensLe_functor
@[simps]
def generateEquivalenceOpensLe :
    (FullSubcategory fun f : Over Y => (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) ≌
    OpensLeCover U 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U)
Goal: (TopCat.Presheaf.generateEquivalenceOpensLe U hY).functor = TopCat.Presheaf.generateEquivalenceOpensLe_functor' U ⋯
-- TopCat.Presheaf.generateEquivalenceOpensLe_unitIso
@[simps]
def generateEquivalenceOpensLe :
    (FullSubcategory fun f : Over Y => (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) ≌
    OpensLeCover U 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U)
Goal: (TopCat.Presheaf.generateEquivalenceOpensLe U hY).unitIso = CategoryTheory.eqToIso ⋯
-- TopCat.Presheaf.generateEquivalenceOpensLe_inverse
@[simps]
def generateEquivalenceOpensLe :
    (FullSubcategory fun f : Over Y => (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) ≌
    OpensLeCover U 
Arguments: {X : TopCat} {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U)
Goal: (TopCat.Presheaf.generateEquivalenceOpensLe U hY).inverse = TopCat.Presheaf.generateEquivalenceOpensLe_inverse' U ⋯
-- TopCat.Presheaf.whiskerIsoMapGenerateCocone_inv_hom
@[simps]
def whiskerIsoMapGenerateCocone :
    (F.mapCone (opensLeCoverCocone U).op).whisker (generateEquivalenceOpensLe U hY).op.functor ≅
      F.mapCone (Sieve.generate (presieveOfCoveringAux U Y)).arrows.cocone.op 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} (F : TopCat.Presheaf C X) {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U)
Goal: (F.whiskerIsoMapGenerateCocone U hY).inv.hom = F.map (CategoryTheory.eqToHom ⋯)
-- TopCat.Presheaf.whiskerIsoMapGenerateCocone_hom_hom
@[simps]
def whiskerIsoMapGenerateCocone :
    (F.mapCone (opensLeCoverCocone U).op).whisker (generateEquivalenceOpensLe U hY).op.functor ≅
      F.mapCone (Sieve.generate (presieveOfCoveringAux U Y)).arrows.cocone.op 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} (F : TopCat.Presheaf C X) {ι : Type w} (U : ι → TopologicalSpace.Opens ↑X) {Y : TopologicalSpace.Opens ↑X} (hY : Y = iSup U)
Goal: (F.whiskerIsoMapGenerateCocone U hY).hom.hom = F.map (CategoryTheory.eqToHom ⋯)
-- TopCat.Presheaf.isSheaf_iff_isSheafOpensLeCover
theorem isSheaf_iff_isSheafOpensLeCover : F.IsSheaf ↔ F.IsSheafOpensLeCover 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} (F : TopCat.Presheaf C X)
Goal: F.IsSheaf ↔ F.IsSheafOpensLeCover
-- skyscraperPresheaf_map
@[simps]
def skyscraperPresheaf : Presheaf C X 
Arguments: {X : TopCat} (p₀ : ↑X) [(U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type v} [CategoryTheory.Category.{w, v} C] [CategoryTheory.Limits.HasTerminal C] (A : C) {U V : (TopologicalSpace.Opens ↑X)ᵒᵖ} (i : U ⟶ V)
Goal: (skyscraperPresheaf p₀ A).map i =
  if h : p₀ ∈ Opposite.unop V then CategoryTheory.eqToHom ⋯
  else (⋯ ▸ CategoryTheory.Limits.terminalIsTerminal).from ((fun U => if p₀ ∈ Opposite.unop U then A else ⊤_ C) U)
-- skyscraperPresheaf_obj
@[simps]
def skyscraperPresheaf : Presheaf C X 
Arguments: {X : TopCat} (p₀ : ↑X) [(U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type v} [CategoryTheory.Category.{w, v} C] [CategoryTheory.Limits.HasTerminal C] (A : C) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (skyscraperPresheaf p₀ A).obj U = if p₀ ∈ Opposite.unop U then A else ⊤_ C
-- skyscraperPresheaf_eq_pushforward
theorem skyscraperPresheaf_eq_pushforward
    [hd : ∀ U : Opens (TopCat.of PUnit.{u + 1}), Decidable (PUnit.unit ∈ U)] :
    skyscraperPresheaf p₀ A =
      ContinuousMap.const (TopCat.of PUnit) p₀ _*
        skyscraperPresheaf (X := TopCat.of PUnit) PUnit.unit A 
Arguments: {X : TopCat} (p₀ : ↑X) [(U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type v} [CategoryTheory.Category.{w, v} C] [CategoryTheory.Limits.HasTerminal C] (A : C) [hd : (U : TopologicalSpace.Opens ↑(TopCat.of PUnit.{u + 1})) → Decidable (PUnit.unit ∈ U)]
Goal: skyscraperPresheaf p₀ A =
  (TopCat.Presheaf.pushforward C (ContinuousMap.const (↑(TopCat.of PUnit.{u + 1})) p₀)).obj
    (skyscraperPresheaf PUnit.unit A)
-- SkyscraperPresheafFunctor.map'_app
@[simps]
def SkyscraperPresheafFunctor.map' {a b : C} (f : a ⟶ b) :
    skyscraperPresheaf p₀ a ⟶ skyscraperPresheaf p₀ b 
Arguments: {X : TopCat} (p₀ : ↑X) [(U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type v} [CategoryTheory.Category.{w, v} C] [CategoryTheory.Limits.HasTerminal C] {a b : C} (f : a ⟶ b) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (SkyscraperPresheafFunctor.map' p₀ f).app U =
  if h : p₀ ∈ Opposite.unop U then CategoryTheory.eqToHom ⋯ ≫ f ≫ CategoryTheory.eqToHom ⋯
  else (⋯ ▸ CategoryTheory.Limits.terminalIsTerminal).from ((skyscraperPresheaf p₀ a).obj U)