File: Mathlib/Topology/Specialization.lean

full_name: Specialization
code: /-- Type synonym for a topological space considered with its specialisation order. -/
def Specialization (α : Type*) 
goal: Type u_1

full_name: Specialization.toEquiv
code: /-- `toEquiv` is the "identity" function to the `Specialization` of a type. -/
@[match_pattern] def toEquiv : α ≃ Specialization α 
goal: α ≃ Specialization α

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

full_name: Specialization.toEquiv_symm
code: @[simp] lemma toEquiv_symm : (@toEquiv α).symm = ofEquiv 
goal: Specialization.toEquiv.symm = Specialization.ofEquiv

full_name: Specialization.ofEquiv_symm
code: @[simp] lemma ofEquiv_symm : (@ofEquiv α).symm = toEquiv 
goal: Specialization.ofEquiv.symm = Specialization.toEquiv

full_name: Specialization.toEquiv_ofEquiv
code: @[simp] lemma toEquiv_ofEquiv (a : Specialization α) : toEquiv (ofEquiv a) = a 
goal: Specialization.toEquiv (Specialization.ofEquiv a) = a

full_name: Specialization.ofEquiv_toEquiv
code: @[simp] lemma ofEquiv_toEquiv (a : α) : ofEquiv (toEquiv a) = a 
goal: Specialization.ofEquiv (Specialization.toEquiv a) = a

full_name: Specialization.toEquiv_inj
code: @[simp, nolint simpNF] lemma toEquiv_inj {a b : α} : toEquiv a = toEquiv b ↔ a = b 
goal: Specialization.toEquiv a = Specialization.toEquiv b ↔ a = b

full_name: Specialization.ofEquiv_inj
code: @[simp, nolint simpNF] lemma ofEquiv_inj {a b : Specialization α} : ofEquiv a = ofEquiv b ↔ a = b 
goal: Specialization.ofEquiv a = Specialization.ofEquiv b ↔ a = b

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

full_name: Specialization.instPreorder
code: instance instPreorder : Preorder (Specialization α) 
goal: Preorder (Specialization α)

full_name: Specialization.instPartialOrder
code: instance instPartialOrder [T0Space α] : PartialOrder (Specialization α) 
goal: PartialOrder (Specialization α)

full_name: Specialization.toEquiv_le_toEquiv
code: @[simp] lemma toEquiv_le_toEquiv {a b : α} : toEquiv a ≤ toEquiv b ↔ b ⤳ a 
goal: Specialization.toEquiv a ≤ Specialization.toEquiv b ↔ b ⤳ a

full_name: Specialization.ofEquiv_specializes_ofEquiv
code: @[simp] lemma ofEquiv_specializes_ofEquiv {a b : Specialization α} :
  ofEquiv a ⤳ ofEquiv b ↔ b ≤ a 
goal: Specialization.ofEquiv a ⤳ Specialization.ofEquiv b ↔ b ≤ a

full_name: Specialization.isOpen_toEquiv_preimage
code: @[simp] lemma isOpen_toEquiv_preimage [AlexandrovDiscrete α] {s : Set (Specialization α)} :
  IsOpen (toEquiv ⁻¹' s) ↔ IsUpperSet s 
goal: IsOpen (⇑Specialization.toEquiv ⁻¹' s) ↔ IsUpperSet s

full_name: Specialization.isUpperSet_ofEquiv_preimage
code: @[simp] lemma isUpperSet_ofEquiv_preimage [AlexandrovDiscrete α] {s : Set α} :
  IsUpperSet (ofEquiv ⁻¹' s) ↔ IsOpen s 
goal: IsUpperSet (⇑Specialization.ofEquiv ⁻¹' s) ↔ IsOpen s

full_name: Specialization.map
code: /-- A continuous map between topological spaces induces a monotone map between their specialization
orders. -/
def map (f : C(α, β)) : Specialization α →o Specialization β 
goal: Specialization α →o Specialization β

full_name: Specialization.map_id
code: @[simp] lemma map_id : map (ContinuousMap.id α) = OrderHom.id 
goal: Specialization.map (ContinuousMap.id α) = OrderHom.id

full_name: Specialization.map_comp
code: @[simp] lemma map_comp (g : C(β, γ)) (f : C(α, β)) : map (g.comp f) = (map g).comp (map f) 
goal: Specialization.map (g.comp f) = (Specialization.map g).comp (Specialization.map f)

full_name: orderIsoSpecializationWithUpperSetTopology
code: /-- A preorder is isomorphic to the specialisation order of its upper set topology. -/
def orderIsoSpecializationWithUpperSetTopology (α : Type*) [Preorder α] :
    α ≃o Specialization (WithUpperSet α) 
goal: α ≃o Specialization (Topology.WithUpperSet α)

full_name: homeoWithUpperSetTopologyorderIso
code: /-- An Alexandrov-discrete space is isomorphic to the upper set topology of its specialisation
order. -/
def homeoWithUpperSetTopologyorderIso (α : Type*) [TopologicalSpace α] [AlexandrovDiscrete α] :
    α ≃ₜ WithUpperSet (Specialization α) 
goal: α ≃ₜ Topology.WithUpperSet (Specialization α)

full_name: topToPreord
code: /-- Sends a topological space to its specialisation order. -/
@[simps]
def topToPreord : TopCat ⥤ Preord 
goal: TopCat ⥤ Preord

full_name: topToPreord_map
code: /-- Sends a topological space to its specialisation order. -/
@[simps]
def topToPreord : TopCat ⥤ Preord 
goal: ∀ {X Y : TopCat} (f : C(↑X, ↑Y)), topToPreord.map f = Specialization.map f

full_name: topToPreord_obj
code: /-- Sends a topological space to its specialisation order. -/
@[simps]
def topToPreord : TopCat ⥤ Preord 
goal: topToPreord.obj X = Preord.of (Specialization ↑X)