ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- exists_nhds_ne_inf_principal_neBot
theorem exists_nhds_ne_inf_principal_neBot (hs : IsCompact s) (hs' : s.Infinite) :
    ∃ z ∈ s, (𝓝[≠] z ⊓ 𝓟 s).NeBot 
Arguments: {X : Type u} [TopologicalSpace X] {s : Set X} (hs : IsCompact s) (hs' : s.Infinite)
Goal: ∃ z ∈ s, (𝓝[≠] z ⊓ 𝓟 s).NeBot
-- ClosedEmbedding.noncompactSpace
protected theorem ClosedEmbedding.noncompactSpace [NoncompactSpace X] {f : X → Y}
    (hf : ClosedEmbedding f) : NoncompactSpace Y 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] [NoncompactSpace X] {f : X → Y} (hf : ClosedEmbedding f)
Goal: NoncompactSpace Y
-- ClosedEmbedding.compactSpace
protected theorem ClosedEmbedding.compactSpace [h : CompactSpace Y] {f : X → Y}
    (hf : ClosedEmbedding f) : CompactSpace X 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] [h : CompactSpace Y] {f : X → Y} (hf : ClosedEmbedding f)
Goal: CompactSpace X
-- IsCompact.prod
theorem IsCompact.prod {t : Set Y} (hs : IsCompact s) (ht : IsCompact t) :
    IsCompact (s ×ˢ t) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {s : Set X} {t : Set Y} (hs : IsCompact s) (ht : IsCompact t)
Goal: IsCompact (s ×ˢ t)
-- Filter.coprod_cocompact
theorem Filter.coprod_cocompact :
    (Filter.cocompact X).coprod (Filter.cocompact Y) = Filter.cocompact (X × Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: (Filter.cocompact X).coprod (Filter.cocompact Y) = Filter.cocompact (X × Y)
-- Prod.noncompactSpace_iff
theorem Prod.noncompactSpace_iff :
    NoncompactSpace (X × Y) ↔ NoncompactSpace X ∧ Nonempty Y ∨ Nonempty X ∧ NoncompactSpace Y 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: NoncompactSpace (X × Y) ↔ NoncompactSpace X ∧ Nonempty Y ∨ Nonempty X ∧ NoncompactSpace Y
-- isCompact_pi_infinite
theorem isCompact_pi_infinite {s : ∀ i, Set (X i)} :
    (∀ i, IsCompact (s i)) → IsCompact { x : ∀ i, X i | ∀ i, x i ∈ s i } 
Arguments: {ι : Type u_1} {X : ι → Type u_2} [(i : ι) → TopologicalSpace (X i)] {s : (i : ι) → Set (X i)}
Goal: (∀ (i : ι), IsCompact (s i)) → IsCompact {x | ∀ (i : ι), x i ∈ s i}
-- isCompact_univ_pi
theorem isCompact_univ_pi {s : ∀ i, Set (X i)} (h : ∀ i, IsCompact (s i)) :
    IsCompact (pi univ s) 
Arguments: {ι : Type u_1} {X : ι → Type u_2} [(i : ι) → TopologicalSpace (X i)] {s : (i : ι) → Set (X i)} (h : ∀ (i : ι), IsCompact (s i))
Goal: IsCompact (Set.univ.pi s)
-- Pi.isCompact_iff_of_isClosed
lemma Pi.isCompact_iff_of_isClosed {s : Set (Π i, X i)} (hs : IsClosed s) :
    IsCompact s ↔ ∀ i, IsCompact (eval i '' s) 
Arguments: {ι : Type u_1} {X : ι → Type u_2} [(i : ι) → TopologicalSpace (X i)] {s : Set ((i : ι) → X i)} (hs : IsClosed s)
Goal: IsCompact s ↔ ∀ (i : ι), IsCompact (Function.eval i '' s)
-- Pi.exists_compact_superset_iff
protected lemma Pi.exists_compact_superset_iff {s : Set (Π i, X i)} :
    (∃ K, IsCompact K ∧ s ⊆ K) ↔ ∀ i, ∃ Ki, IsCompact Ki ∧ s ⊆ eval i ⁻¹' Ki 
Arguments: {ι : Type u_1} {X : ι → Type u_2} [(i : ι) → TopologicalSpace (X i)] {s : Set ((i : ι) → X i)}
Goal: (∃ K, IsCompact K ∧ s ⊆ K) ↔ ∀ (i : ι), ∃ Ki, IsCompact Ki ∧ s ⊆ Function.eval i ⁻¹' Ki
-- Filter.coprodᵢ_cocompact
theorem Filter.coprodᵢ_cocompact {X : ι → Type*} [∀ d, TopologicalSpace (X d)] :
    (Filter.coprodᵢ fun d => Filter.cocompact (X d)) = Filter.cocompact (∀ d, X d) 
Arguments: {ι : Type u_1} {X : ι → Type u_3} [(d : ι) → TopologicalSpace (X d)]
Goal: (Filter.coprodᵢ fun d => Filter.cocompact (X d)) = Filter.cocompact ((d : ι) → X d)
-- IsClosed.exists_minimal_nonempty_closed_subset
theorem IsClosed.exists_minimal_nonempty_closed_subset [CompactSpace X] {S : Set X}
    (hS : IsClosed S) (hne : S.Nonempty) :
    ∃ V : Set X, V ⊆ S ∧ V.Nonempty ∧ IsClosed V ∧
      ∀ V' : Set X, V' ⊆ V → V'.Nonempty → IsClosed V' → V' = V 
Arguments: {X : Type u} [TopologicalSpace X] [CompactSpace X] {S : Set X} (hS : IsClosed S) (hne : S.Nonempty)
Goal: ∃ V ⊆ S, V.Nonempty ∧ IsClosed V ∧ ∀ V' ⊆ V, V'.Nonempty → IsClosed V' → V' = V
-- TopCommRingCat.isTopologicalRing
structure TopCommRingCat where
    α : Type u
  [isCommRing : CommRing α]
  [isTopologicalSpace : TopologicalSpace α]
  [isTopologicalRing : TopologicalRing α]
Arguments: (self : TopCommRingCat)
Goal: TopologicalRing self.α
-- TopCommRingCat.coe_of
@[simp]
theorem coe_of (X : Type u) [CommRing X] [TopologicalSpace X] [TopologicalRing X] :
    (of X : Type u) = X 
Arguments: (X : Type u) [CommRing X] [TopologicalSpace X] [TopologicalRing X]
Goal: (TopCommRingCat.of X).α = X
-- TopologicalSpace.OpenNhds.inclusion_obj
@[simp]
theorem inclusion_obj (x : X) (U) (p) : (inclusion x).obj ⟨U, p⟩ = U 
Arguments: {X : TopCat} (x : ↑X) (U : TopologicalSpace.Opens ↑X) (p : x ∈ U)
Goal: (TopologicalSpace.OpenNhds.inclusion x).obj { obj := U, property := p } = U
-- TopologicalSpace.OpenNhds.openEmbedding
theorem openEmbedding {x : X} (U : OpenNhds x) : OpenEmbedding U.1.inclusion 
Arguments: {X : TopCat} {x : ↑X} (U : TopologicalSpace.OpenNhds x)
Goal: OpenEmbedding ⇑U.obj.inclusion
-- TopologicalSpace.OpenNhds.map_obj
@[simp]
theorem map_obj (x : X) (U) (q) : (map f x).obj ⟨U, q⟩ = ⟨(Opens.map f).obj U, q⟩ 
Arguments: {X Y : TopCat} (f : X ⟶ Y) (x : ↑X) (U : TopologicalSpace.Opens ↑Y) (q : f x ∈ U)
Goal: (TopologicalSpace.OpenNhds.map f x).obj { obj := U, property := q } =
  { obj := (TopologicalSpace.Opens.map f).obj U, property := q }
-- TopologicalSpace.OpenNhds.map_id_obj
@[simp]
theorem map_id_obj (x : X) (U) : (map (𝟙 X) x).obj U = U 
Arguments: {X : TopCat} (x : ↑X) (U : TopologicalSpace.OpenNhds ((𝟙 X) x))
Goal: (TopologicalSpace.OpenNhds.map (𝟙 X) x).obj U = U
-- TopologicalSpace.OpenNhds.map_id_obj'
@[simp]
theorem map_id_obj' (x : X) (U) (p) (q) : (map (𝟙 X) x).obj ⟨⟨U, p⟩, q⟩ = ⟨⟨U, p⟩, q⟩ 
Arguments: {X : TopCat} (x : ↑X) (U : Set ↑X) (p : IsOpen U) (q : (𝟙 X) x ∈ { carrier := U, is_open' := p })
Goal: (TopologicalSpace.OpenNhds.map (𝟙 X) x).obj { obj := { carrier := U, is_open' := p }, property := q } =
  { obj := { carrier := U, is_open' := p }, property := q }
-- TopologicalSpace.OpenNhds.map_id_obj_unop
@[simp]
theorem map_id_obj_unop (x : X) (U : (OpenNhds x)ᵒᵖ) : (map (𝟙 X) x).obj (unop U) = unop U 
Arguments: {X : TopCat} (x : ↑X) (U : (TopologicalSpace.OpenNhds x)ᵒᵖ)
Goal: (TopologicalSpace.OpenNhds.map (𝟙 X) x).obj (Opposite.unop U) = Opposite.unop U
-- TopologicalSpace.OpenNhds.op_map_id_obj
@[simp]
theorem op_map_id_obj (x : X) (U : (OpenNhds x)ᵒᵖ) : (map (𝟙 X) x).op.obj U = U 
Arguments: {X : TopCat} (x : ↑X) (U : (TopologicalSpace.OpenNhds x)ᵒᵖ)
Goal: (TopologicalSpace.OpenNhds.map (𝟙 X) x).op.obj U = U
-- TopologicalSpace.OpenNhds.inclusionMapIso_hom_app
@[simps! hom_app inv_app]
def inclusionMapIso (x : X) : inclusion (f x) ⋙ Opens.map f ≅ map f x ⋙ inclusion x 
Arguments: {X Y : TopCat} (f : X ⟶ Y) (x : ↑X)
Goal: ∀ (X_1 : TopologicalSpace.OpenNhds (f x)),
  (TopologicalSpace.OpenNhds.inclusionMapIso f x).hom.app X_1 =
    𝟙 ((TopologicalSpace.Opens.map f).obj ((TopologicalSpace.OpenNhds.inclusion (f x)).obj X_1))
-- TopologicalSpace.OpenNhds.inclusionMapIso_inv_app
@[simps! hom_app inv_app]
def inclusionMapIso (x : X) : inclusion (f x) ⋙ Opens.map f ≅ map f x ⋙ inclusion x 
Arguments: {X Y : TopCat} (f : X ⟶ Y) (x : ↑X)
Goal: ∀ (X_1 : TopologicalSpace.OpenNhds (f x)),
  (TopologicalSpace.OpenNhds.inclusionMapIso f x).inv.app X_1 =
    𝟙 ((TopologicalSpace.OpenNhds.inclusion x).obj ((TopologicalSpace.OpenNhds.map f x).obj X_1))
-- TopologicalSpace.OpenNhds.inclusionMapIso_hom
@[simp]
theorem inclusionMapIso_hom (x : X) : (inclusionMapIso f x).hom = 𝟙 _ 
Arguments: {X Y : TopCat} (f : X ⟶ Y) (x : ↑X)
Goal: (TopologicalSpace.OpenNhds.inclusionMapIso f x).hom =
  𝟙 (TopologicalSpace.OpenNhds.inclusion (f x) ⋙ TopologicalSpace.Opens.map f)
-- TopologicalSpace.OpenNhds.inclusionMapIso_inv
@[simp]
theorem inclusionMapIso_inv (x : X) : (inclusionMapIso f x).inv = 𝟙 _ 
Arguments: {X Y : TopCat} (f : X ⟶ Y) (x : ↑X)
Goal: (TopologicalSpace.OpenNhds.inclusionMapIso f x).inv =
  𝟙 (TopologicalSpace.OpenNhds.map f x ⋙ TopologicalSpace.OpenNhds.inclusion x)
-- IsOpenMap.functorNhds_obj_obj
@[simps]
def functorNhds (h : IsOpenMap f) (x : X) : OpenNhds x ⥤ OpenNhds (f x) 
Arguments: {X Y : TopCat} {f : X ⟶ Y} (h : IsOpenMap ⇑f) (x : ↑X) (U : TopologicalSpace.OpenNhds x)
Goal: ((h.functorNhds x).obj U).obj = h.functor.obj U.obj
-- IsOpenMap.functorNhds_map
@[simps]
def functorNhds (h : IsOpenMap f) (x : X) : OpenNhds x ⥤ OpenNhds (f x) 
Arguments: {X Y : TopCat} {f : X ⟶ Y} (h : IsOpenMap ⇑f) (x : ↑X)
Goal: ∀ {X_1 Y_1 : TopologicalSpace.OpenNhds x} (i : X_1 ⟶ Y_1), (h.functorNhds x).map i = h.functor.map i
-- continuous_from_compactlyGenerated
lemma continuous_from_compactlyGenerated {X : Type w} [TopologicalSpace X]
    {Y : Type*} [t : TopologicalSpace Y] (f : X → Y)
      (h : ∀ (S : CompHaus.{u}) (g : C(S, X)), Continuous (f ∘ g)) :
        Continuous[compactlyGenerated.{u} X, t] f 
Arguments: {X : Type w} [TopologicalSpace X] {Y : Type u_1} [t : TopologicalSpace Y] (f : X → Y) (h : ∀ (S : CompHaus) (g : C(↑S.toTop, X)), Continuous (f ∘ ⇑g))
Goal: Continuous f
-- UCompactlyGeneratedSpace.le_compactlyGenerated
class UCompactlyGeneratedSpace (X : Type w) [t : TopologicalSpace X] : Prop where
    le_compactlyGenerated : t ≤ compactlyGenerated.{u} X
Arguments: {X : Type w} [t : TopologicalSpace X] [self : UCompactlyGeneratedSpace X]
Goal: t ≤ TopologicalSpace.compactlyGenerated X
-- eq_compactlyGenerated
lemma eq_compactlyGenerated {X : Type w} [t : TopologicalSpace X] [UCompactlyGeneratedSpace.{u} X] :
    t = compactlyGenerated.{u} X 
Arguments: {X : Type w} [t : TopologicalSpace X] [UCompactlyGeneratedSpace X]
Goal: t = TopologicalSpace.compactlyGenerated X
-- continuous_from_uCompactlyGeneratedSpace
lemma continuous_from_uCompactlyGeneratedSpace {X : Type w} [TopologicalSpace X]
    [UCompactlyGeneratedSpace.{u} X] {Y : Type*} [TopologicalSpace Y] (f : X → Y)
      (h : ∀ (S : CompHaus.{u}) (g : C(S, X)), Continuous (f ∘ g)) : Continuous f 
Arguments: {X : Type w} [TopologicalSpace X] [UCompactlyGeneratedSpace X] {Y : Type u_1} [TopologicalSpace Y] (f : X → Y) (h : ∀ (S : CompHaus) (g : C(↑S.toTop, X)), Continuous (f ∘ ⇑g))
Goal: Continuous f
-- uCompactlyGeneratedSpace_of_continuous_maps
lemma uCompactlyGeneratedSpace_of_continuous_maps {X : Type w} [t : TopologicalSpace X]
    (h : ∀ {Y : Type w} [tY : TopologicalSpace Y] (f : X → Y),
      (∀ (S : CompHaus.{u}) (g : C(S, X)), Continuous (f ∘ g)) → Continuous f) :
        UCompactlyGeneratedSpace.{u} X 
Arguments: {X : Type w} [t : TopologicalSpace X] (h :
  ∀ {Y : Type w} [tY : TopologicalSpace Y] (f : X → Y),
    (∀ (S : CompHaus) (g : C(↑S.toTop, X)), Continuous (f ∘ ⇑g)) → Continuous f)
Goal: UCompactlyGeneratedSpace X
-- CompactlyGenerated.is_compactly_generated
structure CompactlyGenerated where
    toTop : TopCat.{w}
    [is_compactly_generated : UCompactlyGeneratedSpace.{u} toTop]
Arguments: (self : CompactlyGenerated)
Goal: UCompactlyGeneratedSpace ↑self.toTop
-- CompactlyGenerated.compactlyGeneratedToTop_obj
@[simps!]
def compactlyGeneratedToTop : CompactlyGenerated.{u, w} ⥤ TopCat.{w} 
Arguments: (self : CompactlyGenerated)
Goal: CompactlyGenerated.compactlyGeneratedToTop.obj self = self.toTop
-- CompactlyGenerated.compactlyGeneratedToTop_map
@[simps!]
def compactlyGeneratedToTop : CompactlyGenerated.{u, w} ⥤ TopCat.{w} 
Goal: ∀ {X Y : CategoryTheory.InducedCategory TopCat CompactlyGenerated.toTop} (f : X ⟶ Y),
  CompactlyGenerated.compactlyGeneratedToTop.map f = f
-- CompactlyGenerated.isoOfHomeo_inv
@[simps hom inv]
def isoOfHomeo {X Y : CompactlyGenerated.{u, w}} (f : X ≃ₜ Y) : X ≅ Y 
Arguments: {X Y : CompactlyGenerated} (f : ↑X.toTop ≃ₜ ↑Y.toTop)
Goal: (CompactlyGenerated.isoOfHomeo f).inv = { toFun := ⇑f.symm, continuous_toFun := ⋯ }
-- CompactlyGenerated.isoOfHomeo_hom
@[simps hom inv]
def isoOfHomeo {X Y : CompactlyGenerated.{u, w}} (f : X ≃ₜ Y) : X ≅ Y 
Arguments: {X Y : CompactlyGenerated} (f : ↑X.toTop ≃ₜ ↑Y.toTop)
Goal: (CompactlyGenerated.isoOfHomeo f).hom = { toFun := ⇑f, continuous_toFun := ⋯ }
-- CompactlyGenerated.homeoOfIso_symm_apply
@[simps]
def homeoOfIso {X Y : CompactlyGenerated.{u, w}} (f : X ≅ Y) : X ≃ₜ Y 
Arguments: {X Y : CompactlyGenerated} (f : X ≅ Y) (a : (CategoryTheory.forget CompactlyGenerated).obj Y)
Goal: (CompactlyGenerated.homeoOfIso f).symm a = f.inv a
-- CompactlyGenerated.homeoOfIso_apply
@[simps]
def homeoOfIso {X Y : CompactlyGenerated.{u, w}} (f : X ≅ Y) : X ≃ₜ Y 
Arguments: {X Y : CompactlyGenerated} (f : X ≅ Y) (a : (CategoryTheory.forget CompactlyGenerated).obj X)
Goal: (CompactlyGenerated.homeoOfIso f) a = f.hom a
-- CompactlyGenerated.isoEquivHomeo_apply
@[simps]
def isoEquivHomeo {X Y : CompactlyGenerated.{u, w}} : (X ≅ Y) ≃ (X ≃ₜ Y) 
Arguments: {X Y : CompactlyGenerated} (f : X ≅ Y)
Goal: CompactlyGenerated.isoEquivHomeo f = CompactlyGenerated.homeoOfIso f
-- CompactlyGenerated.isoEquivHomeo_symm_apply
@[simps]
def isoEquivHomeo {X Y : CompactlyGenerated.{u, w}} : (X ≅ Y) ≃ (X ≃ₜ Y) 
Arguments: {X Y : CompactlyGenerated} (f : ↑X.toTop ≃ₜ ↑Y.toTop)
Goal: CompactlyGenerated.isoEquivHomeo.symm f = CompactlyGenerated.isoOfHomeo f
-- Profinite.effectiveEpi_tfae
theorem effectiveEpi_tfae
    {B X : Profinite.{u}} (π : X ⟶ B) :
    TFAE
    [ EffectiveEpi π
    , Epi π
    , Function.Surjective π
    ] 
Arguments: {B X : Profinite} (π : X ⟶ B)
Goal: [CategoryTheory.EffectiveEpi π, CategoryTheory.Epi π, Function.Surjective ⇑π].TFAE
-- Profinite.effectiveEpiFamily_tfae
theorem effectiveEpiFamily_tfae
    {α : Type} [Finite α] {B : Profinite.{u}}
    (X : α → Profinite.{u}) (π : (a : α) → (X a ⟶ B)) :
    TFAE
    [ EffectiveEpiFamily X π
    , Epi (Sigma.desc π)
    , ∀ b : B, ∃ (a : α) (x : X a), π a x = b
    ] 
Arguments: {α : Type} [Finite α] {B : Profinite} (X : α → Profinite) (π : (a : α) → X a ⟶ B)
Goal: [CategoryTheory.EffectiveEpiFamily X π, CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π),
    ∀ (b : ↑B.toTop), ∃ a x, (π a) x = b].TFAE
-- Profinite.effectiveEpiFamily_of_jointly_surjective
theorem effectiveEpiFamily_of_jointly_surjective
    {α : Type} [Finite α] {B : Profinite.{u}}
    (X : α → Profinite.{u}) (π : (a : α) → (X a ⟶ B))
    (surj : ∀ b : B, ∃ (a : α) (x : X a), π a x = b) :
    EffectiveEpiFamily X π 
Arguments: {α : Type} [Finite α] {B : Profinite} (X : α → Profinite) (π : (a : α) → X a ⟶ B) (surj : ∀ (b : ↑B.toTop), ∃ a x, (π a) x = b)
Goal: CategoryTheory.EffectiveEpiFamily X π
-- Locale.coe_of
@[simp]
theorem coe_of (α : Type*) [Frame α] : ↥(of α) = α 
Arguments: (α : Type u_1) [Order.Frame α]
Goal: ↑(Opposite.unop (Locale.of α)) = α
-- topToLocale_obj
@[simps!]
def topToLocale : TopCat ⥤ Locale 
Arguments: (X : TopCat)
Goal: topToLocale.obj X = Opposite.op (Frm.of (TopologicalSpace.Opens ↑X))
-- topToLocale_map
@[simps!]
def topToLocale : TopCat ⥤ Locale 
Goal: ∀ {X Y : TopCat} (f : X ⟶ Y), topToLocale.map f = Quiver.Hom.op (TopologicalSpace.Opens.comap f)
-- TopCat.partialSections.nonempty
theorem partialSections.nonempty [IsCofilteredOrEmpty J] [h : ∀ j : J, Nonempty (F.obj j)]
    {G : Finset J} (H : Finset (FiniteDiagramArrow G)) : (partialSections F H).Nonempty 
Arguments: {J : Type u} [CategoryTheory.SmallCategory J] (F : J ⥤ TopCat) [CategoryTheory.IsCofilteredOrEmpty J] [h : ∀ (j : J), Nonempty ↑(F.obj j)] {G : Finset J} (H : Finset (TopCat.FiniteDiagramArrow G))
Goal: (TopCat.partialSections F H).Nonempty
-- TopCat.partialSections.directed
theorem partialSections.directed :
    Directed Superset fun G : FiniteDiagram J => partialSections F G.2 
Arguments: {J : Type u} [CategoryTheory.SmallCategory J] (F : J ⥤ TopCat)
Goal: Directed Superset fun G => TopCat.partialSections F G.snd
-- TopCat.partialSections.closed
theorem partialSections.closed [∀ j : J, T2Space (F.obj j)] {G : Finset J}
    (H : Finset (FiniteDiagramArrow G)) : IsClosed (partialSections F H) 
Arguments: {J : Type u} [CategoryTheory.SmallCategory J] (F : J ⥤ TopCat) [∀ (j : J), T2Space ↑(F.obj j)] {G : Finset J} (H : Finset (TopCat.FiniteDiagramArrow G))
Goal: IsClosed (TopCat.partialSections F H)
-- TopCat.nonempty_limitCone_of_compact_t2_cofiltered_system
-- Porting note: generalized from `TopCat.{u}` to `TopCat.{max v u}`
theorem nonempty_limitCone_of_compact_t2_cofiltered_system (F : J ⥤ TopCat.{max v u})
    [IsCofilteredOrEmpty J]
    [∀ j : J, Nonempty (F.obj j)] [∀ j : J, CompactSpace (F.obj j)] [∀ j : J, T2Space (F.obj j)] :
    Nonempty (TopCat.limitCone F).pt 
Arguments: {J : Type u} [CategoryTheory.SmallCategory J] (F : J ⥤ TopCat) [CategoryTheory.IsCofilteredOrEmpty J] [∀ (j : J), Nonempty ↑(F.obj j)] [∀ (j : J), CompactSpace ↑(F.obj j)] [∀ (j : J), T2Space ↑(F.obj j)]
Goal: Nonempty ↑(TopCat.limitCone F).pt
-- Cube.insertAt_boundary
theorem insertAt_boundary (i : N) {t₀ : I} {t}
    (H : (t₀ = 0 ∨ t₀ = 1) ∨ t ∈ boundary { j // j ≠ i }) : insertAt i ⟨t₀, t⟩ ∈ boundary N 
Arguments: {N : Type u_1} [DecidableEq N] (i : N) {t₀ : ↑I} {t : { j // j ≠ i } → ↑I} (H : (t₀ = 0 ∨ t₀ = 1) ∨ t ∈ Cube.boundary { j // j ≠ i })
Goal: (Cube.insertAt i) (t₀, t) ∈ Cube.boundary N
-- GenLoop.ext
@[ext]
theorem ext (f g : Ω^ N X x) (H : ∀ y, f y = g y) : f = g 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} (f g : ↑(Ω^ N X x)) (H : ∀ (y : N → ↑I), f y = g y)
Goal: f = g
-- GenLoop.mk_apply
@[simp]
theorem mk_apply (f : C(I^N, X)) (H y) : (⟨f, H⟩ : Ω^ N X x) y = f y 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} (f : C(N → ↑I, X)) (H : f ∈ Ω^ N X x) (y : N → ↑I)
Goal: ⟨f, H⟩ y = f y
-- GenLoop.coe_copy
theorem coe_copy (f : Ω^ N X x) {g : (I^N) → X} (h : g = f) : ⇑(copy f g h) = g 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} (f : ↑(Ω^ N X x)) {g : (N → ↑I) → X} (h : g = ⇑f)
Goal: ⇑(GenLoop.copy f g h) = g
-- GenLoop.copy_eq
theorem copy_eq (f : Ω^ N X x) {g : (I^N) → X} (h : g = f) : copy f g h = f 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} (f : ↑(Ω^ N X x)) {g : (N → ↑I) → X} (h : g = ⇑f)
Goal: GenLoop.copy f g h = f
-- GenLoop.boundary
theorem boundary (f : Ω^ N X x) : ∀ y ∈ Cube.boundary N, f y = x 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} (f : ↑(Ω^ N X x)) (y : N → ↑I)
Goal: y ∈ Cube.boundary N → f y = x
-- GenLoop.const_apply
@[simp]
theorem const_apply {t} : (@const N X _ x) t = x 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} {t : N → ↑I}
Goal: GenLoop.const t = x
-- GenLoop.Homotopic.refl
@[refl]
theorem refl (f : Ω^ N X x) : Homotopic f f 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} (f : ↑(Ω^ N X x))
Goal: GenLoop.Homotopic f f
-- GenLoop.Homotopic.symm
@[symm]
nonrec theorem symm (H : Homotopic f g) : Homotopic g f 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} {f g : ↑(Ω^ N X x)} (H : GenLoop.Homotopic f g)
Goal: GenLoop.Homotopic g f
-- GenLoop.Homotopic.trans
@[trans]
nonrec theorem trans (H0 : Homotopic f g) (H1 : Homotopic g h) : Homotopic f h 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} {f g h : ↑(Ω^ N X x)} (H0 : GenLoop.Homotopic f g) (H1 : GenLoop.Homotopic g h)
Goal: GenLoop.Homotopic f h
-- GenLoop.Homotopic.equiv
theorem equiv : Equivalence (@Homotopic N X _ x) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X}
Goal: Equivalence GenLoop.Homotopic
-- GenLoop.toLoop_apply_coe
@[simps]
def toLoop (i : N) (p : Ω^ N X x) : Ω (Ω^ { j // j ≠ i } X x) const 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) (p : ↑(Ω^ N X x)) (t : ↑I)
Goal: ↑((GenLoop.toLoop i p) t) = ((↑p).comp (Cube.insertAt i).toContinuousMap).curry t
-- GenLoop.continuous_toLoop
theorem continuous_toLoop (i : N) : Continuous (@toLoop N X _ x _ i) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N)
Goal: Continuous (GenLoop.toLoop i)
-- GenLoop.fromLoop_coe
@[simps]
def fromLoop (i : N) (p : Ω (Ω^ { j // j ≠ i } X x) const) : Ω^ N X x 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) (p : Ω (↑(Ω^ { j // j ≠ i } X x)) GenLoop.const)
Goal: ↑(GenLoop.fromLoop i p) =
  ({ toFun := Subtype.val, continuous_toFun := ⋯ }.comp p.toContinuousMap).uncurry.comp (Cube.splitAt i).toContinuousMap
-- GenLoop.continuous_fromLoop
theorem continuous_fromLoop (i : N) : Continuous (@fromLoop N X _ x _ i) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N)
Goal: Continuous (GenLoop.fromLoop i)
-- GenLoop.to_from
theorem to_from (i : N) (p : Ω (Ω^ { j // j ≠ i } X x) const) : toLoop i (fromLoop i p) = p 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) (p : Ω (↑(Ω^ { j // j ≠ i } X x)) GenLoop.const)
Goal: GenLoop.toLoop i (GenLoop.fromLoop i p) = p
-- GenLoop.loopHomeo_apply
@[simps]
def loopHomeo (i : N) : Ω^ N X x ≃ₜ Ω (Ω^ { j // j ≠ i } X x) const 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) (p : ↑(Ω^ N X x))
Goal: (GenLoop.loopHomeo i) p = GenLoop.toLoop i p
-- GenLoop.loopHomeo_symm_apply
@[simps]
def loopHomeo (i : N) : Ω^ N X x ≃ₜ Ω (Ω^ { j // j ≠ i } X x) const 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) (p : Ω (↑(Ω^ { j // j ≠ i } X x)) GenLoop.const)
Goal: (GenLoop.loopHomeo i).symm p = GenLoop.fromLoop i p
-- GenLoop.toLoop_apply
theorem toLoop_apply (i : N) {p : Ω^ N X x} {t} {tn} :
    toLoop i p t tn = p (Cube.insertAt i ⟨t, tn⟩) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) {p : ↑(Ω^ N X x)} {t : ↑I} {tn : { j // j ≠ i } → ↑I}
Goal: ((GenLoop.toLoop i p) t) tn = p ((Cube.insertAt i) (t, tn))
-- GenLoop.fromLoop_apply
theorem fromLoop_apply (i : N) {p : Ω (Ω^ { j // j ≠ i } X x) const} {t : I^N} :
    fromLoop i p t = p (t i) (Cube.splitAt i t).snd 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) {p : Ω (↑(Ω^ { j // j ≠ i } X x)) GenLoop.const} {t : N → ↑I}
Goal: (GenLoop.fromLoop i p) t = (p (t i)) ((Cube.splitAt i) t).2
-- GenLoop.homotopyTo_apply
theorem homotopyTo_apply (i : N) {p q : Ω^ N X x} (H : p.1.HomotopyRel q.1 <| Cube.boundary N)
    (t : I × I) (tₙ : I^{ j // j ≠ i }) :
    homotopyTo i H t tₙ = H (t.fst, Cube.insertAt i (t.snd, tₙ)) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) {p q : ↑(Ω^ N X x)} (H : (↑p).HomotopyRel (↑q) (Cube.boundary N)) (t : ↑I × ↑I) (tₙ : { j // j ≠ i } → ↑I)
Goal: ((GenLoop.homotopyTo i H) t) tₙ = H (t.1, (Cube.insertAt i) (t.2, tₙ))
-- GenLoop.homotopicTo
theorem homotopicTo (i : N) {p q : Ω^ N X x} :
    Homotopic p q → (toLoop i p).Homotopic (toLoop i q) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) {p q : ↑(Ω^ N X x)}
Goal: GenLoop.Homotopic p q → Path.Homotopic (GenLoop.toLoop i p) (GenLoop.toLoop i q)
-- GenLoop.homotopyFrom_apply
@[simps!] def homotopyFrom (i : N) {p q : Ω^ N X x} (H : (toLoop i p).Homotopy (toLoop i q)) :
    C(I × I^N, X) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) {p q : ↑(Ω^ N X x)} (H : Path.Homotopy (GenLoop.toLoop i p) (GenLoop.toLoop i q))
Goal: ∀ (a : ↑I × (N → ↑I)),
  (GenLoop.homotopyFrom i H) a =
    Function.uncurry (fun x_1 y => Function.uncurry (fun x_2 y => ↑(H (x_1, x_2)) y) y)
      (Prod.map id (⇑(Cube.splitAt i).toContinuousMap) a)
-- GenLoop.homotopicFrom
theorem homotopicFrom (i : N) {p q : Ω^ N X x} :
    (toLoop i p).Homotopic (toLoop i q) → Homotopic p q 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N) {p q : ↑(Ω^ N X x)}
Goal: Path.Homotopic (GenLoop.toLoop i p) (GenLoop.toLoop i q) → GenLoop.Homotopic p q
-- GenLoop.transAt_distrib
theorem transAt_distrib {i j : N} (h : i ≠ j) (a b c d : Ω^ N X x) :
    transAt i (transAt j a b) (transAt j c d) = transAt j (transAt i a c) (transAt i b d) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] {i j : N} (h : i ≠ j) (a b c d : ↑(Ω^ N X x))
Goal: GenLoop.transAt i (GenLoop.transAt j a b) (GenLoop.transAt j c d) =
  GenLoop.transAt j (GenLoop.transAt i a c) (GenLoop.transAt i b d)