File: Mathlib/SetTheory/Ordinal/Topology.lean

full_name: Ordinal.instTopologicalSpace
code: instance : TopologicalSpace Ordinal.{u} 
goal: TopologicalSpace Ordinal.{u}

full_name: Ordinal.instOrderTopology
code: instance : OrderTopology Ordinal.{u} 
goal: OrderTopology Ordinal.{u}

full_name: Ordinal.isOpen_singleton_iff
code: theorem isOpen_singleton_iff : IsOpen ({a} : Set Ordinal) ↔ ¬IsLimit a 
goal: IsOpen {a} ↔ ¬a.IsLimit

full_name: Ordinal.nhds_right'
code: theorem nhds_right' (a : Ordinal) : 𝓝[>] a = ⊥ 
goal: 𝓝[>] a = ⊥

full_name: Ordinal.nhds_left'_eq_nhds_ne
code: theorem nhds_left'_eq_nhds_ne (a : Ordinal) : 𝓝[<] a = 𝓝[≠] a 
goal: 𝓝[<] a = 𝓝[≠] a

full_name: Ordinal.nhds_left_eq_nhds
code: theorem nhds_left_eq_nhds (a : Ordinal) : 𝓝[≤] a = 𝓝 a 
goal: 𝓝[≤] a = 𝓝 a

full_name: Ordinal.nhdsBasis_Ioc
code: theorem nhdsBasis_Ioc (h : a ≠ 0) : (𝓝 a).HasBasis (· < a) (Set.Ioc · a) 
goal: (𝓝 a).HasBasis (fun x => x < a) fun x => Set.Ioc x a

full_name: Ordinal.nhds_eq_pure
code: theorem nhds_eq_pure : 𝓝 a = pure a ↔ ¬IsLimit a 
goal: 𝓝 a = pure a ↔ ¬a.IsLimit

full_name: Ordinal.isOpen_iff
code: theorem isOpen_iff : IsOpen s ↔ ∀ o ∈ s, IsLimit o → ∃ a < o, Set.Ioo a o ⊆ s 
goal: IsOpen s ↔ ∀ o ∈ s, o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s

full_name: Ordinal.mem_closure_tfae
code: theorem mem_closure_tfae (a : Ordinal.{u}) (s : Set Ordinal) :
    TFAE [a ∈ closure s,
      a ∈ closure (s ∩ Iic a),
      (s ∩ Iic a).Nonempty ∧ sSup (s ∩ Iic a) = a,
      ∃ t, t ⊆ s ∧ t.Nonempty ∧ BddAbove t ∧ sSup t = a,
      ∃ (o : Ordinal.{u}), o ≠ 0 ∧ ∃ (f : ∀ x < o, Ordinal),
        (∀ x hx, f x hx ∈ s) ∧ bsup.{u, u} o f = a,
      ∃ (ι : Type u), Nonempty ι ∧ ∃ f : ι → Ordinal, (∀ i, f i ∈ s) ∧ sup.{u, u} f = a] 
goal: [a ∈ closure s, a ∈ closure (s ∩ Set.Iic a), (s ∩ Set.Iic a).Nonempty ∧ sSup (s ∩ Set.Iic a) = a,
    ∃ t ⊆ s, t.Nonempty ∧ BddAbove t ∧ sSup t = a,
    ∃ o, o ≠ 0 ∧ ∃ f, (∀ (x : Ordinal.{u}) (hx : x < o), f x hx ∈ s) ∧ o.bsup f = a,
    ∃ ι, Nonempty ι ∧ ∃ f, (∀ (i : ι), f i ∈ s) ∧ Ordinal.sup f = a].TFAE

full_name: Ordinal.mem_closure_iff_sup
code: theorem mem_closure_iff_sup :
    a ∈ closure s ↔
      ∃ (ι : Type u) (_ : Nonempty ι) (f : ι → Ordinal), (∀ i, f i ∈ s) ∧ sup.{u, u} f = a 
goal: a ∈ closure s ↔ ∃ ι, ∃ (_ : Nonempty ι), ∃ f, (∀ (i : ι), f i ∈ s) ∧ Ordinal.sup f = a

full_name: Ordinal.mem_closed_iff_sup
code: theorem mem_closed_iff_sup (hs : IsClosed s) :
    a ∈ s ↔ ∃ (ι : Type u) (_hι : Nonempty ι) (f : ι → Ordinal),
      (∀ i, f i ∈ s) ∧ sup.{u, u} f = a 
goal: a ∈ s ↔ ∃ ι, ∃ (_ : Nonempty ι), ∃ f, (∀ (i : ι), f i ∈ s) ∧ Ordinal.sup f = a

full_name: Ordinal.mem_closure_iff_bsup
code: theorem mem_closure_iff_bsup :
    a ∈ closure s ↔
      ∃ (o : Ordinal) (_ho : o ≠ 0) (f : ∀ a < o, Ordinal),
        (∀ i hi, f i hi ∈ s) ∧ bsup.{u, u} o f = a 
goal: a ∈ closure s ↔ ∃ o, ∃ (_ : o ≠ 0), ∃ f, (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) ∧ o.bsup f = a

full_name: Ordinal.mem_closed_iff_bsup
code: theorem mem_closed_iff_bsup (hs : IsClosed s) :
    a ∈ s ↔
      ∃ (o : Ordinal) (_ho : o ≠ 0) (f : ∀ a < o, Ordinal),
        (∀ i hi, f i hi ∈ s) ∧ bsup.{u, u} o f = a 
goal: a ∈ s ↔ ∃ o, ∃ (_ : o ≠ 0), ∃ f, (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) ∧ o.bsup f = a

full_name: Ordinal.isClosed_iff_sup
code: theorem isClosed_iff_sup :
    IsClosed s ↔
      ∀ {ι : Type u}, Nonempty ι → ∀ f : ι → Ordinal, (∀ i, f i ∈ s) → sup.{u, u} f ∈ s 
goal: IsClosed s ↔ ∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → Ordinal.sup f ∈ s

full_name: Ordinal.isClosed_iff_bsup
code: theorem isClosed_iff_bsup :
    IsClosed s ↔
      ∀ {o : Ordinal}, o ≠ 0 → ∀ f : ∀ a < o, Ordinal,
        (∀ i hi, f i hi ∈ s) → bsup.{u, u} o f ∈ s 
goal: IsClosed s ↔
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s

full_name: Ordinal.isLimit_of_mem_frontier
code: theorem isLimit_of_mem_frontier (ha : a ∈ frontier s) : IsLimit a 
goal: a.IsLimit

full_name: Ordinal.isNormal_iff_strictMono_and_continuous
code: theorem isNormal_iff_strictMono_and_continuous (f : Ordinal.{u} → Ordinal.{u}) :
    IsNormal f ↔ StrictMono f ∧ Continuous f 
goal: Ordinal.IsNormal f ↔ StrictMono f ∧ Continuous f

full_name: Ordinal.enumOrd_isNormal_iff_isClosed
code: theorem enumOrd_isNormal_iff_isClosed (hs : s.Unbounded (· < ·)) :
    IsNormal (enumOrd s) ↔ IsClosed s 
goal: Ordinal.IsNormal (Ordinal.enumOrd s) ↔ IsClosed s