File: Mathlib/Topology/Order/LowerUpperTopology.lean

full_name: Topology.lower
code: /--
The lower topology is the topology generated by the complements of the left-closed right-infinite
intervals.
-/
def lower (α : Type*) [Preorder α] : TopologicalSpace α 
goal: TopologicalSpace α

full_name: Topology.upper
code: /--
The upper topology is the topology generated by the complements of the right-closed left-infinite
intervals.
-/
def upper (α : Type*) [Preorder α] : TopologicalSpace α 
goal: TopologicalSpace α

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

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

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

full_name: Topology.WithLower.to_WithLower_symm_eq
code: @[simp] lemma to_WithLower_symm_eq : (@toLower α).symm = ofLower 
goal: Topology.WithLower.toLower.symm = Topology.WithLower.ofLower

full_name: Topology.WithLower.of_WithLower_symm_eq
code: @[simp] lemma of_WithLower_symm_eq : (@ofLower α).symm = toLower 
goal: Topology.WithLower.ofLower.symm = Topology.WithLower.toLower

full_name: Topology.WithLower.toLower_ofLower
code: @[simp] lemma toLower_ofLower (a : WithLower α) : toLower (ofLower a) = a 
goal: Topology.WithLower.toLower (Topology.WithLower.ofLower a) = a

full_name: Topology.WithLower.ofLower_toLower
code: @[simp] lemma ofLower_toLower (a : α) : ofLower (toLower a) = a 
goal: Topology.WithLower.ofLower (Topology.WithLower.toLower a) = a

full_name: Topology.WithLower.toLower_inj
code: lemma toLower_inj {a b : α} : toLower a = toLower b ↔ a = b 
goal: Topology.WithLower.toLower a = Topology.WithLower.toLower b ↔ a = b

full_name: Topology.WithLower.ofLower_inj
code: theorem ofLower_inj {a b : WithLower α} : ofLower a = ofLower b ↔ a = b 
goal: Topology.WithLower.ofLower a = Topology.WithLower.ofLower b ↔ a = b

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

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

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

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

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

full_name: Topology.WithLower.isOpen_preimage_ofLower
code: lemma isOpen_preimage_ofLower : IsOpen (ofLower ⁻¹' s) ↔ (lower α).IsOpen s 
goal: IsOpen (⇑Topology.WithLower.ofLower ⁻¹' s) ↔ TopologicalSpace.IsOpen s

full_name: Topology.WithLower.isOpen_def
code: lemma isOpen_def (T : Set (WithLower α)) : IsOpen T ↔ (lower α).IsOpen (WithLower.toLower ⁻¹' T) 
goal: IsOpen T ↔ TopologicalSpace.IsOpen (⇑Topology.WithLower.toLower ⁻¹' T)

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

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

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

full_name: Topology.WithUpper.to_WithUpper_symm_eq
code: @[simp] lemma to_WithUpper_symm_eq {α} : (@toUpper α).symm = ofUpper 
goal: Topology.WithUpper.toUpper.symm = Topology.WithUpper.ofUpper

full_name: Topology.WithUpper.of_WithUpper_symm_eq
code: @[simp] lemma of_WithUpper_symm_eq : (@ofUpper α).symm = toUpper 
goal: Topology.WithUpper.ofUpper.symm = Topology.WithUpper.toUpper

full_name: Topology.WithUpper.toUpper_ofUpper
code: @[simp] lemma toUpper_ofUpper (a : WithUpper α) : toUpper (ofUpper a) = a 
goal: Topology.WithUpper.toUpper (Topology.WithUpper.ofUpper a) = a

full_name: Topology.WithUpper.ofUpper_toUpper
code: @[simp] lemma ofUpper_toUpper (a : α) : ofUpper (toUpper a) = a 
goal: Topology.WithUpper.ofUpper (Topology.WithUpper.toUpper a) = a

full_name: Topology.WithUpper.toUpper_inj
code: lemma toUpper_inj {a b : α} : toUpper a = toUpper b ↔ a = b 
goal: Topology.WithUpper.toUpper a = Topology.WithUpper.toUpper b ↔ a = b

full_name: Topology.WithUpper.ofUpper_inj
code: lemma ofUpper_inj {a b : WithUpper α} : ofUpper a = ofUpper b ↔ a = b 
goal: Topology.WithUpper.ofUpper a = Topology.WithUpper.ofUpper b ↔ a = b

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

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

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

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

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

full_name: Topology.WithUpper.isOpen_preimage_ofUpper
code: lemma isOpen_preimage_ofUpper : IsOpen (ofUpper ⁻¹' s) ↔ (upper α).IsOpen s 
goal: IsOpen (⇑Topology.WithUpper.ofUpper ⁻¹' s) ↔ TopologicalSpace.IsOpen s

full_name: Topology.WithUpper.isOpen_def
code: lemma isOpen_def {s : Set (WithUpper α)} : IsOpen s ↔ (upper α).IsOpen (toUpper ⁻¹' s) 
goal: IsOpen s ↔ TopologicalSpace.IsOpen (⇑Topology.WithUpper.toUpper ⁻¹' s)

full_name: Topology.IsLower.topology_eq_lowerTopology
code: /--
The lower topology is the topology generated by the complements of the left-closed right-infinite
intervals.
-/
class IsLower (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_lowerTopology : t = lower α
goal: t = Topology.lower α

full_name: Topology.IsLower
code: /--
The lower topology is the topology generated by the complements of the left-closed right-infinite
intervals.
-/
class IsLower (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_lowerTopology : t = lower α
goal: Prop

full_name: Topology.IsUpper.topology_eq_upperTopology
code: /--
The upper topology is the topology generated by the complements of the right-closed left-infinite
intervals.
-/
class IsUpper (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_upperTopology : t = upper α
goal: t = Topology.upper α

full_name: Topology.IsUpper
code: /--
The upper topology is the topology generated by the complements of the right-closed left-infinite
intervals.
-/
class IsUpper (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_upperTopology : t = upper α
goal: Prop

full_name: Topology.instIsLowerWithLower
code: instance [Preorder α] : IsLower (WithLower α) 
goal: Topology.IsLower (Topology.WithLower α)

full_name: Topology.instIsUpperWithUpper
code: instance [Preorder α] : IsUpper (WithUpper α) 
goal: Topology.IsUpper (Topology.WithUpper α)

full_name: Topology.WithLower.toDualHomeomorph
code: /--
The lower topology is homeomorphic to the upper topology on the dual order
-/
def WithLower.toDualHomeomorph [Preorder α] : WithLower α ≃ₜ WithUpper αᵒᵈ 
goal: Topology.WithLower α ≃ₜ Topology.WithUpper αᵒᵈ

full_name: Topology.IsLower.lowerBasis
code: /-- The complements of the upper closures of finite sets are a collection of lower sets
which form a basis for the lower topology. -/
def lowerBasis (α : Type*) [Preorder α] 
goal: Set (Set α)

full_name: Topology.IsLower.topology_eq
code: lemma topology_eq : ‹_› = lower α 
goal: inst✝ = Topology.lower α

full_name: Topology.IsLower.withLowerHomeomorph
code: /-- If `α` is equipped with the lower topology, then it is homeomorphic to `WithLower α`.
-/
def withLowerHomeomorph : WithLower α ≃ₜ α 
goal: Topology.WithLower α ≃ₜ α

full_name: Topology.IsLower.isOpen_iff_generate_Ici_compl
code: theorem isOpen_iff_generate_Ici_compl : IsOpen s ↔ GenerateOpen { t | ∃ a, (Ici a)ᶜ = t } s 
goal: IsOpen s ↔ TopologicalSpace.GenerateOpen {t | ∃ a, (Set.Ici a)ᶜ = t} s

full_name: OrderDual.instIsUpper
code: instance _root_.OrderDual.instIsUpper [Preorder α] [TopologicalSpace α] [IsLower α] :
    IsUpper αᵒᵈ 
goal: Topology.IsUpper αᵒᵈ

full_name: Topology.IsLower.instClosedIciTopology
code: /-- Left-closed right-infinite intervals [a, ∞) are closed in the lower topology. -/
instance : ClosedIciTopology α 
goal: ClosedIciTopology α

full_name: Topology.IsLower.isClosed_upperClosure
code: /-- The upper closure of a finite set is closed in the lower topology. -/
theorem isClosed_upperClosure (h : s.Finite) : IsClosed (upperClosure s : Set α) 
goal: IsClosed ↑(upperClosure s)

full_name: Topology.IsLower.isLowerSet_of_isOpen
code: /-- Every set open in the lower topology is a lower set. -/
theorem isLowerSet_of_isOpen (h : IsOpen s) : IsLowerSet s 
goal: IsLowerSet s

full_name: Topology.IsLower.isUpperSet_of_isClosed
code: theorem isUpperSet_of_isClosed (h : IsClosed s) : IsUpperSet s 
goal: IsUpperSet s

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

full_name: Topology.IsLower.isTopologicalBasis
code: protected theorem isTopologicalBasis : IsTopologicalBasis (lowerBasis α) 
goal: TopologicalSpace.IsTopologicalBasis (Topology.IsLower.lowerBasis α)

full_name: Topology.IsLower.continuous_iff_Ici
code: /-- A function `f : β → α` with lower topology in the codomain is continuous
if and only if the preimage of every interval `Set.Ici a` is a closed set.
-/
lemma continuous_iff_Ici [TopologicalSpace β] {f : β → α} :
    Continuous f ↔ ∀ a, IsClosed (f ⁻¹' (Ici a)) 
goal: Continuous f ↔ ∀ (a : α), IsClosed (f ⁻¹' Set.Ici a)

full_name: Topology.IsLower.t0Space
code: /-- The lower topology on a partial order is T₀. -/
instance (priority := 90) t0Space : T0Space α 
goal: T0Space α

full_name: Topology.IsUpper.upperBasis
code: /-- The complements of the lower closures of finite sets are a collection of upper sets
which form a basis for the upper topology. -/
def upperBasis (α : Type*) [Preorder α] 
goal: Set (Set α)

full_name: Topology.IsUpper.topology_eq
code: lemma topology_eq : ‹_› = upper α 
goal: inst✝ = Topology.upper α

full_name: Topology.IsUpper.withUpperHomeomorph
code: /-- If `α` is equipped with the upper topology, then it is homeomorphic to `WithUpper α`.
-/
def withUpperHomeomorph : WithUpper α ≃ₜ α 
goal: Topology.WithUpper α ≃ₜ α

full_name: Topology.IsUpper.isOpen_iff_generate_Iic_compl
code: theorem isOpen_iff_generate_Iic_compl : IsOpen s ↔ GenerateOpen { t | ∃ a, (Iic a)ᶜ = t } s 
goal: IsOpen s ↔ TopologicalSpace.GenerateOpen {t | ∃ a, (Set.Iic a)ᶜ = t} s

full_name: OrderDual.instIsLower
code: instance _root_.OrderDual.instIsLower [Preorder α] [TopologicalSpace α] [IsUpper α] :
    IsLower αᵒᵈ 
goal: Topology.IsLower αᵒᵈ

full_name: Topology.IsUpper.instClosedIicTopology
code: /-- Left-infinite right-closed intervals (-∞,a] are closed in the upper topology. -/
instance : ClosedIicTopology α 
goal: ClosedIicTopology α

full_name: Topology.IsUpper.isClosed_lowerClosure
code: /-- The lower closure of a finite set is closed in the upper topology. -/
theorem isClosed_lowerClosure (h : s.Finite) : IsClosed (lowerClosure s : Set α) 
goal: IsClosed ↑(lowerClosure s)

full_name: Topology.IsUpper.isUpperSet_of_isOpen
code: /-- Every set open in the upper topology is a upper set. -/
theorem isUpperSet_of_isOpen (h : IsOpen s) : IsUpperSet s 
goal: IsUpperSet s

full_name: Topology.IsUpper.isLowerSet_of_isClosed
code: theorem isLowerSet_of_isClosed (h : IsClosed s) : IsLowerSet s 
goal: IsLowerSet s

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

full_name: Topology.IsUpper.isTopologicalBasis
code: protected theorem isTopologicalBasis : IsTopologicalBasis (upperBasis α) 
goal: TopologicalSpace.IsTopologicalBasis (Topology.IsUpper.upperBasis α)

full_name: Topology.IsUpper.continuous_iff_Iic
code: /-- A function `f : β → α` with upper topology in the codomain is continuous
if and only if the preimage of every interval `Set.Iic a` is a closed set. -/
lemma continuous_iff_Iic [TopologicalSpace β] {f : β → α} :
    Continuous f ↔ ∀ a, IsClosed (f ⁻¹' (Iic a)) 
goal: Continuous f ↔ ∀ (a : α), IsClosed (f ⁻¹' Set.Iic a)

full_name: Topology.IsUpper.continuous_of_Iic
code: /-- A function `f : β → α` with upper topology in the codomain is continuous
provided that the preimage of every interval `Set.Iic a` is a closed set. -/
@[deprecated (since := "2023-12-24")]
lemma continuous_of_Iic [TopologicalSpace β] {f : β → α} (h : ∀ a, IsClosed (f ⁻¹' (Iic a))) :
    Continuous f 
goal: Continuous f

full_name: Topology.IsUpper.t0Space
code: /-- The upper topology on a partial order is T₀. -/
instance (priority := 90) t0Space : T0Space α 
goal: T0Space α

full_name: Topology.instIsLowerProd
code: instance instIsLowerProd [Preorder α] [TopologicalSpace α] [IsLower α]
    [OrderBot α] [Preorder β] [TopologicalSpace β] [IsLower β] [OrderBot β] :
    IsLower (α × β) 
goal: Topology.IsLower (α × β)

full_name: Topology.instIsUpperProd
code: instance instIsUpperProd [Preorder α] [TopologicalSpace α] [IsUpper α]
    [OrderTop α] [Preorder β] [TopologicalSpace β] [IsUpper β] [OrderTop β] :
    IsUpper (α × β) 
goal: Topology.IsUpper (α × β)

full_name: sInfHom.continuous
code: protected lemma _root_.sInfHom.continuous (f : sInfHom α β) : Continuous f 
goal: Continuous ⇑f

full_name: Topology.IsLower.toContinuousInf
code: instance (priority := 90) IsLower.toContinuousInf : ContinuousInf α 
goal: ContinuousInf α

full_name: sSupHom.continuous
code: protected lemma _root_.sSupHom.continuous (f : sSupHom α β) : Continuous f 
goal: Continuous ⇑f

full_name: Topology.IsUpper.toContinuousInf
code: instance (priority := 90) IsUpper.toContinuousInf : ContinuousSup α 
goal: ContinuousSup α

full_name: Topology.isUpper_orderDual
code: lemma isUpper_orderDual [Preorder α] [TopologicalSpace α] : IsUpper αᵒᵈ ↔ IsLower α 
goal: Topology.IsUpper αᵒᵈ ↔ Topology.IsLower α

full_name: Topology.isLower_orderDual
code: lemma isLower_orderDual [Preorder α] [TopologicalSpace α] : IsLower αᵒᵈ ↔ IsUpper α 
goal: Topology.IsLower αᵒᵈ ↔ Topology.IsUpper α