File: Mathlib/Topology/Sets/Compacts.lean

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

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

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

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

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

full_name: TopologicalSpace.Compacts.isCompact
code: protected theorem isCompact (s : Compacts α) : IsCompact (s : Set α) 
goal: IsCompact ↑s

full_name: TopologicalSpace.Compacts.instCompactSpaceSubtypeMem
code: instance (K : Compacts α) : CompactSpace K 
goal: CompactSpace ↥K

full_name: TopologicalSpace.Compacts.instCanLiftSetCoeIsCompact
code: instance : CanLift (Set α) (Compacts α) (↑) IsCompact 
goal: CanLift (Set α) (TopologicalSpace.Compacts α) SetLike.coe IsCompact

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

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

full_name: TopologicalSpace.Compacts.carrier_eq_coe
code: @[simp]
theorem carrier_eq_coe (s : Compacts α) : s.carrier = s 
goal: s.carrier = ↑s

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

full_name: TopologicalSpace.Compacts.instInfOfT2Space
code: instance [T2Space α] : Inf (Compacts α) 
goal: Inf (TopologicalSpace.Compacts α)

full_name: TopologicalSpace.Compacts.instTopOfCompactSpace
code: instance [CompactSpace α] : Top (Compacts α) 
goal: Top (TopologicalSpace.Compacts α)

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

full_name: TopologicalSpace.Compacts.instSemilatticeSup
code: instance : SemilatticeSup (Compacts α) 
goal: SemilatticeSup (TopologicalSpace.Compacts α)

full_name: TopologicalSpace.Compacts.instDistribLatticeOfT2Space
code: instance [T2Space α] : DistribLattice (Compacts α) 
goal: DistribLattice (TopologicalSpace.Compacts α)

full_name: TopologicalSpace.Compacts.instOrderBot
code: instance : OrderBot (Compacts α) 
goal: OrderBot (TopologicalSpace.Compacts α)

full_name: TopologicalSpace.Compacts.instBoundedOrderOfCompactSpace
code: instance [CompactSpace α] : BoundedOrder (Compacts α) 
goal: BoundedOrder (TopologicalSpace.Compacts α)

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

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

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

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

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

full_name: TopologicalSpace.Compacts.coe_finset_sup
code: @[simp]
theorem coe_finset_sup {ι : Type*} {s : Finset ι} {f : ι → Compacts α} :
    (↑(s.sup f) : Set α) = s.sup fun i => ↑(f i) 
goal: ↑(s.sup f) = s.sup fun i => ↑(f i)

full_name: TopologicalSpace.Compacts.map
code: /-- The image of a compact set under a continuous function. -/
protected def map (f : α → β) (hf : Continuous f) (K : Compacts α) : Compacts β 
goal: TopologicalSpace.Compacts β

full_name: TopologicalSpace.Compacts.coe_map
code: @[simp, norm_cast]
theorem coe_map {f : α → β} (hf : Continuous f) (s : Compacts α) : (s.map f hf : Set β) = f '' s 
goal: ↑(TopologicalSpace.Compacts.map f hf s) = f '' ↑s

full_name: TopologicalSpace.Compacts.map_id
code: @[simp]
theorem map_id (K : Compacts α) : K.map id continuous_id = K 
goal: TopologicalSpace.Compacts.map id ⋯ K = K

full_name: TopologicalSpace.Compacts.map_comp
code: theorem map_comp (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (K : Compacts α) :
    K.map (f ∘ g) (hf.comp hg) = (K.map g hg).map f hf 
goal: TopologicalSpace.Compacts.map (f ∘ g) ⋯ K = TopologicalSpace.Compacts.map f hf (TopologicalSpace.Compacts.map g hg K)

full_name: TopologicalSpace.Compacts.equiv_symm_apply
code: /-- A homeomorphism induces an equivalence on compact sets, by taking the image. -/
@[simps]
protected def equiv (f : α ≃ₜ β) : Compacts α ≃ Compacts β 
goal: (TopologicalSpace.Compacts.equiv f).symm K = TopologicalSpace.Compacts.map ⇑f.symm ⋯ K

full_name: TopologicalSpace.Compacts.equiv_apply
code: /-- A homeomorphism induces an equivalence on compact sets, by taking the image. -/
@[simps]
protected def equiv (f : α ≃ₜ β) : Compacts α ≃ Compacts β 
goal: (TopologicalSpace.Compacts.equiv f) K = TopologicalSpace.Compacts.map ⇑f ⋯ K

full_name: TopologicalSpace.Compacts.equiv
code: /-- A homeomorphism induces an equivalence on compact sets, by taking the image. -/
@[simps]
protected def equiv (f : α ≃ₜ β) : Compacts α ≃ Compacts β 
goal: TopologicalSpace.Compacts α ≃ TopologicalSpace.Compacts β

full_name: TopologicalSpace.Compacts.equiv_refl
code: @[simp]
theorem equiv_refl : Compacts.equiv (Homeomorph.refl α) = Equiv.refl _ 
goal: TopologicalSpace.Compacts.equiv (Homeomorph.refl α) = Equiv.refl (TopologicalSpace.Compacts α)

full_name: TopologicalSpace.Compacts.equiv_trans
code: @[simp]
theorem equiv_trans (f : α ≃ₜ β) (g : β ≃ₜ γ) :
    Compacts.equiv (f.trans g) = (Compacts.equiv f).trans (Compacts.equiv g) 
goal: TopologicalSpace.Compacts.equiv (f.trans g) =
  (TopologicalSpace.Compacts.equiv f).trans (TopologicalSpace.Compacts.equiv g)

full_name: TopologicalSpace.Compacts.equiv_symm
code: @[simp]
theorem equiv_symm (f : α ≃ₜ β) : Compacts.equiv f.symm = (Compacts.equiv f).symm 
goal: TopologicalSpace.Compacts.equiv f.symm = (TopologicalSpace.Compacts.equiv f).symm

full_name: TopologicalSpace.Compacts.coe_equiv_apply_eq_preimage
code: /-- The image of a compact set under a homeomorphism can also be expressed as a preimage. -/
theorem coe_equiv_apply_eq_preimage (f : α ≃ₜ β) (K : Compacts α) :
    (Compacts.equiv f K : Set β) = f.symm ⁻¹' (K : Set α) 
goal: ↑((TopologicalSpace.Compacts.equiv f) K) = ⇑f.symm ⁻¹' ↑K

full_name: TopologicalSpace.Compacts.prod
code: /-- The product of two `TopologicalSpace.Compacts`, as a `TopologicalSpace.Compacts` in the product
space. -/
protected def prod (K : Compacts α) (L : Compacts β) : Compacts (α × β) 
goal: TopologicalSpace.Compacts (α × β)

full_name: TopologicalSpace.Compacts.coe_prod
code: @[simp]
theorem coe_prod (K : Compacts α) (L : Compacts β) :
    (K.prod L : Set (α × β)) = (K : Set α) ×ˢ (L : Set β) 
goal: ↑(K.prod L) = ↑K ×ˢ ↑L

full_name: TopologicalSpace.NonemptyCompacts.nonempty'
code: /-- The type of nonempty compact sets of a topological space. -/
structure NonemptyCompacts (α : Type*) [TopologicalSpace α] extends Compacts α where
  nonempty' : carrier.Nonempty
goal: self.carrier.Nonempty

full_name: TopologicalSpace.NonemptyCompacts
code: /-- The type of nonempty compact sets of a topological space. -/
structure NonemptyCompacts (α : Type*) [TopologicalSpace α] extends Compacts α where
  nonempty' : carrier.Nonempty
goal: Type u_4

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

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

full_name: TopologicalSpace.NonemptyCompacts.isCompact
code: protected theorem isCompact (s : NonemptyCompacts α) : IsCompact (s : Set α) 
goal: IsCompact ↑s

full_name: TopologicalSpace.NonemptyCompacts.nonempty
code: protected theorem nonempty (s : NonemptyCompacts α) : (s : Set α).Nonempty 
goal: (↑s).Nonempty

full_name: TopologicalSpace.NonemptyCompacts.toCloseds
code: /-- Reinterpret a nonempty compact as a closed set. -/
def toCloseds [T2Space α] (s : NonemptyCompacts α) : Closeds α 
goal: TopologicalSpace.Closeds α

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

full_name: TopologicalSpace.NonemptyCompacts.coe_mk
code: @[simp]
theorem coe_mk (s : Compacts α) (h) : (mk s h : Set α) = s 
goal: ↑{ toCompacts := s, nonempty' := h } = ↑s

full_name: TopologicalSpace.NonemptyCompacts.carrier_eq_coe
code: theorem carrier_eq_coe (s : NonemptyCompacts α) : s.carrier = s 
goal: s.carrier = ↑s

full_name: TopologicalSpace.NonemptyCompacts.coe_toCompacts
code: @[simp]
theorem coe_toCompacts (s : NonemptyCompacts α) : (s.toCompacts : Set α) = s 
goal: ↑s.toCompacts = ↑s

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

full_name: TopologicalSpace.NonemptyCompacts.instTopOfCompactSpaceOfNonempty
code: instance [CompactSpace α] [Nonempty α] : Top (NonemptyCompacts α) 
goal: Top (TopologicalSpace.NonemptyCompacts α)

full_name: TopologicalSpace.NonemptyCompacts.instSemilatticeSup
code: instance : SemilatticeSup (NonemptyCompacts α) 
goal: SemilatticeSup (TopologicalSpace.NonemptyCompacts α)

full_name: TopologicalSpace.NonemptyCompacts.instOrderTopOfCompactSpaceOfNonempty
code: instance [CompactSpace α] [Nonempty α] : OrderTop (NonemptyCompacts α) 
goal: OrderTop (TopologicalSpace.NonemptyCompacts α)

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

full_name: TopologicalSpace.NonemptyCompacts.coe_top
code: @[simp]
theorem coe_top [CompactSpace α] [Nonempty α] : (↑(⊤ : NonemptyCompacts α) : Set α) = univ 
goal: ↑⊤ = Set.univ

full_name: TopologicalSpace.NonemptyCompacts.instInhabited
code: /-- In an inhabited space, the type of nonempty compact subsets is also inhabited, with
default element the singleton set containing the default element. -/
instance [Inhabited α] : Inhabited (NonemptyCompacts α) 
goal: Inhabited (TopologicalSpace.NonemptyCompacts α)

full_name: TopologicalSpace.NonemptyCompacts.toCompactSpace
code: instance toCompactSpace {s : NonemptyCompacts α} : CompactSpace s 
goal: CompactSpace ↥s

full_name: TopologicalSpace.NonemptyCompacts.toNonempty
code: instance toNonempty {s : NonemptyCompacts α} : Nonempty s 
goal: Nonempty ↥s

full_name: TopologicalSpace.NonemptyCompacts.prod
code: /-- The product of two `TopologicalSpace.NonemptyCompacts`, as a `TopologicalSpace.NonemptyCompacts`
in the product space. -/
protected def prod (K : NonemptyCompacts α) (L : NonemptyCompacts β) : NonemptyCompacts (α × β) 
goal: TopologicalSpace.NonemptyCompacts (α × β)

full_name: TopologicalSpace.NonemptyCompacts.coe_prod
code: @[simp]
theorem coe_prod (K : NonemptyCompacts α) (L : NonemptyCompacts β) :
    (K.prod L : Set (α × β)) = (K : Set α) ×ˢ (L : Set β) 
goal: ↑(K.prod L) = ↑K ×ˢ ↑L

full_name: TopologicalSpace.PositiveCompacts.interior_nonempty'
code: /-- The type of compact sets with nonempty interior of a topological space.
See also `TopologicalSpace.Compacts` and `TopologicalSpace.NonemptyCompacts`. -/
structure PositiveCompacts (α : Type*) [TopologicalSpace α] extends Compacts α where
  interior_nonempty' : (interior carrier).Nonempty
goal: (interior self.carrier).Nonempty

full_name: TopologicalSpace.PositiveCompacts
code: /-- The type of compact sets with nonempty interior of a topological space.
See also `TopologicalSpace.Compacts` and `TopologicalSpace.NonemptyCompacts`. -/
structure PositiveCompacts (α : Type*) [TopologicalSpace α] extends Compacts α where
  interior_nonempty' : (interior carrier).Nonempty
goal: Type u_4

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

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

full_name: TopologicalSpace.PositiveCompacts.isCompact
code: protected theorem isCompact (s : PositiveCompacts α) : IsCompact (s : Set α) 
goal: IsCompact ↑s

full_name: TopologicalSpace.PositiveCompacts.interior_nonempty
code: theorem interior_nonempty (s : PositiveCompacts α) : (interior (s : Set α)).Nonempty 
goal: (interior ↑s).Nonempty

full_name: TopologicalSpace.PositiveCompacts.nonempty
code: protected theorem nonempty (s : PositiveCompacts α) : (s : Set α).Nonempty 
goal: (↑s).Nonempty

full_name: TopologicalSpace.PositiveCompacts.toNonemptyCompacts
code: /-- Reinterpret a positive compact as a nonempty compact. -/
def toNonemptyCompacts (s : PositiveCompacts α) : NonemptyCompacts α 
goal: TopologicalSpace.NonemptyCompacts α

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

full_name: TopologicalSpace.PositiveCompacts.coe_mk
code: @[simp]
theorem coe_mk (s : Compacts α) (h) : (mk s h : Set α) = s 
goal: ↑{ toCompacts := s, interior_nonempty' := h } = ↑s

full_name: TopologicalSpace.PositiveCompacts.carrier_eq_coe
code: theorem carrier_eq_coe (s : PositiveCompacts α) : s.carrier = s 
goal: s.carrier = ↑s

full_name: TopologicalSpace.PositiveCompacts.coe_toCompacts
code: @[simp]
theorem coe_toCompacts (s : PositiveCompacts α) : (s.toCompacts : Set α) = s 
goal: ↑s.toCompacts = ↑s

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

full_name: TopologicalSpace.PositiveCompacts.instTopOfCompactSpaceOfNonempty
code: instance [CompactSpace α] [Nonempty α] : Top (PositiveCompacts α) 
goal: Top (TopologicalSpace.PositiveCompacts α)

full_name: TopologicalSpace.PositiveCompacts.instSemilatticeSup
code: instance : SemilatticeSup (PositiveCompacts α) 
goal: SemilatticeSup (TopologicalSpace.PositiveCompacts α)

full_name: TopologicalSpace.PositiveCompacts.instOrderTopOfCompactSpaceOfNonempty
code: instance [CompactSpace α] [Nonempty α] : OrderTop (PositiveCompacts α) 
goal: OrderTop (TopologicalSpace.PositiveCompacts α)

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

full_name: TopologicalSpace.PositiveCompacts.coe_top
code: @[simp]
theorem coe_top [CompactSpace α] [Nonempty α] : (↑(⊤ : PositiveCompacts α) : Set α) = univ 
goal: ↑⊤ = Set.univ

full_name: TopologicalSpace.PositiveCompacts.map
code: /-- The image of a positive compact set under a continuous open map. -/
protected def map (f : α → β) (hf : Continuous f) (hf' : IsOpenMap f) (K : PositiveCompacts α) :
    PositiveCompacts β 
goal: TopologicalSpace.PositiveCompacts β

full_name: TopologicalSpace.PositiveCompacts.coe_map
code: @[simp, norm_cast]
theorem coe_map {f : α → β} (hf : Continuous f) (hf' : IsOpenMap f) (s : PositiveCompacts α) :
    (s.map f hf hf' : Set β) = f '' s 
goal: ↑(TopologicalSpace.PositiveCompacts.map f hf hf' s) = f '' ↑s

full_name: TopologicalSpace.PositiveCompacts.map_id
code: @[simp]
theorem map_id (K : PositiveCompacts α) : K.map id continuous_id IsOpenMap.id = K 
goal: TopologicalSpace.PositiveCompacts.map id ⋯ ⋯ K = K

full_name: TopologicalSpace.PositiveCompacts.map_comp
code: theorem map_comp (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (hf' : IsOpenMap f)
    (hg' : IsOpenMap g) (K : PositiveCompacts α) :
    K.map (f ∘ g) (hf.comp hg) (hf'.comp hg') = (K.map g hg hg').map f hf hf' 
goal: TopologicalSpace.PositiveCompacts.map (f ∘ g) ⋯ ⋯ K =
  TopologicalSpace.PositiveCompacts.map f hf hf' (TopologicalSpace.PositiveCompacts.map g hg hg' K)

full_name: exists_positiveCompacts_subset
code: theorem _root_.exists_positiveCompacts_subset [LocallyCompactSpace α] {U : Set α} (ho : IsOpen U)
    (hn : U.Nonempty) : ∃ K : PositiveCompacts α, ↑K ⊆ U 
goal: ∃ K, ↑K ⊆ U

full_name: IsOpen.exists_positiveCompacts_closure_subset
code: theorem _root_.IsOpen.exists_positiveCompacts_closure_subset [R1Space α] [LocallyCompactSpace α]
    {U : Set α} (ho : IsOpen U) (hn : U.Nonempty) : ∃ K : PositiveCompacts α, closure ↑K ⊆ U 
goal: ∃ K, closure ↑K ⊆ U

full_name: TopologicalSpace.PositiveCompacts.instInhabitedOfCompactSpaceOfNonempty
code: instance [CompactSpace α] [Nonempty α] : Inhabited (PositiveCompacts α) 
goal: Inhabited (TopologicalSpace.PositiveCompacts α)

full_name: TopologicalSpace.PositiveCompacts.nonempty'
code: /-- In a nonempty locally compact space, there exists a compact set with nonempty interior. -/
instance nonempty' [WeaklyLocallyCompactSpace α] [Nonempty α] : Nonempty (PositiveCompacts α) 
goal: Nonempty (TopologicalSpace.PositiveCompacts α)

full_name: TopologicalSpace.PositiveCompacts.prod
code: /-- The product of two `TopologicalSpace.PositiveCompacts`, as a `TopologicalSpace.PositiveCompacts`
in the product space. -/
protected def prod (K : PositiveCompacts α) (L : PositiveCompacts β) :
    PositiveCompacts (α × β) 
goal: TopologicalSpace.PositiveCompacts (α × β)

full_name: TopologicalSpace.PositiveCompacts.coe_prod
code: @[simp]
theorem coe_prod (K : PositiveCompacts α) (L : PositiveCompacts β) :
    (K.prod L : Set (α × β)) = (K : Set α) ×ˢ (L : Set β) 
goal: ↑(K.prod L) = ↑K ×ˢ ↑L

full_name: TopologicalSpace.CompactOpens.isOpen'
code: /-- The type of compact open sets of a topological space. This is useful in non Hausdorff contexts,
in particular spectral spaces. -/
structure CompactOpens (α : Type*) [TopologicalSpace α] extends Compacts α where
  isOpen' : IsOpen carrier
goal: IsOpen self.carrier

full_name: TopologicalSpace.CompactOpens
code: /-- The type of compact open sets of a topological space. This is useful in non Hausdorff contexts,
in particular spectral spaces. -/
structure CompactOpens (α : Type*) [TopologicalSpace α] extends Compacts α where
  isOpen' : IsOpen carrier
goal: Type u_4

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

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

full_name: TopologicalSpace.CompactOpens.isCompact
code: protected theorem isCompact (s : CompactOpens α) : IsCompact (s : Set α) 
goal: IsCompact ↑s

full_name: TopologicalSpace.CompactOpens.isOpen
code: protected theorem isOpen (s : CompactOpens α) : IsOpen (s : Set α) 
goal: IsOpen ↑s

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

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

full_name: TopologicalSpace.CompactOpens.toClopens_coe
code: /-- Reinterpret a compact open as a clopen. -/
@[simps]
def toClopens [T2Space α] (s : CompactOpens α) : Clopens α 
goal: ↑s.toClopens = ↑s

full_name: TopologicalSpace.CompactOpens.toClopens
code: /-- Reinterpret a compact open as a clopen. -/
@[simps]
def toClopens [T2Space α] (s : CompactOpens α) : Clopens α 
goal: TopologicalSpace.Clopens α

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

full_name: TopologicalSpace.CompactOpens.coe_mk
code: @[simp]
theorem coe_mk (s : Compacts α) (h) : (mk s h : Set α) = s 
goal: ↑{ toCompacts := s, isOpen' := h } = ↑s

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

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

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

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

full_name: TopologicalSpace.CompactOpens.instSemilatticeSup
code: instance : SemilatticeSup (CompactOpens α) 
goal: SemilatticeSup (TopologicalSpace.CompactOpens α)

full_name: TopologicalSpace.CompactOpens.instOrderBot
code: instance : OrderBot (CompactOpens α) 
goal: OrderBot (TopologicalSpace.CompactOpens α)

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

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

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

full_name: TopologicalSpace.CompactOpens.instSemilatticeInf
code: instance instSemilatticeInf : SemilatticeInf (CompactOpens α) 
goal: SemilatticeInf (TopologicalSpace.CompactOpens α)

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

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

full_name: TopologicalSpace.CompactOpens.instGeneralizedBooleanAlgebra
code: instance instGeneralizedBooleanAlgebra : GeneralizedBooleanAlgebra (CompactOpens α) 
goal: GeneralizedBooleanAlgebra (TopologicalSpace.CompactOpens α)

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

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

full_name: TopologicalSpace.CompactOpens.instBoundedOrder
code: instance instBoundedOrder : BoundedOrder (CompactOpens α) 
goal: BoundedOrder (TopologicalSpace.CompactOpens α)

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

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

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

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

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

full_name: TopologicalSpace.CompactOpens.map
code: /-- The image of a compact open under a continuous open map. -/
@[simps toCompacts]
def map (f : α → β) (hf : Continuous f) (hf' : IsOpenMap f) (s : CompactOpens α) : CompactOpens β 
goal: TopologicalSpace.CompactOpens β

full_name: TopologicalSpace.CompactOpens.map_toCompacts
code: /-- The image of a compact open under a continuous open map. -/
@[simps toCompacts]
def map (f : α → β) (hf : Continuous f) (hf' : IsOpenMap f) (s : CompactOpens α) : CompactOpens β 
goal: (TopologicalSpace.CompactOpens.map f hf hf' s).toCompacts = TopologicalSpace.Compacts.map f hf s.toCompacts

full_name: TopologicalSpace.CompactOpens.coe_map
code: @[simp, norm_cast]
theorem coe_map {f : α → β} (hf : Continuous f) (hf' : IsOpenMap f) (s : CompactOpens α) :
    (s.map f hf hf' : Set β) = f '' s 
goal: ↑(TopologicalSpace.CompactOpens.map f hf hf' s) = f '' ↑s

full_name: TopologicalSpace.CompactOpens.map_id
code: @[simp]
theorem map_id (K : CompactOpens α) : K.map id continuous_id IsOpenMap.id = K 
goal: TopologicalSpace.CompactOpens.map id ⋯ ⋯ K = K

full_name: TopologicalSpace.CompactOpens.map_comp
code: theorem map_comp (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (hf' : IsOpenMap f)
    (hg' : IsOpenMap g) (K : CompactOpens α) :
    K.map (f ∘ g) (hf.comp hg) (hf'.comp hg') = (K.map g hg hg').map f hf hf' 
goal: TopologicalSpace.CompactOpens.map (f ∘ g) ⋯ ⋯ K =
  TopologicalSpace.CompactOpens.map f hf hf' (TopologicalSpace.CompactOpens.map g hg hg' K)

full_name: TopologicalSpace.CompactOpens.prod
code: /-- The product of two `TopologicalSpace.CompactOpens`, as a `TopologicalSpace.CompactOpens` in the
product space. -/
protected def prod (K : CompactOpens α) (L : CompactOpens β) : CompactOpens (α × β) 
goal: TopologicalSpace.CompactOpens (α × β)

full_name: TopologicalSpace.CompactOpens.coe_prod
code: @[simp]
theorem coe_prod (K : CompactOpens α) (L : CompactOpens β) :
    (K.prod L : Set (α × β)) = (K : Set α) ×ˢ (L : Set β) 
goal: ↑(K.prod L) = ↑K ×ˢ ↑L