File: Mathlib/Topology/Order/ScottTopology.lean

full_name: DirSupInacc
code: /-- A set `s` is said to be inaccessible by directed joins if, when the least upper bound of a
directed set `d` lies in `s` then `d` has non-empty intersection with `s`. -/
def DirSupInacc (s : Set α) : Prop 
goal: Prop

full_name: DirSupClosed
code: /--
A set `s` is said to be closed under directed joins if, whenever a directed set `d` has a least
upper bound `a` and is a subset of `s` then `a` also lies in `s`.
-/
def DirSupClosed (s : Set α) : Prop 
goal: Prop

full_name: dirSupInacc_compl
code: @[simp] lemma dirSupInacc_compl : DirSupInacc sᶜ ↔ DirSupClosed s 
goal: DirSupInacc sᶜ ↔ DirSupClosed s

full_name: dirSupClosed_compl
code: @[simp] lemma dirSupClosed_compl : DirSupClosed sᶜ ↔ DirSupInacc s 
goal: DirSupClosed sᶜ ↔ DirSupInacc s

full_name: DirSupClosed.inter
code: lemma DirSupClosed.inter (hs : DirSupClosed s) (ht : DirSupClosed t) : DirSupClosed (s ∩ t) 
goal: DirSupClosed (s ∩ t)

full_name: DirSupInacc.union
code: lemma DirSupInacc.union (hs : DirSupInacc s) (ht : DirSupInacc t) : DirSupInacc (s ∪ t) 
goal: DirSupInacc (s ∪ t)

full_name: IsUpperSet.dirSupClosed
code: lemma IsUpperSet.dirSupClosed (hs : IsUpperSet s) : DirSupClosed s 
goal: DirSupClosed s

full_name: IsLowerSet.dirSupInacc
code: lemma IsLowerSet.dirSupInacc (hs : IsLowerSet s) : DirSupInacc s 
goal: DirSupInacc s

full_name: dirSupClosed_Iic
code: lemma dirSupClosed_Iic (a : α) : DirSupClosed (Iic a) 
goal: DirSupClosed (Set.Iic a)

full_name: dirSupInacc_iff_forall_sSup
code: lemma dirSupInacc_iff_forall_sSup :
    DirSupInacc s ↔ ∀ ⦃d⦄, d.Nonempty → DirectedOn (· ≤ ·) d → sSup d ∈ s → (d ∩ s).Nonempty 
goal: DirSupInacc s ↔ ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → sSup d ∈ s → (d ∩ s).Nonempty

full_name: dirSupClosed_iff_forall_sSup
code: lemma dirSupClosed_iff_forall_sSup :
    DirSupClosed s ↔ ∀ ⦃d⦄, d.Nonempty → DirectedOn (· ≤ ·) d → d ⊆ s → sSup d ∈ s 
goal: DirSupClosed s ↔ ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → d ⊆ s → sSup d ∈ s

full_name: Topology.scottHausdorff
code: /-- The Scott-Hausdorff topology.

A set `u` is open in the Scott-Hausdorff topology iff when the least upper bound of a directed set
`d` lies in `u` then there is a tail of `d` which is a subset of `u`. -/
def scottHausdorff (α : Type*) [Preorder α] : TopologicalSpace α 
goal: TopologicalSpace α

full_name: Topology.IsScottHausdorff
code: /-- Predicate for an ordered topological space to be equipped with its Scott-Hausdorff topology.

A set `u` is open in the Scott-Hausdorff topology iff when the least upper bound of a directed set
`d` lies in `u` then there is a tail of `d` which is a subset of `u`. -/
class IsScottHausdorff : Prop where
  topology_eq_scottHausdorff : ‹TopologicalSpace α› = scottHausdorff α
goal: Prop

full_name: Topology.IsScottHausdorff.topology_eq_scottHausdorff
code: /-- Predicate for an ordered topological space to be equipped with its Scott-Hausdorff topology.

A set `u` is open in the Scott-Hausdorff topology iff when the least upper bound of a directed set
`d` lies in `u` then there is a tail of `d` which is a subset of `u`. -/
class IsScottHausdorff : Prop where
  topology_eq_scottHausdorff : ‹TopologicalSpace α› = scottHausdorff α
goal: inst✝ = Topology.scottHausdorff α

full_name: Topology.instIsScottHausdorff
code: instance : @IsScottHausdorff α _ (scottHausdorff α) 
goal: Topology.IsScottHausdorff α

full_name: Topology.IsScottHausdorff.topology_eq
code: lemma topology_eq : ‹_› = scottHausdorff α 
goal: inst✝ = Topology.scottHausdorff α

full_name: Topology.IsScottHausdorff.isOpen_iff
code: lemma isOpen_iff :
    IsOpen s ↔ ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (· ≤ ·) d → ∀ ⦃a : α⦄, IsLUB d a →
      a ∈ s → ∃ b ∈ d, Ici b ∩ d ⊆ s 
goal: IsOpen s ↔
  ∀ ⦃d : Set α⦄,
    d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → ∀ ⦃a : α⦄, IsLUB d a → a ∈ s → ∃ b ∈ d, Set.Ici b ∩ d ⊆ s

full_name: Topology.IsScottHausdorff.isOpen_of_isLowerSet
code: lemma isOpen_of_isLowerSet (h : IsLowerSet s) : IsOpen s 
goal: IsOpen s

full_name: Topology.IsScottHausdorff.isClosed_of_isUpperSet
code: lemma isClosed_of_isUpperSet (h : IsUpperSet s) : IsClosed s 
goal: IsClosed s

full_name: Topology.IsScottHausdorff.dirSupInacc_of_isOpen
code: lemma dirSupInacc_of_isOpen (h : IsOpen s) : DirSupInacc s 
goal: DirSupInacc s

full_name: Topology.IsScottHausdorff.dirSupClosed_of_isClosed
code: lemma dirSupClosed_of_isClosed (h : IsClosed s) : DirSupClosed s 
goal: DirSupClosed s

full_name: Topology.scott
code: /-- The Scott topology.

It is defined as the join of the topology of upper sets and the Scott-Hausdorff topology. -/
def scott (α : Type*) [Preorder α] : TopologicalSpace α 
goal: TopologicalSpace α

full_name: Topology.upperSet_le_scott
code: lemma upperSet_le_scott : upperSet α ≤ scott α 
goal: Topology.upperSet α ≤ Topology.scott α

full_name: Topology.scottHausdorff_le_scott
code: lemma scottHausdorff_le_scott : scottHausdorff α ≤ scott α 
goal: Topology.scottHausdorff α ≤ Topology.scott α

full_name: Topology.IsScott.topology_eq_scott
code: /-- Predicate for an ordered topological space to be equipped with its Scott topology.

The Scott topology is defined as the join of the topology of upper sets and the Scott Hausdorff
topology. -/
class IsScott : Prop where
  topology_eq_scott : ‹TopologicalSpace α› = scott α
goal: inst✝ = Topology.scott α

full_name: Topology.IsScott
code: /-- Predicate for an ordered topological space to be equipped with its Scott topology.

The Scott topology is defined as the join of the topology of upper sets and the Scott Hausdorff
topology. -/
class IsScott : Prop where
  topology_eq_scott : ‹TopologicalSpace α› = scott α
goal: Prop

full_name: Topology.IsScott.topology_eq
code: lemma topology_eq : ‹_› = scott α 
goal: inst✝ = Topology.scott α

full_name: Topology.IsScott.isOpen_iff_isUpperSet_and_scottHausdorff_open
code: lemma isOpen_iff_isUpperSet_and_scottHausdorff_open :
    IsOpen s ↔ IsUpperSet s ∧ IsOpen[scottHausdorff α] s 
goal: IsOpen s ↔ IsUpperSet s ∧ IsOpen s

full_name: Topology.IsScott.isOpen_iff_isUpperSet_and_dirSupInacc
code: lemma isOpen_iff_isUpperSet_and_dirSupInacc : IsOpen s ↔ IsUpperSet s ∧ DirSupInacc s 
goal: IsOpen s ↔ IsUpperSet s ∧ DirSupInacc s

full_name: Topology.IsScott.isClosed_iff_isLowerSet_and_dirSupClosed
code: lemma isClosed_iff_isLowerSet_and_dirSupClosed : IsClosed s ↔ IsLowerSet s ∧ DirSupClosed s 
goal: IsClosed s ↔ IsLowerSet s ∧ DirSupClosed s

full_name: Topology.IsScott.isUpperSet_of_isOpen
code: lemma isUpperSet_of_isOpen : IsOpen s → IsUpperSet s 
goal: IsOpen s → IsUpperSet s

full_name: Topology.IsScott.isLowerSet_of_isClosed
code: lemma isLowerSet_of_isClosed : IsClosed s → IsLowerSet s 
goal: IsClosed s → IsLowerSet s

full_name: Topology.IsScott.dirSupClosed_of_isClosed
code: lemma dirSupClosed_of_isClosed : IsClosed s → DirSupClosed s 
goal: IsClosed s → DirSupClosed s

full_name: Topology.IsScott.lowerClosure_subset_closure
code: lemma lowerClosure_subset_closure : ↑(lowerClosure s) ⊆ closure s 
goal: ↑(lowerClosure s) ⊆ closure s

full_name: Topology.IsScott.isClosed_Iic
code: lemma isClosed_Iic : IsClosed (Iic a) 
goal: IsClosed (Set.Iic a)

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

full_name: Topology.IsScott.monotone_of_continuous
code: lemma monotone_of_continuous (hf : Continuous f) : Monotone f 
goal: Monotone f

full_name: Topology.IsScott.scottContinuous_iff_continuous
code: @[simp] lemma scottContinuous_iff_continuous : ScottContinuous f ↔ Continuous f 
goal: ScottContinuous f ↔ Continuous f

full_name: Topology.IsScott.instT0Space
code: /--
The Scott topology on a partial order is T₀.
-/
-- see Note [lower instance priority]
instance (priority := 90) : T0Space α 
goal: T0Space α

full_name: Topology.IsScott.isOpen_iff_Iic_compl_or_univ
code: lemma isOpen_iff_Iic_compl_or_univ (U : Set α) :
    IsOpen U ↔ (∃ (a : α), U = (Iic a)ᶜ) ∨ U = univ 
goal: IsOpen U ↔ (∃ a, U = (Set.Iic a)ᶜ) ∨ U = Set.univ

full_name: Topology.WithScott
code: /--
Type synonym for a preorder equipped with the Scott topology
-/
def WithScott (α : Type*) 
goal: Type u_3

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

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

full_name: Topology.WithScott.toScott_symm_eq
code: @[simp] lemma toScott_symm_eq : (@toScott α).symm = ofScott 
goal: Topology.WithScott.toScott.symm = Topology.WithScott.ofScott

full_name: Topology.WithScott.ofScott_symm_eq
code: @[simp] lemma ofScott_symm_eq : (@ofScott α).symm = toScott 
goal: Topology.WithScott.ofScott.symm = Topology.WithScott.toScott

full_name: Topology.WithScott.toScott_ofScott
code: @[simp] lemma toScott_ofScott (a : WithScott α) : toScott (ofScott a) = a 
goal: Topology.WithScott.toScott (Topology.WithScott.ofScott a) = a

full_name: Topology.WithScott.ofScott_toScott
code: @[simp] lemma ofScott_toScott (a : α) : ofScott (toScott a) = a 
goal: Topology.WithScott.ofScott (Topology.WithScott.toScott a) = a

full_name: Topology.WithScott.toScott_inj
code: @[simp, nolint simpNF]
lemma toScott_inj {a b : α} : toScott a = toScott b ↔ a = b 
goal: Topology.WithScott.toScott a = Topology.WithScott.toScott b ↔ a = b

full_name: Topology.WithScott.ofScott_inj
code: @[simp, nolint simpNF]
lemma ofScott_inj {a b : WithScott α} : ofScott a = ofScott b ↔ a = b 
goal: Topology.WithScott.ofScott a = Topology.WithScott.ofScott b ↔ a = b

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

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

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

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

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

full_name: Topology.WithScott.instIsScott
code: instance : IsScott (WithScott α) 
goal: Topology.IsScott (Topology.WithScott α)

full_name: Topology.WithScott.isOpen_iff_isUpperSet_and_scottHausdorff_open'
code: lemma isOpen_iff_isUpperSet_and_scottHausdorff_open' {u : Set α} :
    IsOpen (WithScott.ofScott ⁻¹' u) ↔ IsUpperSet u ∧ (scottHausdorff α).IsOpen u 
goal: IsOpen (⇑Topology.WithScott.ofScott ⁻¹' u) ↔ IsUpperSet u ∧ TopologicalSpace.IsOpen u

full_name: Topology.scottHausdorff_le_lower
code: lemma scottHausdorff_le_lower : scottHausdorff α ≤ lower α 
goal: Topology.scottHausdorff α ≤ Topology.lower α

full_name: Topology.IsScott.withScottHomeomorph
code: /-- If `α` is equipped with the Scott topology, then it is homeomorphic to `WithScott α`.
-/
def IsScott.withScottHomeomorph [IsScott α] : WithScott α ≃ₜ α 
goal: Topology.WithScott α ≃ₜ α

full_name: Topology.IsScott.scottHausdorff_le
code: lemma IsScott.scottHausdorff_le [IsScott α] : scottHausdorff α ≤ ‹TopologicalSpace α› 
goal: Topology.scottHausdorff α ≤ inst✝

full_name: Topology.IsLower.scottHausdorff_le
code: lemma IsLower.scottHausdorff_le [IsLower α] : scottHausdorff α ≤ ‹TopologicalSpace α› 
goal: Topology.scottHausdorff α ≤ inst✝