File: Mathlib/Topology/Order/UpperLowerSetTopology.lean

full_name: Topology.upperSet
code: /-- Topology whose open sets are upper sets.

Note: In general the upper set topology does not coincide with the upper topology. -/
def upperSet (α :  Type*) [Preorder α] : TopologicalSpace α 
goal: TopologicalSpace α

full_name: Topology.lowerSet
code: /-- Topology whose open sets are lower sets.

Note: In general the lower set topology does not coincide with the lower topology. -/
def lowerSet (α :  Type*) [Preorder α] : TopologicalSpace α 
goal: TopologicalSpace α

full_name: Topology.WithUpperSet
code: /-- Type synonym for a preorder equipped with the upper set topology. -/
def WithUpperSet (α : Type*) 
goal: Type u_4

full_name: Topology.WithUpperSet.toUpperSet
code: /-- `toUpperSet` is the identity function to the `WithUpperSet` of a type.  -/
@[match_pattern] def toUpperSet : α ≃ WithUpperSet α 
goal: α ≃ Topology.WithUpperSet α

full_name: Topology.WithUpperSet.ofUpperSet
code: /-- `ofUpperSet` is the identity function from the `WithUpperSet` of a type.  -/
@[match_pattern] def ofUpperSet : WithUpperSet α ≃ α 
goal: Topology.WithUpperSet α ≃ α

full_name: Topology.WithUpperSet.to_WithUpperSet_symm_eq
code: @[simp] lemma to_WithUpperSet_symm_eq : (@toUpperSet α).symm = ofUpperSet 
goal: Topology.WithUpperSet.toUpperSet.symm = Topology.WithUpperSet.ofUpperSet

full_name: Topology.WithUpperSet.of_WithUpperSet_symm_eq
code: @[simp] lemma of_WithUpperSet_symm_eq : (@ofUpperSet α).symm = toUpperSet 
goal: Topology.WithUpperSet.ofUpperSet.symm = Topology.WithUpperSet.toUpperSet

full_name: Topology.WithUpperSet.toUpperSet_ofUpperSet
code: @[simp] lemma toUpperSet_ofUpperSet (a : WithUpperSet α) : toUpperSet (ofUpperSet a) = a 
goal: Topology.WithUpperSet.toUpperSet (Topology.WithUpperSet.ofUpperSet a) = a

full_name: Topology.WithUpperSet.ofUpperSet_toUpperSet
code: @[simp] lemma ofUpperSet_toUpperSet (a : α) : ofUpperSet (toUpperSet a) = a 
goal: Topology.WithUpperSet.ofUpperSet (Topology.WithUpperSet.toUpperSet a) = a

full_name: Topology.WithUpperSet.toUpperSet_inj
code: lemma toUpperSet_inj {a b : α} : toUpperSet a = toUpperSet b ↔ a = b 
goal: Topology.WithUpperSet.toUpperSet a = Topology.WithUpperSet.toUpperSet b ↔ a = b

full_name: Topology.WithUpperSet.ofUpperSet_inj
code: lemma ofUpperSet_inj {a b : WithUpperSet α} : ofUpperSet a = ofUpperSet b ↔ a = b 
goal: Topology.WithUpperSet.ofUpperSet a = Topology.WithUpperSet.ofUpperSet b ↔ a = b

full_name: Topology.WithUpperSet.rec
code: /-- A recursor for `WithUpperSet`. Use as `induction x`. -/
@[elab_as_elim, cases_eliminator, induction_eliminator]
protected def rec {β : WithUpperSet α → Sort*} (h : ∀ a, β (toUpperSet a)) : ∀ a, β a 
goal: β a

full_name: Topology.WithUpperSet.instNonempty
code: instance [Nonempty α] : Nonempty (WithUpperSet α) 
goal: Nonempty (Topology.WithUpperSet α)

full_name: Topology.WithUpperSet.instInhabited
code: instance [Inhabited α] : Inhabited (WithUpperSet α) 
goal: Inhabited (Topology.WithUpperSet α)

full_name: Topology.WithUpperSet.instPreorder
code: instance : Preorder (WithUpperSet α) 
goal: Preorder (Topology.WithUpperSet α)

full_name: Topology.WithUpperSet.instTopologicalSpace
code: instance : TopologicalSpace (WithUpperSet α) 
goal: TopologicalSpace (Topology.WithUpperSet α)

full_name: Topology.WithUpperSet.ofUpperSet_le_iff
code: lemma ofUpperSet_le_iff {a b : WithUpperSet α} : ofUpperSet a ≤ ofUpperSet b ↔ a ≤ b 
goal: Topology.WithUpperSet.ofUpperSet a ≤ Topology.WithUpperSet.ofUpperSet b ↔ a ≤ b

full_name: Topology.WithUpperSet.toUpperSet_le_iff
code: lemma toUpperSet_le_iff {a b : α} : toUpperSet a ≤ toUpperSet b ↔ a ≤ b 
goal: Topology.WithUpperSet.toUpperSet a ≤ Topology.WithUpperSet.toUpperSet b ↔ a ≤ b

full_name: Topology.WithUpperSet.ofUpperSetOrderIso
code: /-- `ofUpperSet` as an `OrderIso` -/
def ofUpperSetOrderIso : WithUpperSet α ≃o α 
goal: Topology.WithUpperSet α ≃o α

full_name: Topology.WithUpperSet.toUpperSetOrderIso
code: /-- `toUpperSet` as an `OrderIso` -/
def toUpperSetOrderIso : α ≃o WithUpperSet α 
goal: α ≃o Topology.WithUpperSet α

full_name: Topology.WithLowerSet
code: /-- Type synonym for a preorder equipped with the lower set topology. -/
def WithLowerSet (α : Type*) 
goal: Type u_4

full_name: Topology.WithLowerSet.toLowerSet
code: /-- `toLowerSet` is the identity function to the `WithLowerSet` of a type.  -/
@[match_pattern] def toLowerSet : α ≃ WithLowerSet α 
goal: α ≃ Topology.WithLowerSet α

full_name: Topology.WithLowerSet.ofLowerSet
code: /-- `ofLowerSet` is the identity function from the `WithLowerSet` of a type.  -/
@[match_pattern] def ofLowerSet : WithLowerSet α ≃ α 
goal: Topology.WithLowerSet α ≃ α

full_name: Topology.WithLowerSet.to_WithLowerSet_symm_eq
code: @[simp] lemma to_WithLowerSet_symm_eq : (@toLowerSet α).symm = ofLowerSet 
goal: Topology.WithLowerSet.toLowerSet.symm = Topology.WithLowerSet.ofLowerSet

full_name: Topology.WithLowerSet.of_WithLowerSet_symm_eq
code: @[simp] lemma of_WithLowerSet_symm_eq : (@ofLowerSet α).symm = toLowerSet 
goal: Topology.WithLowerSet.ofLowerSet.symm = Topology.WithLowerSet.toLowerSet

full_name: Topology.WithLowerSet.toLowerSet_ofLowerSet
code: @[simp] lemma toLowerSet_ofLowerSet (a : WithLowerSet α) : toLowerSet (ofLowerSet a) = a 
goal: Topology.WithLowerSet.toLowerSet (Topology.WithLowerSet.ofLowerSet a) = a

full_name: Topology.WithLowerSet.ofLowerSet_toLowerSet
code: @[simp] lemma ofLowerSet_toLowerSet (a : α) : ofLowerSet (toLowerSet a) = a 
goal: Topology.WithLowerSet.ofLowerSet (Topology.WithLowerSet.toLowerSet a) = a

full_name: Topology.WithLowerSet.toLowerSet_inj
code: lemma toLowerSet_inj {a b : α} : toLowerSet a = toLowerSet b ↔ a = b 
goal: Topology.WithLowerSet.toLowerSet a = Topology.WithLowerSet.toLowerSet b ↔ a = b

full_name: Topology.WithLowerSet.ofLowerSet_inj
code: lemma ofLowerSet_inj {a b : WithLowerSet α} : ofLowerSet a = ofLowerSet b ↔ a = b 
goal: Topology.WithLowerSet.ofLowerSet a = Topology.WithLowerSet.ofLowerSet b ↔ a = b

full_name: Topology.WithLowerSet.rec
code: /-- A recursor for `WithLowerSet`. Use as `induction x`. -/
@[elab_as_elim, cases_eliminator, induction_eliminator]
protected def rec {β : WithLowerSet α → Sort*} (h : ∀ a, β (toLowerSet a)) : ∀ a, β a 
goal: β a

full_name: Topology.WithLowerSet.instNonempty
code: instance [Nonempty α] : Nonempty (WithLowerSet α) 
goal: Nonempty (Topology.WithLowerSet α)

full_name: Topology.WithLowerSet.instInhabited
code: instance [Inhabited α] : Inhabited (WithLowerSet α) 
goal: Inhabited (Topology.WithLowerSet α)

full_name: Topology.WithLowerSet.instPreorder
code: instance : Preorder (WithLowerSet α) 
goal: Preorder (Topology.WithLowerSet α)

full_name: Topology.WithLowerSet.instTopologicalSpace
code: instance : TopologicalSpace (WithLowerSet α) 
goal: TopologicalSpace (Topology.WithLowerSet α)

full_name: Topology.WithLowerSet.ofLowerSet_le_iff
code: lemma ofLowerSet_le_iff {a b : WithLowerSet α} : ofLowerSet a ≤ ofLowerSet b ↔ a ≤ b 
goal: Topology.WithLowerSet.ofLowerSet a ≤ Topology.WithLowerSet.ofLowerSet b ↔ a ≤ b

full_name: Topology.WithLowerSet.toLowerSet_le_iff
code: lemma toLowerSet_le_iff {a b : α} : toLowerSet a ≤ toLowerSet b ↔ a ≤ b 
goal: Topology.WithLowerSet.toLowerSet a ≤ Topology.WithLowerSet.toLowerSet b ↔ a ≤ b

full_name: Topology.WithLowerSet.ofLowerSetOrderIso
code: /-- `ofLowerSet` as an `OrderIso` -/
def ofLowerSetOrderIso : WithLowerSet α ≃o α 
goal: Topology.WithLowerSet α ≃o α

full_name: Topology.WithLowerSet.toLowerSetOrderIso
code: /-- `toLowerSet` as an `OrderIso` -/
def toLowerSetOrderIso : α ≃o WithLowerSet α 
goal: α ≃o Topology.WithLowerSet α

full_name: Topology.WithUpperSet.toDualHomeomorph
code: /--
The Upper Set topology is homeomorphic to the Lower Set topology on the dual order
-/
def WithUpperSet.toDualHomeomorph [Preorder α] : WithUpperSet α ≃ₜ WithLowerSet αᵒᵈ 
goal: Topology.WithUpperSet α ≃ₜ Topology.WithLowerSet αᵒᵈ

full_name: Topology.IsUpperSet.topology_eq_upperSetTopology
code: /-- Prop-valued mixin for an ordered topological space to be
The upper set topology is the topology where the open sets are the upper sets. In general the upper
set topology does not coincide with the upper topology.
-/
protected class IsUpperSet (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_upperSetTopology : t = upperSet α
goal: t = Topology.upperSet α

full_name: Topology.IsUpperSet
code: /-- Prop-valued mixin for an ordered topological space to be
The upper set topology is the topology where the open sets are the upper sets. In general the upper
set topology does not coincide with the upper topology.
-/
protected class IsUpperSet (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_upperSetTopology : t = upperSet α
goal: Prop

full_name: Topology.instIsUpperSetWithUpperSet
code: instance [Preorder α] : Topology.IsUpperSet (WithUpperSet α) 
goal: Topology.IsUpperSet (Topology.WithUpperSet α)

full_name: Topology.instIsUpperSet
code: instance [Preorder α] : @Topology.IsUpperSet α (upperSet α) _ 
goal: Topology.IsUpperSet α

full_name: Topology.IsLowerSet.topology_eq_lowerSetTopology
code: /--
The lower set topology is the topology where the open sets are the lower sets. In general the lower
set topology does not coincide with the lower topology.
-/
protected class IsLowerSet (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_lowerSetTopology : t = lowerSet α
goal: t = Topology.lowerSet α

full_name: Topology.IsLowerSet
code: /--
The lower set topology is the topology where the open sets are the lower sets. In general the lower
set topology does not coincide with the lower topology.
-/
protected class IsLowerSet (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_lowerSetTopology : t = lowerSet α
goal: Prop

full_name: Topology.instIsLowerSetWithLowerSet
code: instance [Preorder α] : Topology.IsLowerSet (WithLowerSet α) 
goal: Topology.IsLowerSet (Topology.WithLowerSet α)

full_name: Topology.instIsLowerSet
code: instance [Preorder α] : @Topology.IsLowerSet α (lowerSet α) _ 
goal: Topology.IsLowerSet α

full_name: Topology.IsUpperSet.topology_eq
code: lemma topology_eq : ‹_› = upperSet α 
goal: inst✝ = Topology.upperSet α

full_name: OrderDual.instIsLowerSet
code: instance _root_.OrderDual.instIsLowerSet [Preorder α] [TopologicalSpace α] [Topology.IsUpperSet α] :
    Topology.IsLowerSet αᵒᵈ 
goal: Topology.IsLowerSet αᵒᵈ

full_name: Topology.IsUpperSet.WithUpperSetHomeomorph
code: /-- If `α` is equipped with the upper set topology, then it is homeomorphic to
`WithUpperSet α`. -/
def WithUpperSetHomeomorph : WithUpperSet α ≃ₜ α 
goal: Topology.WithUpperSet α ≃ₜ α

full_name: Topology.IsUpperSet.isOpen_iff_isUpperSet
code: lemma isOpen_iff_isUpperSet : IsOpen s ↔ IsUpperSet s 
goal: IsOpen s ↔ IsUpperSet s

full_name: Topology.IsUpperSet.toAlexandrovDiscrete
code: instance toAlexandrovDiscrete : AlexandrovDiscrete α 
goal: AlexandrovDiscrete α

full_name: Topology.IsUpperSet.isClosed_iff_isLower
code: lemma isClosed_iff_isLower : IsClosed s ↔ IsLowerSet s 
goal: IsClosed s ↔ IsLowerSet s

full_name: Topology.IsUpperSet.closure_eq_lowerClosure
code: lemma closure_eq_lowerClosure {s : Set α} : closure s = lowerClosure s 
goal: closure s = ↑(lowerClosure s)

full_name: Topology.IsUpperSet.closure_singleton
code: /--
The closure of a singleton `{a}` in the upper set topology is the right-closed left-infinite
interval (-∞,a].
-/
@[simp] lemma closure_singleton {a : α} : closure {a} = Iic a 
goal: closure {a} = Set.Iic a

full_name: Topology.IsUpperSet.monotone_iff_continuous
code: protected lemma monotone_iff_continuous [TopologicalSpace α] [TopologicalSpace β]
    [Topology.IsUpperSet α] [Topology.IsUpperSet β] {f : α → β} : Monotone f ↔ Continuous f 
goal: Monotone f ↔ Continuous f

full_name: Topology.IsUpperSet.monotone_to_upperTopology_continuous
code: lemma monotone_to_upperTopology_continuous [TopologicalSpace α] [TopologicalSpace β]
    [Topology.IsUpperSet α] [IsUpper β] {f : α → β} (hf : Monotone f) : Continuous f 
goal: Continuous f

full_name: Topology.IsUpperSet.upperSet_le_upper
code: lemma upperSet_le_upper {t₁ t₂ : TopologicalSpace α} [@Topology.IsUpperSet α t₁ _]
    [@Topology.IsUpper α t₂ _] : t₁ ≤ t₂ 
goal: t₁ ≤ t₂

full_name: Topology.IsLowerSet.topology_eq
code: lemma topology_eq : ‹_› = lowerSet α 
goal: inst✝ = Topology.lowerSet α

full_name: OrderDual.instIsUpperSet
code: instance _root_.OrderDual.instIsUpperSet [Preorder α] [TopologicalSpace α] [Topology.IsLowerSet α] :
    Topology.IsUpperSet αᵒᵈ 
goal: Topology.IsUpperSet αᵒᵈ

full_name: Topology.IsLowerSet.WithLowerSetHomeomorph
code: /-- If `α` is equipped with the lower set topology, then it is homeomorphic to `WithLowerSet α`. -/
def WithLowerSetHomeomorph : WithLowerSet α ≃ₜ α 
goal: Topology.WithLowerSet α ≃ₜ α

full_name: Topology.IsLowerSet.isOpen_iff_isLowerSet
code: lemma isOpen_iff_isLowerSet : IsOpen s ↔ IsLowerSet s 
goal: IsOpen s ↔ IsLowerSet s

full_name: Topology.IsLowerSet.toAlexandrovDiscrete
code: instance toAlexandrovDiscrete : AlexandrovDiscrete α 
goal: AlexandrovDiscrete α

full_name: Topology.IsLowerSet.isClosed_iff_isUpper
code: lemma isClosed_iff_isUpper : IsClosed s ↔ IsUpperSet s 
goal: IsClosed s ↔ IsUpperSet s

full_name: Topology.IsLowerSet.closure_eq_upperClosure
code: lemma closure_eq_upperClosure {s : Set α} : closure s = upperClosure s 
goal: closure s = ↑(upperClosure s)

full_name: Topology.IsLowerSet.closure_singleton
code: /--
The closure of a singleton `{a}` in the lower set topology is the right-closed left-infinite
interval (-∞,a].
-/
@[simp] lemma closure_singleton {a : α} : closure {a} = Ici a 
goal: closure {a} = Set.Ici a

full_name: Topology.IsLowerSet.monotone_iff_continuous
code: protected lemma monotone_iff_continuous [TopologicalSpace α] [TopologicalSpace β]
    [Topology.IsLowerSet α] [Topology.IsLowerSet β] {f : α → β} : Monotone f ↔ Continuous f 
goal: Monotone f ↔ Continuous f

full_name: Topology.IsLowerSet.monotone_to_lowerTopology_continuous
code: lemma monotone_to_lowerTopology_continuous [TopologicalSpace α] [TopologicalSpace β]
    [Topology.IsLowerSet α] [IsLower β] {f : α → β} (hf : Monotone f) : Continuous f 
goal: Continuous f

full_name: Topology.IsLowerSet.lowerSet_le_lower
code: lemma lowerSet_le_lower {t₁ t₂ : TopologicalSpace α} [@Topology.IsLowerSet α t₁ _]
    [@IsLower α t₂ _] : t₁ ≤ t₂ 
goal: t₁ ≤ t₂

full_name: Topology.isUpperSet_orderDual
code: lemma isUpperSet_orderDual [Preorder α] [TopologicalSpace α] :
    Topology.IsUpperSet αᵒᵈ ↔ Topology.IsLowerSet α 
goal: Topology.IsUpperSet αᵒᵈ ↔ Topology.IsLowerSet α

full_name: Topology.isLowerSet_orderDual
code: lemma isLowerSet_orderDual [Preorder α] [TopologicalSpace α] :
    Topology.IsLowerSet αᵒᵈ ↔ Topology.IsUpperSet α 
goal: Topology.IsLowerSet αᵒᵈ ↔ Topology.IsUpperSet α

full_name: Topology.WithUpperSet.map
code: /-- A monotone map between preorders spaces induces a continuous map between themselves considered
with the upper set topology. -/
def map (f : α →o β) : C(WithUpperSet α, WithUpperSet β) 
goal: C(Topology.WithUpperSet α, Topology.WithUpperSet β)

full_name: Topology.WithUpperSet.map_id
code: @[simp] lemma map_id : map (OrderHom.id : α →o α) = ContinuousMap.id _ 
goal: Topology.WithUpperSet.map OrderHom.id = ContinuousMap.id (Topology.WithUpperSet α)

full_name: Topology.WithUpperSet.map_comp
code: @[simp] lemma map_comp (g : β →o γ) (f : α →o β) : map (g.comp f) = (map g).comp (map f) 
goal: Topology.WithUpperSet.map (g.comp f) = (Topology.WithUpperSet.map g).comp (Topology.WithUpperSet.map f)

full_name: Topology.WithUpperSet.toUpperSet_specializes_toUpperSet
code: @[simp] lemma toUpperSet_specializes_toUpperSet {a b : α} :
    toUpperSet a ⤳ toUpperSet b ↔ b ≤ a 
goal: Topology.WithUpperSet.toUpperSet a ⤳ Topology.WithUpperSet.toUpperSet b ↔ b ≤ a

full_name: Topology.WithUpperSet.ofUpperSet_le_ofUpperSet
code: @[simp] lemma ofUpperSet_le_ofUpperSet {a b : WithUpperSet α} :
    ofUpperSet a ≤ ofUpperSet b ↔ b ⤳ a 
goal: Topology.WithUpperSet.ofUpperSet a ≤ Topology.WithUpperSet.ofUpperSet b ↔ b ⤳ a

full_name: Topology.WithUpperSet.isUpperSet_toUpperSet_preimage
code: @[simp] lemma isUpperSet_toUpperSet_preimage {s : Set (WithUpperSet α)} :
    IsUpperSet (toUpperSet ⁻¹' s) ↔ IsOpen s 
goal: IsUpperSet (⇑Topology.WithUpperSet.toUpperSet ⁻¹' s) ↔ IsOpen s

full_name: Topology.WithUpperSet.isOpen_ofUpperSet_preimage
code: @[simp] lemma isOpen_ofUpperSet_preimage {s : Set α} :
    IsOpen (ofUpperSet ⁻¹' s) ↔ IsUpperSet s 
goal: IsOpen (⇑Topology.WithUpperSet.ofUpperSet ⁻¹' s) ↔ IsUpperSet s

full_name: Topology.WithLowerSet.map
code: /-- A monotone map between preorders spaces induces a continuous map between themselves considered
with the lower set topology. -/
def map (f : α →o β) : C(WithLowerSet α, WithLowerSet β) 
goal: C(Topology.WithLowerSet α, Topology.WithLowerSet β)

full_name: Topology.WithLowerSet.map_id
code: @[simp] lemma map_id : map (OrderHom.id : α →o α) = ContinuousMap.id _ 
goal: Topology.WithLowerSet.map OrderHom.id = ContinuousMap.id (Topology.WithLowerSet α)

full_name: Topology.WithLowerSet.map_comp
code: @[simp] lemma map_comp (g : β →o γ) (f : α →o β) : map (g.comp f) = (map g).comp (map f) 
goal: Topology.WithLowerSet.map (g.comp f) = (Topology.WithLowerSet.map g).comp (Topology.WithLowerSet.map f)

full_name: Topology.WithLowerSet.toLowerSet_specializes_toLowerSet
code: @[simp] lemma toLowerSet_specializes_toLowerSet {a b : α} :
  toLowerSet a ⤳ toLowerSet b ↔ a ≤ b 
goal: Topology.WithLowerSet.toLowerSet a ⤳ Topology.WithLowerSet.toLowerSet b ↔ a ≤ b

full_name: Topology.WithLowerSet.ofLowerSet_le_ofLowerSet
code: @[simp] lemma ofLowerSet_le_ofLowerSet {a b : WithLowerSet α} :
    ofLowerSet a ≤ ofLowerSet b ↔ a ⤳ b 
goal: Topology.WithLowerSet.ofLowerSet a ≤ Topology.WithLowerSet.ofLowerSet b ↔ a ⤳ b

full_name: Topology.WithLowerSet.isLowerSet_toLowerSet_preimage
code: @[simp] lemma isLowerSet_toLowerSet_preimage {s : Set (WithLowerSet α)} :
    IsLowerSet (toLowerSet ⁻¹' s) ↔ IsOpen s 
goal: IsLowerSet (⇑Topology.WithLowerSet.toLowerSet ⁻¹' s) ↔ IsOpen s

full_name: Topology.WithLowerSet.isOpen_ofLowerSet_preimage
code: @[simp] lemma isOpen_ofLowerSet_preimage {s : Set α} :
    IsOpen (ofLowerSet ⁻¹' s) ↔ IsLowerSet s 
goal: IsOpen (⇑Topology.WithLowerSet.ofLowerSet ⁻¹' s) ↔ IsLowerSet s