File: Mathlib/Topology/Sets/Closeds.lean

full_name: TopologicalSpace.Closeds
code: /-- The type of closed subsets of a topological space. -/
structure Closeds (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  closed' : IsClosed carrier
goal: Type u_4

full_name: TopologicalSpace.Closeds.closed'
code: /-- The type of closed subsets of a topological space. -/
structure Closeds (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  closed' : IsClosed carrier
goal: IsClosed self.carrier

full_name: TopologicalSpace.Closeds.carrier
code: /-- The type of closed subsets of a topological space. -/
structure Closeds (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  closed' : IsClosed carrier
goal: Set α

full_name: TopologicalSpace.Closeds.instSetLike
code: instance : SetLike (Closeds α) α 
goal: SetLike (TopologicalSpace.Closeds α) α

full_name: TopologicalSpace.Closeds.instCanLiftSetCoeIsClosed
code: instance : CanLift (Set α) (Closeds α) (↑) IsClosed 
goal: CanLift (Set α) (TopologicalSpace.Closeds α) SetLike.coe IsClosed

full_name: TopologicalSpace.Closeds.closed
code: theorem closed (s : Closeds α) : IsClosed (s : Set α) 
goal: IsClosed ↑s

full_name: TopologicalSpace.Closeds.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (s : Closeds α) : Set α 
goal: Set α

full_name: TopologicalSpace.Closeds.ext
code: @[ext]
protected theorem ext {s t : Closeds α} (h : (s : Set α) = t) : s = t 
goal: s = t

full_name: TopologicalSpace.Closeds.coe_mk
code: @[simp]
theorem coe_mk (s : Set α) (h) : (mk s h : Set α) = s 
goal: ↑{ carrier := s, closed' := h } = s

full_name: TopologicalSpace.Closeds.coe_closure
code: /-- The closure of a set, as an element of `TopologicalSpace.Closeds`. -/
@[simps]
protected def closure (s : Set α) : Closeds α 
goal: ↑(TopologicalSpace.Closeds.closure s) = closure s

full_name: TopologicalSpace.Closeds.closure
code: /-- The closure of a set, as an element of `TopologicalSpace.Closeds`. -/
@[simps]
protected def closure (s : Set α) : Closeds α 
goal: TopologicalSpace.Closeds α

full_name: TopologicalSpace.Closeds.gc
code: theorem gc : GaloisConnection Closeds.closure ((↑) : Closeds α → Set α) 
goal: GaloisConnection TopologicalSpace.Closeds.closure SetLike.coe

full_name: TopologicalSpace.Closeds.gi
code: /-- The galois coinsertion between sets and opens. -/
def gi : GaloisInsertion (@Closeds.closure α _) (↑) 
goal: GaloisInsertion TopologicalSpace.Closeds.closure SetLike.coe

full_name: TopologicalSpace.Closeds.completeLattice
code: instance completeLattice : CompleteLattice (Closeds α) 
goal: CompleteLattice (TopologicalSpace.Closeds α)

full_name: TopologicalSpace.Closeds.instInhabited
code: /-- The type of closed sets is inhabited, with default element the empty set. -/
instance : Inhabited (Closeds α) 
goal: Inhabited (TopologicalSpace.Closeds α)

full_name: TopologicalSpace.Closeds.coe_sup
code: @[simp, norm_cast]
theorem coe_sup (s t : Closeds α) : (↑(s ⊔ t) : Set α) = ↑s ∪ ↑t 
goal: ↑(s ⊔ t) = ↑s ∪ ↑t

full_name: TopologicalSpace.Closeds.coe_inf
code: @[simp, norm_cast]
theorem coe_inf (s t : Closeds α) : (↑(s ⊓ t) : Set α) = ↑s ∩ ↑t 
goal: ↑(s ⊓ t) = ↑s ∩ ↑t

full_name: TopologicalSpace.Closeds.coe_top
code: @[simp, norm_cast]
theorem coe_top : (↑(⊤ : Closeds α) : Set α) = univ 
goal: ↑⊤ = Set.univ

full_name: TopologicalSpace.Closeds.coe_eq_univ
code: @[simp, norm_cast]
theorem coe_eq_univ {s : Closeds α} : (s : Set α) = univ ↔ s = ⊤ 
goal: ↑s = Set.univ ↔ s = ⊤

full_name: TopologicalSpace.Closeds.coe_bot
code: @[simp, norm_cast]
theorem coe_bot : (↑(⊥ : Closeds α) : Set α) = ∅ 
goal: ↑⊥ = ∅

full_name: TopologicalSpace.Closeds.coe_eq_empty
code: @[simp, norm_cast]
theorem coe_eq_empty {s : Closeds α} : (s : Set α) = ∅ ↔ s = ⊥ 
goal: ↑s = ∅ ↔ s = ⊥

full_name: TopologicalSpace.Closeds.coe_nonempty
code: theorem coe_nonempty {s : Closeds α} : (s : Set α).Nonempty ↔ s ≠ ⊥ 
goal: (↑s).Nonempty ↔ s ≠ ⊥

full_name: TopologicalSpace.Closeds.coe_sInf
code: @[simp, norm_cast]
theorem coe_sInf {S : Set (Closeds α)} : (↑(sInf S) : Set α) = ⋂ i ∈ S, ↑i 
goal: ↑(sInf S) = ⋂ i ∈ S, ↑i

full_name: TopologicalSpace.Closeds.coe_sSup
code: @[simp]
lemma coe_sSup {S : Set (Closeds α)} : ((sSup S : Closeds α) : Set α) =
    closure (⋃₀ ((↑) '' S)) 
goal: ↑(sSup S) = closure (⋃₀ (SetLike.coe '' S))

full_name: TopologicalSpace.Closeds.coe_finset_sup
code: @[simp, norm_cast]
theorem coe_finset_sup (f : ι → Closeds α) (s : Finset ι) :
    (↑(s.sup f) : Set α) = s.sup ((↑) ∘ f) 
goal: ↑(s.sup f) = s.sup (SetLike.coe ∘ f)

full_name: TopologicalSpace.Closeds.coe_finset_inf
code: @[simp, norm_cast]
theorem coe_finset_inf (f : ι → Closeds α) (s : Finset ι) :
    (↑(s.inf f) : Set α) = s.inf ((↑) ∘ f) 
goal: ↑(s.inf f) = s.inf (SetLike.coe ∘ f)

full_name: TopologicalSpace.Closeds.mem_sInf
code: @[simp]
theorem mem_sInf {S : Set (Closeds α)} {x : α} : x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s 
goal: x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s

full_name: TopologicalSpace.Closeds.mem_iInf
code: @[simp]
theorem mem_iInf {ι} {x : α} {s : ι → Closeds α} : x ∈ iInf s ↔ ∀ i, x ∈ s i 
goal: x ∈ iInf s ↔ ∀ (i : ι), x ∈ s i

full_name: TopologicalSpace.Closeds.coe_iInf
code: @[simp, norm_cast]
theorem coe_iInf {ι} (s : ι → Closeds α) : ((⨅ i, s i : Closeds α) : Set α) = ⋂ i, s i 
goal: ↑(⨅ i, s i) = ⋂ i, ↑(s i)

full_name: TopologicalSpace.Closeds.iInf_def
code: theorem iInf_def {ι} (s : ι → Closeds α) :
    ⨅ i, s i = ⟨⋂ i, s i, isClosed_iInter fun i => (s i).2⟩ 
goal: ⨅ i, s i = { carrier := ⋂ i, ↑(s i), closed' := ⋯ }

full_name: TopologicalSpace.Closeds.iInf_mk
code: @[simp]
theorem iInf_mk {ι} (s : ι → Set α) (h : ∀ i, IsClosed (s i)) :
    (⨅ i, ⟨s i, h i⟩ : Closeds α) = ⟨⋂ i, s i, isClosed_iInter h⟩ 
goal: ⨅ i, { carrier := s i, closed' := ⋯ } = { carrier := ⋂ i, s i, closed' := ⋯ }

full_name: TopologicalSpace.Closeds.coframeMinimalAxioms
code: /-- Closed sets in a topological space form a coframe. -/
def coframeMinimalAxioms : Coframe.MinimalAxioms (Closeds α) 
goal: Order.Coframe.MinimalAxioms (TopologicalSpace.Closeds α)

full_name: TopologicalSpace.Closeds.instCoframe
code: instance instCoframe : Coframe (Closeds α) 
goal: Order.Coframe (TopologicalSpace.Closeds α)

full_name: TopologicalSpace.Closeds.coe_singleton
code: /-- The term of `TopologicalSpace.Closeds α` corresponding to a singleton. -/
@[simps]
def singleton [T1Space α] (x : α) : Closeds α 
goal: ↑(TopologicalSpace.Closeds.singleton x) = {x}

full_name: TopologicalSpace.Closeds.singleton
code: /-- The term of `TopologicalSpace.Closeds α` corresponding to a singleton. -/
@[simps]
def singleton [T1Space α] (x : α) : Closeds α 
goal: TopologicalSpace.Closeds α

full_name: TopologicalSpace.Closeds.mem_singleton
code: @[simp] lemma mem_singleton [T1Space α] {a b : α} : a ∈ singleton b ↔ a = b 
goal: a ∈ TopologicalSpace.Closeds.singleton b ↔ a = b

full_name: TopologicalSpace.Closeds.compl
code: /-- The complement of a closed set as an open set. -/
@[simps]
def Closeds.compl (s : Closeds α) : Opens α 
goal: TopologicalSpace.Opens α

full_name: TopologicalSpace.Closeds.compl_coe
code: /-- The complement of a closed set as an open set. -/
@[simps]
def Closeds.compl (s : Closeds α) : Opens α 
goal: ↑s.compl = (↑s)ᶜ

full_name: TopologicalSpace.Opens.coe_compl
code: /-- The complement of an open set as a closed set. -/
@[simps]
def Opens.compl (s : Opens α) : Closeds α 
goal: ↑s.compl = (↑s)ᶜ

full_name: TopologicalSpace.Opens.compl
code: /-- The complement of an open set as a closed set. -/
@[simps]
def Opens.compl (s : Opens α) : Closeds α 
goal: TopologicalSpace.Closeds α

full_name: TopologicalSpace.Closeds.compl_compl
code: nonrec theorem Closeds.compl_compl (s : Closeds α) : s.compl.compl = s 
goal: s.compl.compl = s

full_name: TopologicalSpace.Opens.compl_compl
code: nonrec theorem Opens.compl_compl (s : Opens α) : s.compl.compl = s 
goal: s.compl.compl = s

full_name: TopologicalSpace.Closeds.compl_bijective
code: theorem Closeds.compl_bijective : Function.Bijective (@Closeds.compl α _) 
goal: Function.Bijective TopologicalSpace.Closeds.compl

full_name: TopologicalSpace.Opens.compl_bijective
code: theorem Opens.compl_bijective : Function.Bijective (@Opens.compl α _) 
goal: Function.Bijective TopologicalSpace.Opens.compl

full_name: TopologicalSpace.Closeds.complOrderIso_apply
code: /-- `TopologicalSpace.Closeds.compl` as an `OrderIso` to the order dual of
`TopologicalSpace.Opens α`. -/
@[simps]
def Closeds.complOrderIso : Closeds α ≃o (Opens α)ᵒᵈ 
goal: ∀ (a : TopologicalSpace.Closeds α),
  (TopologicalSpace.Closeds.complOrderIso α) a = (⇑OrderDual.toDual ∘ TopologicalSpace.Closeds.compl) a

full_name: TopologicalSpace.Closeds.complOrderIso
code: /-- `TopologicalSpace.Closeds.compl` as an `OrderIso` to the order dual of
`TopologicalSpace.Opens α`. -/
@[simps]
def Closeds.complOrderIso : Closeds α ≃o (Opens α)ᵒᵈ 
goal: TopologicalSpace.Closeds α ≃o (TopologicalSpace.Opens α)ᵒᵈ

full_name: TopologicalSpace.Closeds.complOrderIso_symm_apply
code: /-- `TopologicalSpace.Closeds.compl` as an `OrderIso` to the order dual of
`TopologicalSpace.Opens α`. -/
@[simps]
def Closeds.complOrderIso : Closeds α ≃o (Opens α)ᵒᵈ 
goal: ∀ (a : (TopologicalSpace.Opens α)ᵒᵈ),
  (RelIso.symm (TopologicalSpace.Closeds.complOrderIso α)) a = (TopologicalSpace.Opens.compl ∘ ⇑OrderDual.ofDual) a

full_name: TopologicalSpace.Opens.complOrderIso
code: /-- `TopologicalSpace.Opens.compl` as an `OrderIso` to the order dual of
`TopologicalSpace.Closeds α`. -/
@[simps]
def Opens.complOrderIso : Opens α ≃o (Closeds α)ᵒᵈ 
goal: TopologicalSpace.Opens α ≃o (TopologicalSpace.Closeds α)ᵒᵈ

full_name: TopologicalSpace.Opens.complOrderIso_symm_apply
code: /-- `TopologicalSpace.Opens.compl` as an `OrderIso` to the order dual of
`TopologicalSpace.Closeds α`. -/
@[simps]
def Opens.complOrderIso : Opens α ≃o (Closeds α)ᵒᵈ 
goal: ∀ (a : (TopologicalSpace.Closeds α)ᵒᵈ),
  (RelIso.symm (TopologicalSpace.Opens.complOrderIso α)) a = (TopologicalSpace.Closeds.compl ∘ ⇑OrderDual.ofDual) a

full_name: TopologicalSpace.Opens.complOrderIso_apply
code: /-- `TopologicalSpace.Opens.compl` as an `OrderIso` to the order dual of
`TopologicalSpace.Closeds α`. -/
@[simps]
def Opens.complOrderIso : Opens α ≃o (Closeds α)ᵒᵈ 
goal: ∀ (a : TopologicalSpace.Opens α),
  (TopologicalSpace.Opens.complOrderIso α) a = (⇑OrderDual.toDual ∘ TopologicalSpace.Opens.compl) a

full_name: TopologicalSpace.Closeds.coe_eq_singleton_of_isAtom
code: lemma Closeds.coe_eq_singleton_of_isAtom [T0Space α] {s : Closeds α} (hs : IsAtom s) :
    ∃ a, (s : Set α) = {a} 
goal: ∃ a, ↑s = {a}

full_name: TopologicalSpace.Closeds.isAtom_coe
code: @[simp, norm_cast] lemma Closeds.isAtom_coe [T1Space α] {s : Closeds α} :
    IsAtom (s : Set α) ↔ IsAtom s 
goal: IsAtom ↑s ↔ IsAtom s

full_name: TopologicalSpace.Closeds.isAtom_iff
code: /-- in a `T1Space`, atoms of `TopologicalSpace.Closeds α` are precisely the
`TopologicalSpace.Closeds.singleton`s. -/
theorem Closeds.isAtom_iff [T1Space α] {s : Closeds α} :
    IsAtom s ↔ ∃ x, s = Closeds.singleton x 
goal: IsAtom s ↔ ∃ x, s = TopologicalSpace.Closeds.singleton x

full_name: TopologicalSpace.Opens.isCoatom_iff
code: /-- in a `T1Space`, coatoms of `TopologicalSpace.Opens α` are precisely complements of singletons:
`(TopologicalSpace.Closeds.singleton x).compl`. -/
theorem Opens.isCoatom_iff [T1Space α] {s : Opens α} :
    IsCoatom s ↔ ∃ x, s = (Closeds.singleton x).compl 
goal: IsCoatom s ↔ ∃ x, s = (TopologicalSpace.Closeds.singleton x).compl

full_name: TopologicalSpace.Clopens.isClopen'
code: /-- The type of clopen sets of a topological space. -/
structure Clopens (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  isClopen' : IsClopen carrier
goal: IsClopen self.carrier

full_name: TopologicalSpace.Clopens
code: /-- The type of clopen sets of a topological space. -/
structure Clopens (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  isClopen' : IsClopen carrier
goal: Type u_4

full_name: TopologicalSpace.Clopens.carrier
code: /-- The type of clopen sets of a topological space. -/
structure Clopens (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  isClopen' : IsClopen carrier
goal: Set α

full_name: TopologicalSpace.Clopens.instSetLike
code: instance : SetLike (Clopens α) α 
goal: SetLike (TopologicalSpace.Clopens α) α

full_name: TopologicalSpace.Clopens.isClopen
code: theorem isClopen (s : Clopens α) : IsClopen (s : Set α) 
goal: IsClopen ↑s

full_name: TopologicalSpace.Clopens.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (s : Clopens α) : Set α 
goal: Set α

full_name: TopologicalSpace.Clopens.toOpens_coe
code: /-- Reinterpret a clopen as an open. -/
@[simps]
def toOpens (s : Clopens α) : Opens α 
goal: ↑s.toOpens = ↑s

full_name: TopologicalSpace.Clopens.toOpens
code: /-- Reinterpret a clopen as an open. -/
@[simps]
def toOpens (s : Clopens α) : Opens α 
goal: TopologicalSpace.Opens α

full_name: TopologicalSpace.Clopens.ext
code: @[ext]
protected theorem ext {s t : Clopens α} (h : (s : Set α) = t) : s = t 
goal: s = t

full_name: TopologicalSpace.Clopens.coe_mk
code: @[simp]
theorem coe_mk (s : Set α) (h) : (mk s h : Set α) = s 
goal: ↑{ carrier := s, isClopen' := h } = s

full_name: TopologicalSpace.Clopens.mem_mk
code: @[simp] lemma mem_mk {s : Set α} {x h} : x ∈ mk s h ↔ x ∈ s 
goal: x ∈ { carrier := s, isClopen' := h } ↔ x ∈ s

full_name: TopologicalSpace.Clopens.instSup
code: instance : Sup (Clopens α) 
goal: Sup (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.instInf
code: instance : Inf (Clopens α) 
goal: Inf (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.instTop
code: instance : Top (Clopens α) 
goal: Top (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.instBot
code: instance : Bot (Clopens α) 
goal: Bot (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.instSDiff
code: instance : SDiff (Clopens α) 
goal: SDiff (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.instHImp
code: instance : HImp (Clopens α) 
goal: HImp (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.instHasCompl
code: instance : HasCompl (Clopens α) 
goal: HasCompl (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.coe_sup
code: @[simp, norm_cast] lemma coe_sup (s t : Clopens α) : ↑(s ⊔ t) = (s ∪ t : Set α) 
goal: ↑(s ⊔ t) = ↑s ∪ ↑t

full_name: TopologicalSpace.Clopens.coe_inf
code: @[simp, norm_cast] lemma coe_inf (s t : Clopens α) : ↑(s ⊓ t) = (s ∩ t : Set α) 
goal: ↑(s ⊓ t) = ↑s ∩ ↑t

full_name: TopologicalSpace.Clopens.coe_top
code: @[simp, norm_cast] lemma coe_top : (↑(⊤ : Clopens α) : Set α) = univ 
goal: ↑⊤ = Set.univ

full_name: TopologicalSpace.Clopens.coe_bot
code: @[simp, norm_cast] lemma coe_bot : (↑(⊥ : Clopens α) : Set α) = ∅ 
goal: ↑⊥ = ∅

full_name: TopologicalSpace.Clopens.coe_sdiff
code: @[simp, norm_cast] lemma coe_sdiff (s t : Clopens α) : ↑(s \ t) = (s \ t : Set α) 
goal: ↑(s \ t) = ↑s \ ↑t

full_name: TopologicalSpace.Clopens.coe_himp
code: @[simp, norm_cast] lemma coe_himp (s t : Clopens α) : ↑(s ⇨ t) = (s ⇨ t : Set α) 
goal: ↑(s ⇨ t) = ↑s ⇨ ↑t

full_name: TopologicalSpace.Clopens.coe_compl
code: @[simp, norm_cast] lemma coe_compl (s : Clopens α) : (↑sᶜ : Set α) = (↑s)ᶜ 
goal: ↑sᶜ = (↑s)ᶜ

full_name: TopologicalSpace.Clopens.instBooleanAlgebra
code: instance : BooleanAlgebra (Clopens α) 
goal: BooleanAlgebra (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.instInhabited
code: instance : Inhabited (Clopens α) 
goal: Inhabited (TopologicalSpace.Clopens α)

full_name: TopologicalSpace.Clopens.instSProdProd
code: instance : SProd (Clopens α) (Clopens β) (Clopens (α × β)) 
goal: SProd (TopologicalSpace.Clopens α) (TopologicalSpace.Clopens β) (TopologicalSpace.Clopens (α × β))

full_name: TopologicalSpace.Clopens.mem_prod
code: @[simp]
protected lemma mem_prod {s : Clopens α} {t : Clopens β} {x : α × β} :
    x ∈ s ×ˢ t ↔ x.1 ∈ s ∧ x.2 ∈ t 
goal: x ∈ s ×ˢ t ↔ x.1 ∈ s ∧ x.2 ∈ t

full_name: TopologicalSpace.IrreducibleCloseds.is_closed'
code: /-- The type of irreducible closed subsets of a topological space. -/
structure IrreducibleCloseds (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  is_irreducible' : IsIrreducible carrier
  is_closed' : IsClosed carrier
goal: IsClosed self.carrier

full_name: TopologicalSpace.IrreducibleCloseds.is_irreducible'
code: /-- The type of irreducible closed subsets of a topological space. -/
structure IrreducibleCloseds (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  is_irreducible' : IsIrreducible carrier
  is_closed' : IsClosed carrier
goal: IsIrreducible self.carrier

full_name: TopologicalSpace.IrreducibleCloseds
code: /-- The type of irreducible closed subsets of a topological space. -/
structure IrreducibleCloseds (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  is_irreducible' : IsIrreducible carrier
  is_closed' : IsClosed carrier
goal: Type u_4

full_name: TopologicalSpace.IrreducibleCloseds.carrier
code: /-- The type of irreducible closed subsets of a topological space. -/
structure IrreducibleCloseds (α : Type*) [TopologicalSpace α] where
  /-- the carrier set, i.e. the points in this set -/
  carrier : Set α
  is_irreducible' : IsIrreducible carrier
  is_closed' : IsClosed carrier
goal: Set α

full_name: TopologicalSpace.IrreducibleCloseds.instSetLike
code: instance : SetLike (IrreducibleCloseds α) α 
goal: SetLike (TopologicalSpace.IrreducibleCloseds α) α

full_name: TopologicalSpace.IrreducibleCloseds.instCanLiftSetCoeAndIsIrreducibleIsClosed
code: instance : CanLift (Set α) (IrreducibleCloseds α) (↑) (fun s ↦ IsIrreducible s ∧ IsClosed s) 
goal: CanLift (Set α) (TopologicalSpace.IrreducibleCloseds α) SetLike.coe fun s => IsIrreducible s ∧ IsClosed s

full_name: TopologicalSpace.IrreducibleCloseds.isIrreducible
code: theorem isIrreducible (s : IrreducibleCloseds α) : IsIrreducible (s : Set α) 
goal: IsIrreducible ↑s

full_name: TopologicalSpace.IrreducibleCloseds.isClosed
code: theorem isClosed (s : IrreducibleCloseds α) : IsClosed (s : Set α) 
goal: IsClosed ↑s

full_name: TopologicalSpace.IrreducibleCloseds.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (s : IrreducibleCloseds α) : Set α 
goal: Set α

full_name: TopologicalSpace.IrreducibleCloseds.ext
code: @[ext]
protected theorem ext {s t : IrreducibleCloseds α} (h : (s : Set α) = t) : s = t 
goal: s = t

full_name: TopologicalSpace.IrreducibleCloseds.coe_mk
code: @[simp]
theorem coe_mk (s : Set α) (h : IsIrreducible s) (h' : IsClosed s) : (mk s h h' : Set α) = s 
goal: ↑{ carrier := s, is_irreducible' := h, is_closed' := h' } = s

full_name: TopologicalSpace.IrreducibleCloseds.singleton
code: /-- The term of `TopologicalSpace.IrreducibleCloseds α` corresponding to a singleton. -/
@[simps]
def singleton [T1Space α] (x : α) : IrreducibleCloseds α 
goal: TopologicalSpace.IrreducibleCloseds α

full_name: TopologicalSpace.IrreducibleCloseds.coe_singleton
code: /-- The term of `TopologicalSpace.IrreducibleCloseds α` corresponding to a singleton. -/
@[simps]
def singleton [T1Space α] (x : α) : IrreducibleCloseds α 
goal: ↑(TopologicalSpace.IrreducibleCloseds.singleton x) = {x}

full_name: TopologicalSpace.IrreducibleCloseds.mem_singleton
code: @[simp] lemma mem_singleton [T1Space α] {a b : α} : a ∈ singleton b ↔ a = b 
goal: a ∈ TopologicalSpace.IrreducibleCloseds.singleton b ↔ a = b

full_name: TopologicalSpace.IrreducibleCloseds.equivSubtype_symm_apply
code: /--
The equivalence between `IrreducibleCloseds α` and `{x : Set α // IsIrreducible x ∧ IsClosed x }`.
-/
@[simps apply symm_apply]
def equivSubtype : IrreducibleCloseds α ≃ { x : Set α // IsIrreducible x ∧ IsClosed x } 
goal: TopologicalSpace.IrreducibleCloseds.equivSubtype.symm a = { carrier := ↑a, is_irreducible' := ⋯, is_closed' := ⋯ }

full_name: TopologicalSpace.IrreducibleCloseds.equivSubtype_apply
code: /--
The equivalence between `IrreducibleCloseds α` and `{x : Set α // IsIrreducible x ∧ IsClosed x }`.
-/
@[simps apply symm_apply]
def equivSubtype : IrreducibleCloseds α ≃ { x : Set α // IsIrreducible x ∧ IsClosed x } 
goal: TopologicalSpace.IrreducibleCloseds.equivSubtype a = ⟨a.carrier, ⋯⟩

full_name: TopologicalSpace.IrreducibleCloseds.equivSubtype
code: /--
The equivalence between `IrreducibleCloseds α` and `{x : Set α // IsIrreducible x ∧ IsClosed x }`.
-/
@[simps apply symm_apply]
def equivSubtype : IrreducibleCloseds α ≃ { x : Set α // IsIrreducible x ∧ IsClosed x } 
goal: TopologicalSpace.IrreducibleCloseds α ≃ { x // IsIrreducible x ∧ IsClosed x }

full_name: TopologicalSpace.IrreducibleCloseds.equivSubtype'_apply
code: /--
The equivalence between `IrreducibleCloseds α` and `{x : Set α // IsClosed x ∧ IsIrreducible x }`.
-/
@[simps apply symm_apply]
def equivSubtype' : IrreducibleCloseds α ≃ { x : Set α // IsClosed x ∧ IsIrreducible x } 
goal: TopologicalSpace.IrreducibleCloseds.equivSubtype' a = ⟨a.carrier, ⋯⟩

full_name: TopologicalSpace.IrreducibleCloseds.equivSubtype'_symm_apply
code: /--
The equivalence between `IrreducibleCloseds α` and `{x : Set α // IsClosed x ∧ IsIrreducible x }`.
-/
@[simps apply symm_apply]
def equivSubtype' : IrreducibleCloseds α ≃ { x : Set α // IsClosed x ∧ IsIrreducible x } 
goal: TopologicalSpace.IrreducibleCloseds.equivSubtype'.symm a = { carrier := ↑a, is_irreducible' := ⋯, is_closed' := ⋯ }

full_name: TopologicalSpace.IrreducibleCloseds.equivSubtype'
code: /--
The equivalence between `IrreducibleCloseds α` and `{x : Set α // IsClosed x ∧ IsIrreducible x }`.
-/
@[simps apply symm_apply]
def equivSubtype' : IrreducibleCloseds α ≃ { x : Set α // IsClosed x ∧ IsIrreducible x } 
goal: TopologicalSpace.IrreducibleCloseds α ≃ { x // IsClosed x ∧ IsIrreducible x }

full_name: TopologicalSpace.IrreducibleCloseds.orderIsoSubtype
code: /-- The equivalence `IrreducibleCloseds α ≃ { x : Set α // IsIrreducible x ∧ IsClosed x }` is an
order isomorphism.-/
def orderIsoSubtype : IrreducibleCloseds α ≃o { x : Set α // IsIrreducible x ∧ IsClosed x } 
goal: TopologicalSpace.IrreducibleCloseds α ≃o { x // IsIrreducible x ∧ IsClosed x }

full_name: TopologicalSpace.IrreducibleCloseds.orderIsoSubtype'
code: /-- The equivalence `IrreducibleCloseds α ≃ { x : Set α // IsClosed x ∧ IsIrreducible x }` is an
order isomorphism.-/
def orderIsoSubtype' : IrreducibleCloseds α ≃o { x : Set α // IsClosed x ∧ IsIrreducible x } 
goal: TopologicalSpace.IrreducibleCloseds α ≃o { x // IsClosed x ∧ IsIrreducible x }