File: Mathlib/Topology/Compactification/OnePoint.lean

full_name: OnePoint
code: /-- The OnePoint extension of an arbitrary topological space `X` -/
def OnePoint (X : Type*) 
goal: Type u_2

full_name: instReprOnePoint
code: /-- The repr uses the notation from the `OnePoint` locale. -/
instance [Repr X] : Repr (OnePoint X) 
goal: Repr (OnePoint X)

full_name: OnePoint.infty
code: /-- The point at infinity -/
@[match_pattern] def infty : OnePoint X 
goal: OnePoint X

full_name: OnePoint.«_aux_Mathlib_Topology_Compactification_OnePoint___macroRules_OnePoint_term∞_1»
code: @[inherit_doc]
scoped notation "∞" => OnePoint.infty
goal: Lean.Macro

full_name: OnePoint._aux_Mathlib_Topology_Compactification_OnePoint___unexpand_OnePoint_infty_1
code: @[inherit_doc]
scoped notation "∞" => OnePoint.infty
goal: Lean.PrettyPrinter.Unexpander

full_name: OnePoint.some
code: /-- Coercion from `X` to `OnePoint X`. -/
@[coe, match_pattern] def some : X → OnePoint X 
goal: X → OnePoint X

full_name: OnePoint.instCoeTC
code: instance : CoeTC X (OnePoint X) 
goal: CoeTC X (OnePoint X)

full_name: OnePoint.instInhabited
code: instance : Inhabited (OnePoint X) 
goal: Inhabited (OnePoint X)

full_name: OnePoint.forall
code: protected lemma «forall» {p : OnePoint X → Prop} :
    (∀ (x : OnePoint X), p x) ↔ p ∞ ∧ ∀ (x : X), p x 
goal: (∀ (x : OnePoint X), p x) ↔ p OnePoint.infty ∧ ∀ (x : X), p ↑x

full_name: OnePoint.exists
code: protected lemma «exists» {p : OnePoint X → Prop} :
    (∃ x, p x) ↔ p ∞ ∨ ∃ (x : X), p x 
goal: (∃ x, p x) ↔ p OnePoint.infty ∨ ∃ x, p ↑x

full_name: OnePoint.instFintype
code: instance [Fintype X] : Fintype (OnePoint X) 
goal: Fintype (OnePoint X)

full_name: OnePoint.infinite
code: instance infinite [Infinite X] : Infinite (OnePoint X) 
goal: Infinite (OnePoint X)

full_name: OnePoint.coe_injective
code: theorem coe_injective : Function.Injective ((↑) : X → OnePoint X) 
goal: Function.Injective OnePoint.some

full_name: OnePoint.coe_eq_coe
code: @[norm_cast]
theorem coe_eq_coe {x y : X} : (x : OnePoint X) = y ↔ x = y 
goal: ↑x = ↑y ↔ x = y

full_name: OnePoint.coe_ne_infty
code: @[simp]
theorem coe_ne_infty (x : X) : (x : OnePoint X) ≠ ∞ 
goal: ↑x ≠ OnePoint.infty

full_name: OnePoint.infty_ne_coe
code: @[simp]
theorem infty_ne_coe (x : X) : ∞ ≠ (x : OnePoint X) 
goal: OnePoint.infty ≠ ↑x

full_name: OnePoint.rec
code: /-- Recursor for `OnePoint` using the preferred forms `∞` and `↑x`. -/
@[elab_as_elim]
protected def rec {C : OnePoint X → Sort*} (h₁ : C ∞) (h₂ : ∀ x : X, C x) :
    ∀ z : OnePoint X, C z
  
goal: C z

full_name: OnePoint.isCompl_range_coe_infty
code: theorem isCompl_range_coe_infty : IsCompl (range ((↑) : X → OnePoint X)) {∞} 
goal: IsCompl (Set.range OnePoint.some) {OnePoint.infty}

full_name: OnePoint.range_coe_union_infty
code: theorem range_coe_union_infty : range ((↑) : X → OnePoint X) ∪ {∞} = univ 
goal: Set.range OnePoint.some ∪ {OnePoint.infty} = Set.univ

full_name: OnePoint.insert_infty_range_coe
code: @[simp]
theorem insert_infty_range_coe : insert ∞ (range (@some X)) = univ 
goal: insert OnePoint.infty (Set.range OnePoint.some) = Set.univ

full_name: OnePoint.range_coe_inter_infty
code: @[simp]
theorem range_coe_inter_infty : range ((↑) : X → OnePoint X) ∩ {∞} = ∅ 
goal: Set.range OnePoint.some ∩ {OnePoint.infty} = ∅

full_name: OnePoint.compl_range_coe
code: @[simp]
theorem compl_range_coe : (range ((↑) : X → OnePoint X))ᶜ = {∞} 
goal: (Set.range OnePoint.some)ᶜ = {OnePoint.infty}

full_name: OnePoint.compl_infty
code: theorem compl_infty : ({∞}ᶜ : Set (OnePoint X)) = range ((↑) : X → OnePoint X) 
goal: {OnePoint.infty}ᶜ = Set.range OnePoint.some

full_name: OnePoint.compl_image_coe
code: theorem compl_image_coe (s : Set X) : ((↑) '' s : Set (OnePoint X))ᶜ = (↑) '' sᶜ ∪ {∞} 
goal: (OnePoint.some '' s)ᶜ = OnePoint.some '' sᶜ ∪ {OnePoint.infty}

full_name: OnePoint.ne_infty_iff_exists
code: theorem ne_infty_iff_exists {x : OnePoint X} : x ≠ ∞ ↔ ∃ y : X, (y : OnePoint X) = x 
goal: x ≠ OnePoint.infty ↔ ∃ y, ↑y = x

full_name: OnePoint.canLift
code: instance canLift : CanLift (OnePoint X) X (↑) fun x => x ≠ ∞ 
goal: CanLift (OnePoint X) X OnePoint.some fun x => x ≠ OnePoint.infty

full_name: OnePoint.not_mem_range_coe_iff
code: theorem not_mem_range_coe_iff {x : OnePoint X} : x ∉ range some ↔ x = ∞ 
goal: x ∉ Set.range OnePoint.some ↔ x = OnePoint.infty

full_name: OnePoint.infty_not_mem_range_coe
code: theorem infty_not_mem_range_coe : ∞ ∉ range ((↑) : X → OnePoint X) 
goal: OnePoint.infty ∉ Set.range OnePoint.some

full_name: OnePoint.infty_not_mem_image_coe
code: theorem infty_not_mem_image_coe {s : Set X} : ∞ ∉ ((↑) : X → OnePoint X) '' s 
goal: OnePoint.infty ∉ OnePoint.some '' s

full_name: OnePoint.coe_preimage_infty
code: @[simp]
theorem coe_preimage_infty : ((↑) : X → OnePoint X) ⁻¹' {∞} = ∅ 
goal: OnePoint.some ⁻¹' {OnePoint.infty} = ∅

full_name: OnePoint.instTopologicalSpace
code: instance : TopologicalSpace (OnePoint X) 
goal: TopologicalSpace (OnePoint X)

full_name: OnePoint.isOpen_def
code: theorem isOpen_def :
    IsOpen s ↔ (∞ ∈ s → IsCompact ((↑) ⁻¹' s : Set X)ᶜ) ∧ IsOpen ((↑) ⁻¹' s : Set X) 
goal: IsOpen s ↔ (OnePoint.infty ∈ s → IsCompact (OnePoint.some ⁻¹' s)ᶜ) ∧ IsOpen (OnePoint.some ⁻¹' s)

full_name: OnePoint.isOpen_iff_of_mem'
code: theorem isOpen_iff_of_mem' (h : ∞ ∈ s) :
    IsOpen s ↔ IsCompact ((↑) ⁻¹' s : Set X)ᶜ ∧ IsOpen ((↑) ⁻¹' s : Set X) 
goal: IsOpen s ↔ IsCompact (OnePoint.some ⁻¹' s)ᶜ ∧ IsOpen (OnePoint.some ⁻¹' s)

full_name: OnePoint.isOpen_iff_of_mem
code: theorem isOpen_iff_of_mem (h : ∞ ∈ s) :
    IsOpen s ↔ IsClosed ((↑) ⁻¹' s : Set X)ᶜ ∧ IsCompact ((↑) ⁻¹' s : Set X)ᶜ 
goal: IsOpen s ↔ IsClosed (OnePoint.some ⁻¹' s)ᶜ ∧ IsCompact (OnePoint.some ⁻¹' s)ᶜ

full_name: OnePoint.isOpen_iff_of_not_mem
code: theorem isOpen_iff_of_not_mem (h : ∞ ∉ s) : IsOpen s ↔ IsOpen ((↑) ⁻¹' s : Set X) 
goal: IsOpen s ↔ IsOpen (OnePoint.some ⁻¹' s)

full_name: OnePoint.isClosed_iff_of_mem
code: theorem isClosed_iff_of_mem (h : ∞ ∈ s) : IsClosed s ↔ IsClosed ((↑) ⁻¹' s : Set X) 
goal: IsClosed s ↔ IsClosed (OnePoint.some ⁻¹' s)

full_name: OnePoint.isClosed_iff_of_not_mem
code: theorem isClosed_iff_of_not_mem (h : ∞ ∉ s) :
    IsClosed s ↔ IsClosed ((↑) ⁻¹' s : Set X) ∧ IsCompact ((↑) ⁻¹' s : Set X) 
goal: IsClosed s ↔ IsClosed (OnePoint.some ⁻¹' s) ∧ IsCompact (OnePoint.some ⁻¹' s)

full_name: OnePoint.isOpen_image_coe
code: @[simp]
theorem isOpen_image_coe {s : Set X} : IsOpen ((↑) '' s : Set (OnePoint X)) ↔ IsOpen s 
goal: IsOpen (OnePoint.some '' s) ↔ IsOpen s

full_name: OnePoint.isOpen_compl_image_coe
code: theorem isOpen_compl_image_coe {s : Set X} :
    IsOpen ((↑) '' s : Set (OnePoint X))ᶜ ↔ IsClosed s ∧ IsCompact s 
goal: IsOpen (OnePoint.some '' s)ᶜ ↔ IsClosed s ∧ IsCompact s

full_name: OnePoint.isClosed_image_coe
code: @[simp]
theorem isClosed_image_coe {s : Set X} :
    IsClosed ((↑) '' s : Set (OnePoint X)) ↔ IsClosed s ∧ IsCompact s 
goal: IsClosed (OnePoint.some '' s) ↔ IsClosed s ∧ IsCompact s

full_name: OnePoint.opensOfCompl
code: /-- An open set in `OnePoint X` constructed from a closed compact set in `X` -/
def opensOfCompl (s : Set X) (h₁ : IsClosed s) (h₂ : IsCompact s) :
    TopologicalSpace.Opens (OnePoint X) 
goal: TopologicalSpace.Opens (OnePoint X)

full_name: OnePoint.infty_mem_opensOfCompl
code: theorem infty_mem_opensOfCompl {s : Set X} (h₁ : IsClosed s) (h₂ : IsCompact s) :
    ∞ ∈ opensOfCompl s h₁ h₂ 
goal: OnePoint.infty ∈ OnePoint.opensOfCompl s h₁ h₂

full_name: OnePoint.continuous_coe
code: @[continuity]
theorem continuous_coe : Continuous ((↑) : X → OnePoint X) 
goal: Continuous OnePoint.some

full_name: OnePoint.isOpenMap_coe
code: theorem isOpenMap_coe : IsOpenMap ((↑) : X → OnePoint X) 
goal: IsOpenMap OnePoint.some

full_name: OnePoint.openEmbedding_coe
code: theorem openEmbedding_coe : OpenEmbedding ((↑) : X → OnePoint X) 
goal: OpenEmbedding OnePoint.some

full_name: OnePoint.isOpen_range_coe
code: theorem isOpen_range_coe : IsOpen (range ((↑) : X → OnePoint X)) 
goal: IsOpen (Set.range OnePoint.some)

full_name: OnePoint.isClosed_infty
code: theorem isClosed_infty : IsClosed ({∞} : Set (OnePoint X)) 
goal: IsClosed {OnePoint.infty}

full_name: OnePoint.nhds_coe_eq
code: theorem nhds_coe_eq (x : X) : 𝓝 ↑x = map ((↑) : X → OnePoint X) (𝓝 x) 
goal: 𝓝 ↑x = Filter.map OnePoint.some (𝓝 x)

full_name: OnePoint.nhdsWithin_coe_image
code: theorem nhdsWithin_coe_image (s : Set X) (x : X) :
    𝓝[(↑) '' s] (x : OnePoint X) = map (↑) (𝓝[s] x) 
goal: 𝓝[OnePoint.some '' s] ↑x = Filter.map OnePoint.some (𝓝[s] x)

full_name: OnePoint.nhdsWithin_coe
code: theorem nhdsWithin_coe (s : Set (OnePoint X)) (x : X) : 𝓝[s] ↑x = map (↑) (𝓝[(↑) ⁻¹' s] x) 
goal: 𝓝[s] ↑x = Filter.map OnePoint.some (𝓝[OnePoint.some ⁻¹' s] x)

full_name: OnePoint.comap_coe_nhds
code: theorem comap_coe_nhds (x : X) : comap ((↑) : X → OnePoint X) (𝓝 x) = 𝓝 x 
goal: Filter.comap OnePoint.some (𝓝 ↑x) = 𝓝 x

full_name: OnePoint.nhdsWithin_compl_coe_neBot
code: /-- If `x` is not an isolated point of `X`, then `x : OnePoint X` is not an isolated point
of `OnePoint X`. -/
instance nhdsWithin_compl_coe_neBot (x : X) [h : NeBot (𝓝[≠] x)] :
    NeBot (𝓝[≠] (x : OnePoint X)) 
goal: (𝓝[≠] ↑x).NeBot

full_name: OnePoint.nhdsWithin_compl_infty_eq
code: theorem nhdsWithin_compl_infty_eq : 𝓝[≠] (∞ : OnePoint X) = map (↑) (coclosedCompact X) 
goal: 𝓝[≠] OnePoint.infty = Filter.map OnePoint.some (Filter.coclosedCompact X)

full_name: OnePoint.nhdsWithin_compl_infty_neBot
code: /-- If `X` is a non-compact space, then `∞` is not an isolated point of `OnePoint X`. -/
instance nhdsWithin_compl_infty_neBot [NoncompactSpace X] : NeBot (𝓝[≠] (∞ : OnePoint X)) 
goal: (𝓝[≠] OnePoint.infty).NeBot

full_name: OnePoint.nhdsWithin_compl_neBot
code: instance (priority := 900) nhdsWithin_compl_neBot [∀ x : X, NeBot (𝓝[≠] x)] [NoncompactSpace X]
    (x : OnePoint X) : NeBot (𝓝[≠] x) 
goal: (𝓝[≠] x).NeBot

full_name: OnePoint.nhds_infty_eq
code: theorem nhds_infty_eq : 𝓝 (∞ : OnePoint X) = map (↑) (coclosedCompact X) ⊔ pure ∞ 
goal: 𝓝 OnePoint.infty = Filter.map OnePoint.some (Filter.coclosedCompact X) ⊔ pure OnePoint.infty

full_name: OnePoint.tendsto_coe_infty
code: theorem tendsto_coe_infty : Tendsto (↑) (coclosedCompact X) (𝓝 (∞ : OnePoint X)) 
goal: Filter.Tendsto OnePoint.some (Filter.coclosedCompact X) (𝓝 OnePoint.infty)

full_name: OnePoint.hasBasis_nhds_infty
code: theorem hasBasis_nhds_infty :
    (𝓝 (∞ : OnePoint X)).HasBasis (fun s : Set X => IsClosed s ∧ IsCompact s) fun s =>
      (↑) '' sᶜ ∪ {∞} 
goal: (𝓝 OnePoint.infty).HasBasis (fun s => IsClosed s ∧ IsCompact s) fun s => OnePoint.some '' sᶜ ∪ {OnePoint.infty}

full_name: OnePoint.comap_coe_nhds_infty
code: @[simp]
theorem comap_coe_nhds_infty : comap ((↑) : X → OnePoint X) (𝓝 ∞) = coclosedCompact X 
goal: Filter.comap OnePoint.some (𝓝 OnePoint.infty) = Filter.coclosedCompact X

full_name: OnePoint.le_nhds_infty
code: theorem le_nhds_infty {f : Filter (OnePoint X)} :
    f ≤ 𝓝 ∞ ↔ ∀ s : Set X, IsClosed s → IsCompact s → (↑) '' sᶜ ∪ {∞} ∈ f 
goal: f ≤ 𝓝 OnePoint.infty ↔ ∀ (s : Set X), IsClosed s → IsCompact s → OnePoint.some '' sᶜ ∪ {OnePoint.infty} ∈ f

full_name: OnePoint.ultrafilter_le_nhds_infty
code: theorem ultrafilter_le_nhds_infty {f : Ultrafilter (OnePoint X)} :
    (f : Filter (OnePoint X)) ≤ 𝓝 ∞ ↔ ∀ s : Set X, IsClosed s → IsCompact s → (↑) '' s ∉ f 
goal: ↑f ≤ 𝓝 OnePoint.infty ↔ ∀ (s : Set X), IsClosed s → IsCompact s → OnePoint.some '' s ∉ f

full_name: OnePoint.tendsto_nhds_infty'
code: theorem tendsto_nhds_infty' {α : Type*} {f : OnePoint X → α} {l : Filter α} :
    Tendsto f (𝓝 ∞) l ↔ Tendsto f (pure ∞) l ∧ Tendsto (f ∘ (↑)) (coclosedCompact X) l 
goal: Filter.Tendsto f (𝓝 OnePoint.infty) l ↔
  Filter.Tendsto f (pure OnePoint.infty) l ∧ Filter.Tendsto (f ∘ OnePoint.some) (Filter.coclosedCompact X) l

full_name: OnePoint.tendsto_nhds_infty
code: theorem tendsto_nhds_infty {α : Type*} {f : OnePoint X → α} {l : Filter α} :
    Tendsto f (𝓝 ∞) l ↔
      ∀ s ∈ l, f ∞ ∈ s ∧ ∃ t : Set X, IsClosed t ∧ IsCompact t ∧ MapsTo (f ∘ (↑)) tᶜ s 
goal: Filter.Tendsto f (𝓝 OnePoint.infty) l ↔
  ∀ s ∈ l, f OnePoint.infty ∈ s ∧ ∃ t, IsClosed t ∧ IsCompact t ∧ Set.MapsTo (f ∘ OnePoint.some) tᶜ s

full_name: OnePoint.continuousAt_infty'
code: theorem continuousAt_infty' {Y : Type*} [TopologicalSpace Y] {f : OnePoint X → Y} :
    ContinuousAt f ∞ ↔ Tendsto (f ∘ (↑)) (coclosedCompact X) (𝓝 (f ∞)) 
goal: ContinuousAt f OnePoint.infty ↔ Filter.Tendsto (f ∘ OnePoint.some) (Filter.coclosedCompact X) (𝓝 (f OnePoint.infty))

full_name: OnePoint.continuousAt_infty
code: theorem continuousAt_infty {Y : Type*} [TopologicalSpace Y] {f : OnePoint X → Y} :
    ContinuousAt f ∞ ↔
      ∀ s ∈ 𝓝 (f ∞), ∃ t : Set X, IsClosed t ∧ IsCompact t ∧ MapsTo (f ∘ (↑)) tᶜ s 
goal: ContinuousAt f OnePoint.infty ↔
  ∀ s ∈ 𝓝 (f OnePoint.infty), ∃ t, IsClosed t ∧ IsCompact t ∧ Set.MapsTo (f ∘ OnePoint.some) tᶜ s

full_name: OnePoint.continuousAt_coe
code: theorem continuousAt_coe {Y : Type*} [TopologicalSpace Y] {f : OnePoint X → Y} {x : X} :
    ContinuousAt f x ↔ ContinuousAt (f ∘ (↑)) x 
goal: ContinuousAt f ↑x ↔ ContinuousAt (f ∘ OnePoint.some) x

full_name: OnePoint.continuous_iff
code: lemma continuous_iff {Y : Type*} [TopologicalSpace Y] (f : OnePoint X → Y) : Continuous f ↔
    Tendsto (fun x : X ↦ f x) (coclosedCompact X) (𝓝 (f ∞)) ∧ Continuous (fun x : X ↦ f x) 
goal: Continuous f ↔
  Filter.Tendsto (fun x => f ↑x) (Filter.coclosedCompact X) (𝓝 (f OnePoint.infty)) ∧ Continuous fun x => f ↑x

full_name: OnePoint.continuousMapMk
code: /--
A constructor for continuous maps out of a one point compactification, given a continuous map from
the underlying space and a limit value at infinity.
-/
def continuousMapMk {Y : Type*} [TopologicalSpace Y] (f : C(X, Y)) (y : Y)
    (h : Tendsto f (coclosedCompact X) (𝓝 y)) : C(OnePoint X, Y) 
goal: C(OnePoint X, Y)

full_name: OnePoint.continuous_iff_from_discrete
code: lemma continuous_iff_from_discrete {Y : Type*} [TopologicalSpace Y]
    [DiscreteTopology X] (f : OnePoint X → Y) :
    Continuous f ↔ Tendsto (fun x : X ↦ f x) cofinite (𝓝 (f ∞)) 
goal: Continuous f ↔ Filter.Tendsto (fun x => f ↑x) Filter.cofinite (𝓝 (f OnePoint.infty))

full_name: OnePoint.continuousMapMkDiscrete
code: /--
A constructor for continuous maps out of a one point compactification of a discrete space, given a
map from the underlying space and a limit value at infinity.
-/
def continuousMapMkDiscrete {Y : Type*} [TopologicalSpace Y]
    [DiscreteTopology X] (f : X → Y) (y : Y) (h : Tendsto f cofinite (𝓝 y)) :
    C(OnePoint X, Y) 
goal: C(OnePoint X, Y)

full_name: OnePoint.continuousMapDiscreteEquiv
code: /--
Continuous maps out of the one point compactification of an infinite discrete space to a Hausdorff
space correspond bijectively to "convergent" maps out of the discrete space.
-/
noncomputable def continuousMapDiscreteEquiv (Y : Type*) [DiscreteTopology X] [TopologicalSpace Y]
    [T2Space Y] [Infinite X] :
    C(OnePoint X, Y) ≃ { f : X → Y // ∃ L, Tendsto (fun x : X ↦ f x) cofinite (𝓝 L) } 
goal: C(OnePoint X, Y) ≃ { f // ∃ L, Filter.Tendsto (fun x => f x) Filter.cofinite (𝓝 L) }

full_name: OnePoint.continuous_iff_from_nat
code: lemma continuous_iff_from_nat {Y : Type*} [TopologicalSpace Y] (f : OnePoint ℕ → Y) :
    Continuous f ↔ Tendsto (fun x : ℕ ↦ f x) atTop (𝓝 (f ∞)) 
goal: Continuous f ↔ Filter.Tendsto (fun x => f ↑x) Filter.atTop (𝓝 (f OnePoint.infty))

full_name: OnePoint.continuousMapMkNat
code: /--
A constructor for continuous maps out of the one point compactification of `ℕ`, given a
sequence and a limit value at infinity.
-/
def continuousMapMkNat {Y : Type*} [TopologicalSpace Y]
    (f : ℕ → Y) (y : Y) (h : Tendsto f atTop (𝓝 y)) :
    C(OnePoint ℕ, Y) 
goal: C(OnePoint ℕ, Y)

full_name: OnePoint.continuousMapNatEquiv
code: /--
Continuous maps out of the one point compactification of `ℕ` to a Hausdorff space `Y` correspond
bijectively to convergent sequences in `Y`.
-/
noncomputable def continuousMapNatEquiv (Y : Type*) [TopologicalSpace Y] [T2Space Y] :
    C(OnePoint ℕ, Y) ≃ { f : ℕ → Y // ∃ L, Tendsto (f ·) atTop (𝓝 L) } 
goal: C(OnePoint ℕ, Y) ≃ { f // ∃ L, Filter.Tendsto (fun x => f x) Filter.atTop (𝓝 L) }

full_name: OnePoint.denseRange_coe
code: /-- If `X` is not a compact space, then the natural embedding `X → OnePoint X` has dense range.
-/
theorem denseRange_coe [NoncompactSpace X] : DenseRange ((↑) : X → OnePoint X) 
goal: DenseRange OnePoint.some

full_name: OnePoint.denseEmbedding_coe
code: theorem denseEmbedding_coe [NoncompactSpace X] : DenseEmbedding ((↑) : X → OnePoint X) 
goal: DenseEmbedding OnePoint.some

full_name: OnePoint.specializes_coe
code: @[simp, norm_cast]
theorem specializes_coe {x y : X} : (x : OnePoint X) ⤳ y ↔ x ⤳ y 
goal: ↑x ⤳ ↑y ↔ x ⤳ y

full_name: OnePoint.inseparable_coe
code: @[simp, norm_cast]
theorem inseparable_coe {x y : X} : Inseparable (x : OnePoint X) y ↔ Inseparable x y 
goal: Inseparable ↑x ↑y ↔ Inseparable x y

full_name: OnePoint.not_specializes_infty_coe
code: theorem not_specializes_infty_coe {x : X} : ¬Specializes ∞ (x : OnePoint X) 
goal: ¬OnePoint.infty ⤳ ↑x

full_name: OnePoint.not_inseparable_infty_coe
code: theorem not_inseparable_infty_coe {x : X} : ¬Inseparable ∞ (x : OnePoint X) 
goal: ¬Inseparable OnePoint.infty ↑x

full_name: OnePoint.not_inseparable_coe_infty
code: theorem not_inseparable_coe_infty {x : X} : ¬Inseparable (x : OnePoint X) ∞ 
goal: ¬Inseparable (↑x) OnePoint.infty

full_name: OnePoint.inseparable_iff
code: theorem inseparable_iff {x y : OnePoint X} :
    Inseparable x y ↔ x = ∞ ∧ y = ∞ ∨ ∃ x' : X, x = x' ∧ ∃ y' : X, y = y' ∧ Inseparable x' y' 
goal: Inseparable x y ↔ x = OnePoint.infty ∧ y = OnePoint.infty ∨ ∃ x', x = ↑x' ∧ ∃ y', y = ↑y' ∧ Inseparable x' y'

full_name: OnePoint.instCompactSpace
code: /-- For any topological space `X`, its one point compactification is a compact space. -/
instance : CompactSpace (OnePoint X) 
goal: CompactSpace (OnePoint X)

full_name: OnePoint.instT0Space
code: /-- The one point compactification of a `T0Space` space is a `T0Space`. -/
instance [T0Space X] : T0Space (OnePoint X) 
goal: T0Space (OnePoint X)

full_name: OnePoint.instT1Space
code: /-- The one point compactification of a `T1Space` space is a `T1Space`. -/
instance [T1Space X] : T1Space (OnePoint X) 
goal: T1Space (OnePoint X)

full_name: OnePoint.instNormalSpaceOfLocallyCompactSpaceOfR1Space
code: /-- The one point compactification of a locally compact R₁ space is a normal topological space. -/
instance [LocallyCompactSpace X] [R1Space X] : NormalSpace (OnePoint X) 
goal: NormalSpace (OnePoint X)

full_name: OnePoint.instConnectedSpaceOfPreconnectedSpaceOfNoncompactSpace
code: /-- If `X` is not a compact space, then `OnePoint X` is a connected space. -/
instance [PreconnectedSpace X] [NoncompactSpace X] : ConnectedSpace (OnePoint X) 
goal: ConnectedSpace (OnePoint X)

full_name: OnePoint.not_continuous_cofiniteTopology_of_symm
code: /-- If `X` is an infinite type with discrete topology (e.g., `ℕ`), then the identity map from
`CofiniteTopology (OnePoint X)` to `OnePoint X` is not continuous. -/
theorem not_continuous_cofiniteTopology_of_symm [Infinite X] [DiscreteTopology X] :
    ¬Continuous (@CofiniteTopology.of (OnePoint X)).symm 
goal: ¬Continuous ⇑CofiniteTopology.of.symm

full_name: OnePoint.instTotallySeparatedSpaceOfDiscreteTopology
code: instance (X : Type*) [TopologicalSpace X] [DiscreteTopology X] :
    TotallySeparatedSpace (OnePoint X) 
goal: TotallySeparatedSpace (OnePoint X)

full_name: Continuous.homeoOfEquivCompactToT2.t1_counterexample
code: /-- A concrete counterexample shows that `Continuous.homeoOfEquivCompactToT2`
cannot be generalized from `T2Space` to `T1Space`.

Let `α = OnePoint ℕ` be the one-point compactification of `ℕ`, and let `β` be the same space
`OnePoint ℕ` with the cofinite topology.  Then `α` is compact, `β` is T1, and the identity map
`id : α → β` is a continuous equivalence that is not a homeomorphism.
-/
theorem Continuous.homeoOfEquivCompactToT2.t1_counterexample :
    ∃ (α β : Type) (_ : TopologicalSpace α) (_ : TopologicalSpace β),
      CompactSpace α ∧ T1Space β ∧ ∃ f : α ≃ β, Continuous f ∧ ¬Continuous f.symm 
goal: ∃ α β x x_1, CompactSpace α ∧ T1Space β ∧ ∃ f, Continuous ⇑f ∧ ¬Continuous ⇑f.symm