ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CompHausLike.finiteCoproduct.hom_ext
lemma finiteCoproduct.hom_ext {B : CompHausLike P} (f g : finiteCoproduct X ⟶ B)
    (h : ∀ a : α, finiteCoproduct.ι X a ≫ f = finiteCoproduct.ι X a ≫ g) : f = g 
Arguments: {P : TopCat → Prop} {α : Type w} [Finite α] (X : α → CompHausLike P) [CompHausLike.HasExplicitFiniteCoproduct X] {B : CompHausLike P} (f g : CompHausLike.finiteCoproduct X ⟶ B) (h :
  ∀ (a : α),
    CategoryTheory.CategoryStruct.comp (CompHausLike.finiteCoproduct.ι X a) f =
      CategoryTheory.CategoryStruct.comp (CompHausLike.finiteCoproduct.ι X a) g)
Goal: f = g
-- CompHausLike.finiteCoproduct.ι_injective
lemma finiteCoproduct.ι_injective (a : α) : Function.Injective (finiteCoproduct.ι X a) 
Arguments: {P : TopCat → Prop} {α : Type w} [Finite α] (X : α → CompHausLike P) [CompHausLike.HasExplicitFiniteCoproduct X] (a : α)
Goal: Function.Injective ⇑(CompHausLike.finiteCoproduct.ι X a)
-- CompHausLike.finiteCoproduct.ι_jointly_surjective
lemma finiteCoproduct.ι_jointly_surjective (R : finiteCoproduct X) :
    ∃ (a : α) (r : X a), R = finiteCoproduct.ι X a r 
Arguments: {P : TopCat → Prop} {α : Type w} [Finite α] (X : α → CompHausLike P) [CompHausLike.HasExplicitFiniteCoproduct X] (R : ↑(CompHausLike.finiteCoproduct X).toTop)
Goal: ∃ a r, R = (CompHausLike.finiteCoproduct.ι X a) r
-- CompHausLike.finiteCoproduct.ι_desc_apply
lemma finiteCoproduct.ι_desc_apply {B : CompHausLike P} {π : (a : α) → X a ⟶ B} (a : α) :
    ∀ x, finiteCoproduct.desc X π (finiteCoproduct.ι X a x) = π a x 
Arguments: {P : TopCat → Prop} {α : Type w} [Finite α] (X : α → CompHausLike P) [CompHausLike.HasExplicitFiniteCoproduct X] {B : CompHausLike P} {π : (a : α) → X a ⟶ B} (a : α) (x : (CategoryTheory.forget (CompHausLike P)).obj (X a))
Goal: (CompHausLike.finiteCoproduct.desc X π) ((CompHausLike.finiteCoproduct.ι X a) x) = (π a) x
-- CompHausLike.HasExplicitFiniteCoproducts.hasProp
class HasExplicitFiniteCoproducts : Prop where
  hasProp {α : Type w} [Finite α] (X : α → CompHausLike.{max u w} P) : HasExplicitFiniteCoproduct X
Arguments: {P : TopCat → Prop} [self : CompHausLike.HasExplicitFiniteCoproducts P] {α : Type w} [Finite α] (X : α → CompHausLike P)
Goal: CompHausLike.HasExplicitFiniteCoproduct X
-- CompHausLike.finiteCoproduct.openEmbedding_ι
lemma finiteCoproduct.openEmbedding_ι (a : α) :
    OpenEmbedding (finiteCoproduct.ι X a) 
Arguments: {P : TopCat → Prop} {α : Type w} [Finite α] (X : α → CompHausLike P) [CompHausLike.HasExplicitFiniteCoproduct X] (a : α)
Goal: OpenEmbedding ⇑(CompHausLike.finiteCoproduct.ι X a)
-- CompHausLike.Sigma.openEmbedding_ι
lemma Sigma.openEmbedding_ι (a : α) :
    OpenEmbedding (Sigma.ι X a) 
Arguments: {P : TopCat → Prop} {α : Type w} [Finite α] (X : α → CompHausLike P) [CompHausLike.HasExplicitFiniteCoproduct X] (a : α)
Goal: OpenEmbedding ⇑(CategoryTheory.Limits.Sigma.ι X a)
-- CompHausLike.pullback.condition
@[reassoc]
lemma pullback.condition : pullback.fst f g ≫ f = pullback.snd f g ≫ g 
Arguments: {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g]
Goal: CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.fst f g) f =
  CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.snd f g) g
-- CompHausLike.pullback.lift_fst
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.fst f g = a 
Arguments: {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g] {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : CategoryTheory.CategoryStruct.comp a f = CategoryTheory.CategoryStruct.comp b g)
Goal: CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.lift f g a b w) (CompHausLike.pullback.fst f g) = a
-- CompHausLike.pullback.lift_snd
@[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.snd f g = b 
Arguments: {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g] {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : CategoryTheory.CategoryStruct.comp a f = CategoryTheory.CategoryStruct.comp b g)
Goal: CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.lift f g a b w) (CompHausLike.pullback.snd f g) = b
-- CompHausLike.pullback.hom_ext
lemma pullback.hom_ext {Z : CompHausLike P} (a b : Z ⟶ pullback f g)
    (hfst : a ≫ pullback.fst f g = b ≫ pullback.fst f g)
    (hsnd : a ≫ pullback.snd f g = b ≫ pullback.snd f g) : a = b 
Arguments: {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g] {Z : CompHausLike P} (a b : Z ⟶ CompHausLike.pullback f g) (hfst :
  CategoryTheory.CategoryStruct.comp a (CompHausLike.pullback.fst f g) =
    CategoryTheory.CategoryStruct.comp b (CompHausLike.pullback.fst f g)) (hsnd :
  CategoryTheory.CategoryStruct.comp a (CompHausLike.pullback.snd f g) =
    CategoryTheory.CategoryStruct.comp b (CompHausLike.pullback.snd f g))
Goal: a = b
-- CompHausLike.pullback.cone_π
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g 
Arguments: {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g]
Goal: (CompHausLike.pullback.cone f g).π =
  {
    app := fun j =>
      Option.rec (CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.fst f g) f)
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CompHausLike.pullback.fst f g) (CompHausLike.pullback.snd f g) val)
        j,
    naturality := ⋯ }
-- CompHausLike.pullback.cone_pt
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g 
Arguments: {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g]
Goal: (CompHausLike.pullback.cone f g).pt = CompHausLike.pullback f g
-- CompHausLike.pullback.isLimit_lift
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g) 
Arguments: {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g] (s : CategoryTheory.Limits.PullbackCone f g)
Goal: (CompHausLike.pullback.isLimit f g).lift s = CompHausLike.pullback.lift f g s.fst s.snd ⋯
-- CompHausLike.HasExplicitPullbacks.hasProp
class HasExplicitPullbacks : Prop where
  hasProp {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) : HasExplicitPullback f g
Arguments: {P : TopCat → Prop} [self : CompHausLike.HasExplicitPullbacks P] {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B)
Goal: CompHausLike.HasExplicitPullback f g
-- CompHausLike.HasExplicitPullbacksOfInclusions.hasProp
class HasExplicitPullbacksOfInclusions [HasExplicitFiniteCoproducts.{0} P] : Prop where
  hasProp : ∀ {X Y Z : CompHausLike P} (f : Z ⟶ X ⨿ Y), HasExplicitPullback coprod.inl f
Arguments: {P : TopCat → Prop} [CompHausLike.HasExplicitFiniteCoproducts P] [self : CompHausLike.HasExplicitPullbacksOfInclusions P] {X Y Z : CompHausLike P} (f : Z ⟶ X ⨿ Y)
Goal: CompHausLike.HasExplicitPullback CategoryTheory.Limits.coprod.inl f
-- CompHausLike.hasPullbacksOfInclusions
theorem hasPullbacksOfInclusions
    (hP' : ∀ ⦃X Y B : CompHausLike.{u} P⦄ (f : X ⟶ B) (g : Y ⟶ B)
      (_ : OpenEmbedding f), HasExplicitPullback f g) :
    HasExplicitPullbacksOfInclusions P 
Arguments: {P : TopCat → Prop} [CompHausLike.HasExplicitFiniteCoproducts P] (hP' : ∀ ⦃X Y B : CompHausLike P⦄ (f : X ⟶ B) (g : Y ⟶ B), OpenEmbedding ⇑f → CompHausLike.HasExplicitPullback f g)
Goal: CompHausLike.HasExplicitPullbacksOfInclusions P
-- CompHausLike.finitaryExtensive
theorem finitaryExtensive (hP' : ∀ ⦃X Y B : CompHausLike.{u} P⦄ (f : X ⟶ B) (g : Y ⟶ B)
    (_ : OpenEmbedding f), HasExplicitPullback f g) :
      FinitaryExtensive (CompHausLike P) 
Arguments: {P : TopCat → Prop} [CompHausLike.HasExplicitFiniteCoproducts P] (hP' : ∀ ⦃X Y B : CompHausLike P⦄ (f : X ⟶ B) (g : Y ⟶ B), OpenEmbedding ⇑f → CompHausLike.HasExplicitPullback f g)
Goal: CategoryTheory.FinitaryExtensive (CompHausLike P)
-- CompHaus.effectiveEpi_tfae
theorem effectiveEpi_tfae
    {B X : CompHaus.{u}} (π : X ⟶ B) :
    TFAE
    [ EffectiveEpi π
    , Epi π
    , Function.Surjective π
    ] 
Arguments: {B X : CompHaus} (π : X ⟶ B)
Goal: [CategoryTheory.EffectiveEpi π, CategoryTheory.Epi π, Function.Surjective ⇑π].TFAE
-- CompHaus.effectiveEpiFamily_tfae
theorem effectiveEpiFamily_tfae
    {α : Type} [Finite α] {B : CompHaus.{u}}
    (X : α → CompHaus.{u}) (π : (a : α) → (X a ⟶ B)) :
    TFAE
    [ EffectiveEpiFamily X π
    , Epi (Sigma.desc π)
    , ∀ b : B, ∃ (a : α) (x : X a), π a x = b
    ] 
Arguments: {α : Type} [Finite α] {B : CompHaus} (X : α → CompHaus) (π : (a : α) → X a ⟶ B)
Goal: [CategoryTheory.EffectiveEpiFamily X π, CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π),
    ∀ (b : ↑B.toTop), ∃ a x, (π a) x = b].TFAE
-- CompHaus.effectiveEpiFamily_of_jointly_surjective
theorem effectiveEpiFamily_of_jointly_surjective
    {α : Type} [Finite α] {B : CompHaus.{u}}
    (X : α → CompHaus.{u}) (π : (a : α) → (X a ⟶ B))
    (surj : ∀ b : B, ∃ (a : α) (x : X a), π a x = b) :
    EffectiveEpiFamily X π 
Arguments: {α : Type} [Finite α] {B : CompHaus} (X : α → CompHaus) (π : (a : α) → X a ⟶ B) (surj : ∀ (b : ↑B.toTop), ∃ a x, (π a) x = b)
Goal: CategoryTheory.EffectiveEpiFamily X π
-- CompletelyRegularSpace.completely_regular
@[mk_iff]
class CompletelyRegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  completely_regular : ∀ (x : X), ∀ K : Set X, IsClosed K → x ∉ K →
    ∃ f : X → I, Continuous f ∧ f x = 0 ∧ EqOn f 1 K
Arguments: {X : Type u} [TopologicalSpace X] [self : CompletelyRegularSpace X] (x : X) (K : Set X)
Goal: IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K
-- completelyRegularSpace_iff
@[mk_iff]
class CompletelyRegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  completely_regular : ∀ (x : X), ∀ K : Set X, IsClosed K → x ∉ K →
    ∃ f : X → I, Continuous f ∧ f x = 0 ∧ EqOn f 1 K
Arguments: (X : Type u) [TopologicalSpace X]
Goal: CompletelyRegularSpace X ↔ ∀ (x : X) (K : Set X), IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K
-- t35Space_iff
@[mk_iff]
class T35Space (X : Type u) [TopologicalSpace X] extends T1Space X, CompletelyRegularSpace X : Prop
Arguments: (X : Type u) [TopologicalSpace X]
Goal: T35Space X ↔ T1Space X ∧ CompletelyRegularSpace X
-- separatesPoints_continuous_of_t35Space
lemma separatesPoints_continuous_of_t35Space [T35Space X] :
    SeparatesPoints (Continuous : Set (X → ℝ)) 
Arguments: {X : Type u} [TopologicalSpace X] [T1Space X] [T35Space X]
Goal: Set.SeparatesPoints Continuous
-- separatesPoints_continuous_of_t35Space_Icc
lemma separatesPoints_continuous_of_t35Space_Icc [T35Space X] :
    SeparatesPoints (Continuous : Set (X → I)) 
Arguments: {X : Type u} [TopologicalSpace X] [T1Space X] [T35Space X]
Goal: Set.SeparatesPoints Continuous
-- injective_stoneCechUnit_of_t35Space
lemma injective_stoneCechUnit_of_t35Space [T35Space X] :
    Function.Injective (stoneCechUnit : X → StoneCech X) 
Arguments: {X : Type u} [TopologicalSpace X] [T1Space X] [T35Space X]
Goal: Function.Injective stoneCechUnit
-- TopCat.piFan_π_app
@[simps! pt π_app]
def piFan {ι : Type v} (α : ι → TopCat.{max v u}) : Fan α 
Arguments: {ι : Type v} (α : ι → TopCat) (X : CategoryTheory.Discrete ι)
Goal: (TopCat.piFan α).π.app X = TopCat.piπ α X.as
-- TopCat.piFan_pt
@[simps! pt π_app]
def piFan {ι : Type v} (α : ι → TopCat.{max v u}) : Fan α 
Arguments: {ι : Type v} (α : ι → TopCat)
Goal: (TopCat.piFan α).pt = TopCat.of ((i : ι) → ↑(α i))
-- TopCat.piIsoPi_inv_π
@[reassoc (attr := simp)]
theorem piIsoPi_inv_π {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) :
    (piIsoPi α).inv ≫ Pi.π α i = piπ α i 
Arguments: {ι : Type v} (α : ι → TopCat) (i : ι)
Goal: (TopCat.piIsoPi α).inv ≫ CategoryTheory.Limits.Pi.π α i = TopCat.piπ α i
-- TopCat.piIsoPi_inv_π_apply
theorem piIsoPi_inv_π_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : ∀ i, α i) :
    (Pi.π α i : _) ((piIsoPi α).inv x) = x i 
Arguments: {ι : Type v} (α : ι → TopCat) (i : ι) (x : (i : ι) → ↑(α i))
Goal: (CategoryTheory.Limits.Pi.π α i) ((TopCat.piIsoPi α).inv x) = x i
-- TopCat.piIsoPi_hom_apply
theorem piIsoPi_hom_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι)
    (x : (∏ᶜ α : TopCat.{max v u})) : (piIsoPi α).hom x i = (Pi.π α i : _) x 
Arguments: {ι : Type v} (α : ι → TopCat) (i : ι) (x : ↑(∏ᶜ α))
Goal: (TopCat.piIsoPi α).hom x i = (CategoryTheory.Limits.Pi.π α i) x
-- TopCat.sigmaCofan_ι_app
@[simps! pt ι_app]
def sigmaCofan {ι : Type v} (α : ι → TopCat.{max v u}) : Cofan α 
Arguments: {ι : Type v} (α : ι → TopCat) (X : CategoryTheory.Discrete ι)
Goal: (TopCat.sigmaCofan α).ι.app X = TopCat.sigmaι α X.as
-- TopCat.sigmaCofan_pt
@[simps! pt ι_app]
def sigmaCofan {ι : Type v} (α : ι → TopCat.{max v u}) : Cofan α 
Arguments: {ι : Type v} (α : ι → TopCat)
Goal: (TopCat.sigmaCofan α).pt = TopCat.of ((i : ι) × ↑(α i))
-- TopCat.sigmaIsoSigma_hom_ι
@[reassoc (attr := simp)]
theorem sigmaIsoSigma_hom_ι {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) :
    Sigma.ι α i ≫ (sigmaIsoSigma α).hom = sigmaι α i 
Arguments: {ι : Type v} (α : ι → TopCat) (i : ι)
Goal: CategoryTheory.Limits.Sigma.ι α i ≫ (TopCat.sigmaIsoSigma α).hom = TopCat.sigmaι α i
-- TopCat.sigmaIsoSigma_hom_ι_apply
theorem sigmaIsoSigma_hom_ι_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : α i) :
    (sigmaIsoSigma α).hom ((Sigma.ι α i : _) x) = Sigma.mk i x 
Arguments: {ι : Type v} (α : ι → TopCat) (i : ι) (x : ↑(α i))
Goal: (TopCat.sigmaIsoSigma α).hom ((CategoryTheory.Limits.Sigma.ι α i) x) = ⟨i, x⟩
-- TopCat.sigmaIsoSigma_inv_apply
theorem sigmaIsoSigma_inv_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : α i) :
    (sigmaIsoSigma α).inv ⟨i, x⟩ = (Sigma.ι α i : _) x 
Arguments: {ι : Type v} (α : ι → TopCat) (i : ι) (x : ↑(α i))
Goal: (TopCat.sigmaIsoSigma α).inv ⟨i, x⟩ = (CategoryTheory.Limits.Sigma.ι α i) x
-- TopCat.induced_of_isLimit
theorem induced_of_isLimit {F : J ⥤ TopCat.{max v u}} (C : Cone F) (hC : IsLimit C) :
    C.pt.str = ⨅ j, (F.obj j).str.induced (C.π.app j) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] {F : J ⥤ TopCat} (C : CategoryTheory.Limits.Cone F) (hC : CategoryTheory.Limits.IsLimit C)
Goal: C.pt.str = ⨅ j, TopologicalSpace.induced (⇑(C.π.app j)) (F.obj j).str
-- TopCat.limit_topology
theorem limit_topology (F : J ⥤ TopCat.{max v u}) :
    (limit F).str = ⨅ j, (F.obj j).str.induced (limit.π F j) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ TopCat)
Goal: (CategoryTheory.Limits.limit F).str = ⨅ j, TopologicalSpace.induced (⇑(CategoryTheory.Limits.limit.π F j)) (F.obj j).str
-- TopCat.prodIsoProd_hom_fst
@[reassoc (attr := simp)]
theorem prodIsoProd_hom_fst (X Y : TopCat.{u}) :
    (prodIsoProd X Y).hom ≫ prodFst = Limits.prod.fst 
Arguments: (X Y : TopCat)
Goal: (X.prodIsoProd Y).hom ≫ TopCat.prodFst = CategoryTheory.Limits.prod.fst
-- TopCat.prodIsoProd_hom_snd
@[reassoc (attr := simp)]
theorem prodIsoProd_hom_snd (X Y : TopCat.{u}) :
    (prodIsoProd X Y).hom ≫ prodSnd = Limits.prod.snd 
Arguments: (X Y : TopCat)
Goal: (X.prodIsoProd Y).hom ≫ TopCat.prodSnd = CategoryTheory.Limits.prod.snd
-- TopCat.prodIsoProd_hom_apply
theorem prodIsoProd_hom_apply {X Y : TopCat.{u}} (x : ↑ (X ⨯ Y)) :
    (prodIsoProd X Y).hom x = ((Limits.prod.fst : X ⨯ Y ⟶ _) x,
    (Limits.prod.snd : X ⨯ Y ⟶ _) x) 
Arguments: {X Y : TopCat} (x : ↑(X ⨯ Y))
Goal: (X.prodIsoProd Y).hom x = (CategoryTheory.Limits.prod.fst x, CategoryTheory.Limits.prod.snd x)
-- TopCat.prodIsoProd_inv_fst
@[reassoc (attr := simp), elementwise]
theorem prodIsoProd_inv_fst (X Y : TopCat.{u}) :
    (prodIsoProd X Y).inv ≫ Limits.prod.fst = prodFst 
Arguments: (X Y : TopCat)
Goal: (X.prodIsoProd Y).inv ≫ CategoryTheory.Limits.prod.fst = TopCat.prodFst
-- TopCat.prodIsoProd_inv_snd
@[reassoc (attr := simp), elementwise]
theorem prodIsoProd_inv_snd (X Y : TopCat.{u}) :
    (prodIsoProd X Y).inv ≫ Limits.prod.snd = prodSnd 
Arguments: (X Y : TopCat)
Goal: (X.prodIsoProd Y).inv ≫ CategoryTheory.Limits.prod.snd = TopCat.prodSnd
-- TopCat.prod_topology
theorem prod_topology {X Y : TopCat.{u}} :
    (X ⨯ Y).str =
      induced (Limits.prod.fst : X ⨯ Y ⟶ _) X.str ⊓
        induced (Limits.prod.snd : X ⨯ Y ⟶ _) Y.str 
Arguments: {X Y : TopCat}
Goal: (X ⨯ Y).str =
  TopologicalSpace.induced (⇑CategoryTheory.Limits.prod.fst) X.str ⊓
    TopologicalSpace.induced (⇑CategoryTheory.Limits.prod.snd) Y.str
-- TopCat.range_prod_map
theorem range_prod_map {W X Y Z : TopCat.{u}} (f : W ⟶ Y) (g : X ⟶ Z) :
    Set.range (Limits.prod.map f g) =
      (Limits.prod.fst : Y ⨯ Z ⟶ _) ⁻¹' Set.range f ∩
        (Limits.prod.snd : Y ⨯ Z ⟶ _) ⁻¹' Set.range g 
Arguments: {W X Y Z : TopCat} (f : W ⟶ Y) (g : X ⟶ Z)
Goal: Set.range ⇑(CategoryTheory.Limits.prod.map f g) =
  ⇑CategoryTheory.Limits.prod.fst ⁻¹' Set.range ⇑f ∩ ⇑CategoryTheory.Limits.prod.snd ⁻¹' Set.range ⇑g
-- TopCat.inducing_prod_map
theorem inducing_prod_map {W X Y Z : TopCat.{u}} {f : W ⟶ X} {g : Y ⟶ Z} (hf : Inducing f)
    (hg : Inducing g) : Inducing (Limits.prod.map f g) 
Arguments: {W X Y Z : TopCat} {f : W ⟶ X} {g : Y ⟶ Z} (hf : Inducing ⇑f) (hg : Inducing ⇑g)
Goal: Inducing ⇑(CategoryTheory.Limits.prod.map f g)
-- TopCat.embedding_prod_map
theorem embedding_prod_map {W X Y Z : TopCat.{u}} {f : W ⟶ X} {g : Y ⟶ Z} (hf : Embedding f)
    (hg : Embedding g) : Embedding (Limits.prod.map f g) 
Arguments: {W X Y Z : TopCat} {f : W ⟶ X} {g : Y ⟶ Z} (hf : Embedding ⇑f) (hg : Embedding ⇑g)
Goal: Embedding ⇑(CategoryTheory.Limits.prod.map f g)
-- TopCat.binaryCofan_isColimit_iff
theorem binaryCofan_isColimit_iff {X Y : TopCat} (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔
      OpenEmbedding c.inl ∧ OpenEmbedding c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr) 
Arguments: {X Y : TopCat} (c : CategoryTheory.Limits.BinaryCofan X Y)
Goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔
  OpenEmbedding ⇑c.inl ∧ OpenEmbedding ⇑c.inr ∧ IsCompl (Set.range ⇑c.inl) (Set.range ⇑c.inr)
-- Compactum.str_incl
@[simp]
theorem str_incl (X : Compactum) (x : X) : X.str (X.incl x) = x 
Arguments: (X : Compactum) (x : X.A)
Goal: X.str (X.incl x) = x
-- Compactum.str_hom_commute
@[simp]
theorem str_hom_commute (X Y : Compactum) (f : X ⟶ Y) (xs : Ultrafilter X) :
    f (X.str xs) = Y.str (map f xs) 
Arguments: (X Y : Compactum) (f : X ⟶ Y) (xs : Ultrafilter X.A)
Goal: f.f (X.str xs) = Y.str (Ultrafilter.map f.f xs)
-- Compactum.join_distrib
@[simp]
theorem join_distrib (X : Compactum) (uux : Ultrafilter (Ultrafilter X)) :
    X.str (X.join uux) = X.str (map X.str uux) 
Arguments: (X : Compactum) (uux : Ultrafilter (Ultrafilter X.A))
Goal: X.str (X.join uux) = X.str (Ultrafilter.map X.str uux)
-- Compactum.isClosed_iff
theorem isClosed_iff {X : Compactum} (S : Set X) :
    IsClosed S ↔ ∀ F : Ultrafilter X, S ∈ F → X.str F ∈ S 
Arguments: {X : Compactum} (S : Set X.A)
Goal: IsClosed S ↔ ∀ (F : Ultrafilter X.A), S ∈ F → X.str F ∈ S
-- _private.Mathlib.Topology.Category.Compactum.0.Compactum.basic_inter
private theorem basic_inter {X : Compactum} (A B : Set X) : basic (A ∩ B) = basic A ∩ basic B 
Arguments: {X : Compactum} (A B : Set X.A)
Goal: Compactum.basic (A ∩ B) = Compactum.basic A ∩ Compactum.basic B
-- _private.Mathlib.Topology.Category.Compactum.0.Compactum.subset_cl
private theorem subset_cl {X : Compactum} (A : Set X) : A ⊆ cl A 
Arguments: {X : Compactum} (A : Set X.A)
Goal: A ⊆ Compactum.cl A
-- _private.Mathlib.Topology.Category.Compactum.0.Compactum.cl_cl
private theorem cl_cl {X : Compactum} (A : Set X) : cl (cl A) ⊆ cl A 
Arguments: {X : Compactum} (A : Set X.A)
Goal: Compactum.cl (Compactum.cl A) ⊆ Compactum.cl A
-- Compactum.isClosed_cl
theorem isClosed_cl {X : Compactum} (A : Set X) : IsClosed (cl A) 
Arguments: {X : Compactum} (A : Set X.A)
Goal: IsClosed (Compactum.cl A)
-- Compactum.str_eq_of_le_nhds
theorem str_eq_of_le_nhds {X : Compactum} (F : Ultrafilter X) (x : X) : ↑F ≤ 𝓝 x → X.str F = x 
Arguments: {X : Compactum} (F : Ultrafilter X.A) (x : X.A)
Goal: ↑F ≤ 𝓝 x → X.str F = x
-- Compactum.le_nhds_of_str_eq
theorem le_nhds_of_str_eq {X : Compactum} (F : Ultrafilter X) (x : X) : X.str F = x → ↑F ≤ 𝓝 x 
Arguments: {X : Compactum} (F : Ultrafilter X.A) (x : X.A)
Goal: X.str F = x → ↑F ≤ 𝓝 x
-- Compactum.lim_eq_str
theorem lim_eq_str {X : Compactum} (F : Ultrafilter X) : F.lim = X.str F 
Arguments: {X : Compactum} (F : Ultrafilter X.A)
Goal: F.lim = X.str F
-- Compactum.cl_eq_closure
theorem cl_eq_closure {X : Compactum} (A : Set X) : cl A = closure A 
Arguments: {X : Compactum} (A : Set X.A)
Goal: Compactum.cl A = closure A
-- Compactum.continuous_of_hom
theorem continuous_of_hom {X Y : Compactum} (f : X ⟶ Y) : Continuous f 
Arguments: {X Y : Compactum} (f : X ⟶ Y)
Goal: Continuous f.f
-- Filter.Germ.value_smul
theorem value_smul {α β : Type*} [SMul α β] (φ : Germ (𝓝 x) α)
    (ψ : Germ (𝓝 x) β) : (φ • ψ).value = φ.value • ψ.value 
Arguments: {X : Type u_3} [TopologicalSpace X] {x : X} {α : Type u_6} {β : Type u_7} [SMul α β] (φ : (𝓝 x).Germ α) (ψ : (𝓝 x).Germ β)
Goal: (φ • ψ).value = φ.value • ψ.value
-- Filter.Eventually.germ_congr_set
theorem Filter.Eventually.germ_congr_set
    {P : ∀ x : X, Germ (𝓝 x) Y → Prop} (hf : ∀ᶠ x in 𝓝ˢ A, P x f)
    (h : ∀ᶠ z in 𝓝ˢ A, g z = f z) : ∀ᶠ x in 𝓝ˢ A, P x g 
Arguments: {X : Type u_3} {Y : Type u_4} [TopologicalSpace X] {f g : X → Y} {A : Set X} {P : (x : X) → (𝓝 x).Germ Y → Prop} (hf : ∀ᶠ (x : X) in 𝓝ˢ A, P x ↑f) (h : ∀ᶠ (z : X) in 𝓝ˢ A, g z = f z)
Goal: ∀ᶠ (x : X) in 𝓝ˢ A, P x ↑g
-- restrictGermPredicate_congr
theorem restrictGermPredicate_congr {P : ∀ x : X, Germ (𝓝 x) Y → Prop}
    (hf : RestrictGermPredicate P A x f) (h : ∀ᶠ z in 𝓝ˢ A, g z = f z) :
    RestrictGermPredicate P A x g 
Arguments: {X : Type u_3} {Y : Type u_4} [TopologicalSpace X] {f g : X → Y} {A : Set X} {x : X} {P : (x : X) → (𝓝 x).Germ Y → Prop} (hf : RestrictGermPredicate P A x ↑f) (h : ∀ᶠ (z : X) in 𝓝ˢ A, g z = f z)
Goal: RestrictGermPredicate P A x ↑g
-- forall_restrictGermPredicate_iff
theorem forall_restrictGermPredicate_iff {P : ∀ x : X, Germ (𝓝 x) Y → Prop} :
    (∀ x, RestrictGermPredicate P A x f) ↔ ∀ᶠ x in 𝓝ˢ A, P x f 
Arguments: {X : Type u_3} {Y : Type u_4} [TopologicalSpace X] {f : X → Y} {A : Set X} {P : (x : X) → (𝓝 x).Germ Y → Prop}
Goal: (∀ (x : X), RestrictGermPredicate P A x ↑f) ↔ ∀ᶠ (x : X) in 𝓝ˢ A, P x ↑f
-- forall_restrictGermPredicate_of_forall
theorem forall_restrictGermPredicate_of_forall
    {P : ∀ x : X, Germ (𝓝 x) Y → Prop} (h : ∀ x, P x f) :
    ∀ x, RestrictGermPredicate P A x f 
Arguments: {X : Type u_3} {Y : Type u_4} [TopologicalSpace X] {f : X → Y} {A : Set X} {P : (x : X) → (𝓝 x).Germ Y → Prop} (h : ∀ (x : X), P x ↑f) (x : X)
Goal: RestrictGermPredicate P A x ↑f
-- Filter.Germ.sliceLeft_coe
@[simp]
theorem sliceLeft_coe [TopologicalSpace Y] {y : Y} (f : X × Y → Z) :
    (↑f : Germ (𝓝 (x, y)) Z).sliceLeft = fun x' ↦ f (x', y) 
Arguments: {X : Type u_3} {Y : Type u_4} {Z : Type u_5} [TopologicalSpace X] {x : X} [TopologicalSpace Y] {y : Y} (f : X × Y → Z)
Goal: (↑f).sliceLeft = ↑fun x' => f (x', y)
-- Filter.Germ.sliceRight_coe
@[simp]
theorem sliceRight_coe [TopologicalSpace Y] {y : Y} (f : X × Y → Z) :
    (↑f : Germ (𝓝 (x, y)) Z).sliceRight = fun y' ↦ f (x, y') 
Arguments: {X : Type u_3} {Y : Type u_4} {Z : Type u_5} [TopologicalSpace X] {x : X} [TopologicalSpace Y] {y : Y} (f : X × Y → Z)
Goal: (↑f).sliceRight = ↑fun y' => f (x, y')
-- Filter.Germ.isConstant_comp_subtype
lemma isConstant_comp_subtype {s : Set X} {f : X → Y} {x : s}
    (hf : (f : Germ (𝓝 (x : X)) Y).IsConstant) :
    ((f ∘ Subtype.val : s → Y) : Germ (𝓝 x) Y).IsConstant 
Arguments: {X : Type u_3} {Y : Type u_4} [TopologicalSpace X] {s : Set X} {f : X → Y} {x : ↑s} (hf : (↑f).IsConstant)
Goal: (↑(f ∘ Subtype.val)).IsConstant
-- IsLocallyConstant.of_germ_isConstant
lemma IsLocallyConstant.of_germ_isConstant (h : ∀ x : X, (f : Germ (𝓝 x) Y).IsConstant) :
    IsLocallyConstant f 
Arguments: {X : Type u_3} {Y : Type u_4} [TopologicalSpace X] {f : X → Y} (h : ∀ (x : X), (↑f).IsConstant)
Goal: IsLocallyConstant f
-- eq_of_germ_isConstant
theorem eq_of_germ_isConstant [i : PreconnectedSpace X]
    (h : ∀ x : X, (f : Germ (𝓝 x) Y).IsConstant) (x x' : X) : f x = f x' 
Arguments: {X : Type u_3} {Y : Type u_4} [TopologicalSpace X] {f : X → Y} [i : PreconnectedSpace X] (h : ∀ (x : X), (↑f).IsConstant) (x x' : X)
Goal: f x = f x'