# Compact sets #

We define a few types of compact sets in a topological space.

## Main Definitions #

For a topological space `α`,

- `TopologicalSpace.Compacts α`: The type of compact sets.
- `TopologicalSpace.NonemptyCompacts α`: The type of non-empty compact sets.
- `TopologicalSpace.PositiveCompacts α`: The type of compact sets with non-empty interior.
- `TopologicalSpace.CompactOpens α`: The type of compact open sets. This is a central object in the study of spectral spaces.

### Compact sets #

source
structure TopologicalSpace.Compacts (α : Type u_4) [TopologicalSpace α] :
Type u_4

The type of compact sets of a topological space.

- carrier : Set α

  the carrier set, i.e. the points in this set

- isCompact' : IsCompact self.carrier

Instances For

source
instance TopologicalSpace.Compacts.instSetLike {α : Type u_1} [TopologicalSpace α] :
SetLike (Compacts α) α
Equations

- TopologicalSpace.Compacts.instSetLike = { coe := TopologicalSpace.Compacts.carrier, coe_injective' := ⋯ }

source
def TopologicalSpace.Compacts.Simps.coe {α : Type u_1} [TopologicalSpace α] (s : Compacts α) :
Set α

See Note [custom simps projection].

Equations

- TopologicalSpace.Compacts.Simps.coe s = ↑s

Instances For

source
theorem TopologicalSpace.Compacts.isCompact {α : Type u_1} [TopologicalSpace α] (s : Compacts α) :
IsCompact ↑s
source
instance TopologicalSpace.Compacts.instCompactSpaceSubtypeMem {α : Type u_1} [TopologicalSpace α] (K : Compacts α) :
CompactSpace ↥K
source
def TopologicalSpace.Compacts.toCloseds {α : Type u_1} [TopologicalSpace α] [T2Space α] (s : Compacts α) :
Closeds α

Reinterpret a compact as a closed set.

Equations

- s.toCloseds = { carrier := ↑s, isClosed' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.Compacts.coe_toCloseds {α : Type u_1} [TopologicalSpace α] [T2Space α] (s : Compacts α) :
↑s.toCloseds = ↑s
source
@[simp]
theorem TopologicalSpace.Compacts.mem_toCloseds {α : Type u_1} [TopologicalSpace α] [T2Space α] {x : α} {s : Compacts α} :
x ∈ s.toCloseds ↔ x ∈ s
source
instance TopologicalSpace.Compacts.instCanLiftSetCoeIsCompact {α : Type u_1} [TopologicalSpace α] :
CanLift (Set α) (Compacts α) SetLike.coe IsCompact
source
theorem TopologicalSpace.Compacts.ext {α : Type u_1} [TopologicalSpace α] {s t : Compacts α} (h : ↑s = ↑t) :
s = t
source
theorem TopologicalSpace.Compacts.ext_iff {α : Type u_1} [TopologicalSpace α] {s t : Compacts α} :
s = t ↔ ↑s = ↑t
source
@[simp]
theorem TopologicalSpace.Compacts.coe_mk {α : Type u_1} [TopologicalSpace α] (s : Set α) (h : IsCompact s) :
↑{ carrier := s, isCompact' := h } = s
source
@[simp]
theorem TopologicalSpace.Compacts.carrier_eq_coe {α : Type u_1} [TopologicalSpace α] (s : Compacts α) :
s.carrier = ↑s
source
instance TopologicalSpace.Compacts.instMax {α : Type u_1} [TopologicalSpace α] :
Max (Compacts α)
Equations

- TopologicalSpace.Compacts.instMax = { max := fun (s t : TopologicalSpace.Compacts α) => { carrier := ↑s ∪ ↑t, isCompact' := ⋯ } }

source
instance TopologicalSpace.Compacts.instMinOfT2Space {α : Type u_1} [TopologicalSpace α] [T2Space α] :
Min (Compacts α)
Equations

- TopologicalSpace.Compacts.instMinOfT2Space = { min := fun (s t : TopologicalSpace.Compacts α) => { carrier := ↑s ∩ ↑t, isCompact' := ⋯ } }

source
instance TopologicalSpace.Compacts.instTopOfCompactSpace {α : Type u_1} [TopologicalSpace α] [CompactSpace α] :
Top (Compacts α)
Equations

- TopologicalSpace.Compacts.instTopOfCompactSpace = { top := { carrier := Set.univ, isCompact' := ⋯ } }

source
instance TopologicalSpace.Compacts.instBot {α : Type u_1} [TopologicalSpace α] :
Bot (Compacts α)
Equations

- TopologicalSpace.Compacts.instBot = { bot := { carrier := ∅, isCompact' := ⋯ } }

source
instance TopologicalSpace.Compacts.instSemilatticeSup {α : Type u_1} [TopologicalSpace α] :
SemilatticeSup (Compacts α)
Equations

- TopologicalSpace.Compacts.instSemilatticeSup = Function.Injective.semilatticeSup SetLike.coe ⋯ ⋯

source
instance TopologicalSpace.Compacts.instDistribLatticeOfT2Space {α : Type u_1} [TopologicalSpace α] [T2Space α] :
DistribLattice (Compacts α)
Equations

- TopologicalSpace.Compacts.instDistribLatticeOfT2Space = Function.Injective.distribLattice SetLike.coe ⋯ ⋯ ⋯

source
instance TopologicalSpace.Compacts.instOrderBot {α : Type u_1} [TopologicalSpace α] :
OrderBot (Compacts α)
Equations

- TopologicalSpace.Compacts.instOrderBot = OrderBot.lift SetLike.coe ⋯ ⋯

source
instance TopologicalSpace.Compacts.instBoundedOrderOfCompactSpace {α : Type u_1} [TopologicalSpace α] [CompactSpace α] :
BoundedOrder (Compacts α)
Equations

- TopologicalSpace.Compacts.instBoundedOrderOfCompactSpace = BoundedOrder.lift SetLike.coe ⋯ ⋯ ⋯

source
instance TopologicalSpace.Compacts.instInhabited {α : Type u_1} [TopologicalSpace α] :
Inhabited (Compacts α)

The type of compact sets is inhabited, with default element the empty set.

Equations

- TopologicalSpace.Compacts.instInhabited = { default := ⊥ }

source
instance TopologicalSpace.Compacts.instUniqueOfIsEmpty {α : Type u_1} [TopologicalSpace α] [IsEmpty α] :
Unique (Compacts α)
Equations

- TopologicalSpace.Compacts.instUniqueOfIsEmpty = { toInhabited := TopologicalSpace.Compacts.instInhabited, uniq := ⋯ }

source
@[simp]
theorem TopologicalSpace.Compacts.coe_sup {α : Type u_1} [TopologicalSpace α] (s t : Compacts α) :
↑(s ⊔ t) = ↑s ∪ ↑t
source
@[simp]
theorem TopologicalSpace.Compacts.coe_inf {α : Type u_1} [TopologicalSpace α] [T2Space α] (s t : Compacts α) :
↑(s ⊓ t) = ↑s ∩ ↑t
source
@[simp]
theorem TopologicalSpace.Compacts.coe_top {α : Type u_1} [TopologicalSpace α] [CompactSpace α] :
↑⊤ = Set.univ
source
@[simp]
theorem TopologicalSpace.Compacts.coe_bot {α : Type u_1} [TopologicalSpace α] :
↑⊥ = ∅
source
@[simp]
theorem TopologicalSpace.Compacts.coe_finset_sup {α : Type u_1} [TopologicalSpace α] {ι : Type u_4} {s : Finset ι} {f : ι → Compacts α} :
↑(s.sup f) = s.sup fun (i : ι) => ↑(f i)
source
instance TopologicalSpace.Compacts.instSingleton {α : Type u_1} [TopologicalSpace α] :
Singleton α (Compacts α)
Equations

- TopologicalSpace.Compacts.instSingleton = { singleton := fun (x : α) => { carrier := {x}, isCompact' := ⋯ } }

source
@[simp]
theorem TopologicalSpace.Compacts.coe_singleton {α : Type u_1} [TopologicalSpace α] (x : α) :
↑{x} = {x}
source
@[simp]
theorem TopologicalSpace.Compacts.mem_singleton {α : Type u_1} [TopologicalSpace α] (x y : α) :
x ∈ {y} ↔ x = y
source
@[simp]
theorem TopologicalSpace.Compacts.toCloseds_singleton {α : Type u_1} [TopologicalSpace α] [T2Space α] (x : α) :
{x}.toCloseds = Closeds.singleton x
source
theorem TopologicalSpace.Compacts.singleton_injective {α : Type u_1} [TopologicalSpace α] :
Function.Injective fun (x : α) => {x}
source
@[simp]
theorem TopologicalSpace.Compacts.singleton_inj {α : Type u_1} [TopologicalSpace α] {x y : α} :
{x} = {y} ↔ x = y
source
instance TopologicalSpace.Compacts.instNontrivialOfNonempty {α : Type u_1} [TopologicalSpace α] [Nonempty α] :
Nontrivial (Compacts α)
source
@[simp]
theorem TopologicalSpace.Compacts.subsingleton_iff {α : Type u_1} [TopologicalSpace α] :
Subsingleton (Compacts α) ↔ IsEmpty α
source
@[simp]
theorem TopologicalSpace.Compacts.nontrivial_iff {α : Type u_1} [TopologicalSpace α] :
Nontrivial (Compacts α) ↔ Nonempty α
source
def TopologicalSpace.Compacts.map {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α → β) (hf : Continuous f) (K : Compacts α) :
Compacts β

The image of a compact set under a continuous function.

Equations

- TopologicalSpace.Compacts.map f hf K = { carrier := f '' K.carrier, isCompact' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.Compacts.coe_map {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} (hf : Continuous f) (s : Compacts α) :
↑(Compacts.map f hf s) = f '' ↑s
source
@[simp]
theorem TopologicalSpace.Compacts.map_id {α : Type u_1} [TopologicalSpace α] (K : Compacts α) :
Compacts.map id ⋯ K = K
source
theorem TopologicalSpace.Compacts.map_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (K : Compacts α) :
Compacts.map (f ∘ g) ⋯ K = Compacts.map f hf (Compacts.map g hg K)
source
theorem TopologicalSpace.Compacts.map_injective {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} (hf : Continuous f) (hf' : Function.Injective f) :
Function.Injective (Compacts.map f hf)
source
@[simp]
theorem TopologicalSpace.Compacts.map_singleton {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} (hf : Continuous f) (x : α) :
Compacts.map f hf {x} = {f x}
source
@[simp]
theorem TopologicalSpace.Compacts.map_injective_iff {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} (hf : Continuous f) :
Function.Injective (Compacts.map f hf) ↔ Function.Injective f
source
def TopologicalSpace.Compacts.equiv {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α ≃ₜ β) :
Compacts α ≃ Compacts β

A homeomorphism induces an equivalence on compact sets, by taking the image.

Equations

- TopologicalSpace.Compacts.equiv f = { toFun := TopologicalSpace.Compacts.map ⇑f ⋯, invFun := TopologicalSpace.Compacts.map ⇑f.symm ⋯, left_inv := ⋯, right_inv := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.Compacts.equiv_apply {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α ≃ₜ β) (K : Compacts α) :
(Compacts.equiv f) K = Compacts.map ⇑f ⋯ K
source
@[simp]
theorem TopologicalSpace.Compacts.equiv_symm_apply {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α ≃ₜ β) (K : Compacts β) :
(Compacts.equiv f).symm K = Compacts.map ⇑f.symm ⋯ K
source
@[simp]
theorem TopologicalSpace.Compacts.equiv_refl {α : Type u_1} [TopologicalSpace α] :
Compacts.equiv (Homeomorph.refl α) = Equiv.refl (Compacts α)
source
@[simp]
theorem TopologicalSpace.Compacts.equiv_trans {α : Type u_1} {β : Type u_2} {γ : Type u_3} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] (f : α ≃ₜ β) (g : β ≃ₜ γ) :
Compacts.equiv (f.trans g) = (Compacts.equiv f).trans (Compacts.equiv g)
source
@[simp]
theorem TopologicalSpace.Compacts.equiv_symm {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α ≃ₜ β) :
Compacts.equiv f.symm = (Compacts.equiv f).symm
source
theorem TopologicalSpace.Compacts.coe_equiv_apply_eq_preimage {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α ≃ₜ β) (K : Compacts α) :
↑((Compacts.equiv f) K) = ⇑f.symm ⁻¹' ↑K

The image of a compact set under a homeomorphism can also be expressed as a preimage.

source
def TopologicalSpace.Compacts.prod {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (K : Compacts α) (L : Compacts β) :
Compacts (α × β)

The product of two `TopologicalSpace.Compacts`, as a `TopologicalSpace.Compacts` in the product space.

Equations

- K.prod L = { carrier := ↑K ×ˢ ↑L, isCompact' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.Compacts.coe_prod {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (K : Compacts α) (L : Compacts β) :
↑(K.prod L) = ↑K ×ˢ ↑L
source
@[simp]
theorem TopologicalSpace.Compacts.singleton_prod_singleton {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (x : α) (y : β) :
{x}.prod {y} = {(x, y)}

### Nonempty compact sets #

source
structure TopologicalSpace.NonemptyCompacts (α : Type u_4) [TopologicalSpace α] extends TopologicalSpace.Compacts α :
Type u_4

The type of nonempty compact sets of a topological space.

- carrier : Set α
- isCompact' : IsCompact self.carrier
- nonempty' : self.carrier.Nonempty

Instances For

source
instance TopologicalSpace.NonemptyCompacts.instSetLike {α : Type u_1} [TopologicalSpace α] :
SetLike (NonemptyCompacts α) α
Equations

- TopologicalSpace.NonemptyCompacts.instSetLike = { coe := fun (s : TopologicalSpace.NonemptyCompacts α) => s.carrier, coe_injective' := ⋯ }

source
def TopologicalSpace.NonemptyCompacts.Simps.coe {α : Type u_1} [TopologicalSpace α] (s : NonemptyCompacts α) :
Set α

See Note [custom simps projection].

Equations

- TopologicalSpace.NonemptyCompacts.Simps.coe s = ↑s

Instances For

source
theorem TopologicalSpace.NonemptyCompacts.isCompact {α : Type u_1} [TopologicalSpace α] (s : NonemptyCompacts α) :
IsCompact ↑s
source
theorem TopologicalSpace.NonemptyCompacts.nonempty {α : Type u_1} [TopologicalSpace α] (s : NonemptyCompacts α) :
(↑s).Nonempty
source
def TopologicalSpace.NonemptyCompacts.toCloseds {α : Type u_1} [TopologicalSpace α] [T2Space α] (s : NonemptyCompacts α) :
Closeds α

Reinterpret a nonempty compact as a closed set.

Equations

- s.toCloseds = { carrier := ↑s, isClosed' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.coe_toCloseds {α : Type u_1} [TopologicalSpace α] [T2Space α] (s : NonemptyCompacts α) :
↑s.toCloseds = ↑s
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.toCloseds_toCompacts {α : Type u_1} [TopologicalSpace α] [T2Space α] (s : NonemptyCompacts α) :
s.toCloseds = s.toCloseds
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.mem_toCloseds {α : Type u_1} [TopologicalSpace α] [T2Space α] {x : α} {s : NonemptyCompacts α} :
x ∈ s.toCloseds ↔ x ∈ s
source
theorem TopologicalSpace.NonemptyCompacts.ext {α : Type u_1} [TopologicalSpace α] {s t : NonemptyCompacts α} (h : ↑s = ↑t) :
s = t
source
theorem TopologicalSpace.NonemptyCompacts.ext_iff {α : Type u_1} [TopologicalSpace α] {s t : NonemptyCompacts α} :
s = t ↔ ↑s = ↑t
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.coe_mk {α : Type u_1} [TopologicalSpace α] (s : Compacts α) (h : s.carrier.Nonempty) :
↑{ toCompacts := s, nonempty' := h } = ↑s
source
theorem TopologicalSpace.NonemptyCompacts.carrier_eq_coe {α : Type u_1} [TopologicalSpace α] (s : NonemptyCompacts α) :
s.carrier = ↑s
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.coe_toCompacts {α : Type u_1} [TopologicalSpace α] (s : NonemptyCompacts α) :
↑s.toCompacts = ↑s
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.mem_toCompacts {α : Type u_1} [TopologicalSpace α] {x : α} {s : NonemptyCompacts α} :
x ∈ s.toCompacts ↔ x ∈ s
source
instance TopologicalSpace.NonemptyCompacts.instMax {α : Type u_1} [TopologicalSpace α] :
Max (NonemptyCompacts α)
Equations

- TopologicalSpace.NonemptyCompacts.instMax = { max := fun (s t : TopologicalSpace.NonemptyCompacts α) => { toCompacts := s.toCompacts ⊔ t.toCompacts, nonempty' := ⋯ } }

source
instance TopologicalSpace.NonemptyCompacts.instTopOfCompactSpaceOfNonempty {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [Nonempty α] :
Top (NonemptyCompacts α)
Equations

- TopologicalSpace.NonemptyCompacts.instTopOfCompactSpaceOfNonempty = { top := { toCompacts := ⊤, nonempty' := ⋯ } }

source
instance TopologicalSpace.NonemptyCompacts.instSemilatticeSup {α : Type u_1} [TopologicalSpace α] :
SemilatticeSup (NonemptyCompacts α)
Equations

- TopologicalSpace.NonemptyCompacts.instSemilatticeSup = Function.Injective.semilatticeSup SetLike.coe ⋯ ⋯

source
instance TopologicalSpace.NonemptyCompacts.instOrderTopOfCompactSpaceOfNonempty {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [Nonempty α] :
OrderTop (NonemptyCompacts α)
Equations

- TopologicalSpace.NonemptyCompacts.instOrderTopOfCompactSpaceOfNonempty = OrderTop.lift SetLike.coe ⋯ ⋯

source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.coe_sup {α : Type u_1} [TopologicalSpace α] (s t : NonemptyCompacts α) :
↑(s ⊔ t) = ↑s ∪ ↑t
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.coe_top {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [Nonempty α] :
↑⊤ = Set.univ
source
instance TopologicalSpace.NonemptyCompacts.instSingleton {α : Type u_1} [TopologicalSpace α] :
Singleton α (NonemptyCompacts α)
Equations

- TopologicalSpace.NonemptyCompacts.instSingleton = { singleton := fun (x : α) => { toCompacts := {x}, nonempty' := ⋯ } }

source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.coe_singleton {α : Type u_1} [TopologicalSpace α] (x : α) :
↑{x} = {x}
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.mem_singleton {α : Type u_1} [TopologicalSpace α] (x y : α) :
x ∈ {y} ↔ x = y
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.toCompacts_singleton {α : Type u_1} [TopologicalSpace α] (x : α) :
{x}.toCompacts = {x}
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.toCloseds_singleton {α : Type u_1} [TopologicalSpace α] [T2Space α] (x : α) :
{x}.toCloseds = Closeds.singleton x
source
theorem TopologicalSpace.NonemptyCompacts.singleton_injective {α : Type u_1} [TopologicalSpace α] :
Function.Injective fun (x : α) => {x}
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.singleton_inj {α : Type u_1} [TopologicalSpace α] {x y : α} :
{x} = {y} ↔ x = y
source
instance TopologicalSpace.NonemptyCompacts.instInhabited {α : Type u_1} [TopologicalSpace α] [Inhabited α] :
Inhabited (NonemptyCompacts α)

In an inhabited space, the type of nonempty compact subsets is also inhabited, with default element the singleton set containing the default element.

Equations

- TopologicalSpace.NonemptyCompacts.instInhabited = { default := {default} }

source
instance TopologicalSpace.NonemptyCompacts.instIsEmpty {α : Type u_1} [TopologicalSpace α] [IsEmpty α] :
IsEmpty (NonemptyCompacts α)
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.isEmpty_iff {α : Type u_1} [TopologicalSpace α] :
IsEmpty (NonemptyCompacts α) ↔ IsEmpty α
source
instance TopologicalSpace.NonemptyCompacts.instNonempty {α : Type u_1} [TopologicalSpace α] [Nonempty α] :
Nonempty (NonemptyCompacts α)
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.nonempty_iff {α : Type u_1} [TopologicalSpace α] :
Nonempty (NonemptyCompacts α) ↔ Nonempty α
source
instance TopologicalSpace.NonemptyCompacts.instSubsingleton {α : Type u_1} [TopologicalSpace α] [Subsingleton α] :
Subsingleton (NonemptyCompacts α)
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.subsingleton_iff {α : Type u_1} [TopologicalSpace α] :
Subsingleton (NonemptyCompacts α) ↔ Subsingleton α
source
instance TopologicalSpace.NonemptyCompacts.instUnique {α : Type u_1} [TopologicalSpace α] [Unique α] :
Unique (NonemptyCompacts α)
Equations

- TopologicalSpace.NonemptyCompacts.instUnique = Unique.mk' (TopologicalSpace.NonemptyCompacts α)

source
instance TopologicalSpace.NonemptyCompacts.instNontrivial {α : Type u_1} [TopologicalSpace α] [Nontrivial α] :
Nontrivial (NonemptyCompacts α)
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.nontrivial_iff {α : Type u_1} [TopologicalSpace α] :
Nontrivial (NonemptyCompacts α) ↔ Nontrivial α
source
instance TopologicalSpace.NonemptyCompacts.toCompactSpace {α : Type u_1} [TopologicalSpace α] {s : NonemptyCompacts α} :
CompactSpace ↥s
source
instance TopologicalSpace.NonemptyCompacts.toNonempty {α : Type u_1} [TopologicalSpace α] {s : NonemptyCompacts α} :
Nonempty ↥s
source
def TopologicalSpace.NonemptyCompacts.prod {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (K : NonemptyCompacts α) (L : NonemptyCompacts β) :
NonemptyCompacts (α × β)

The product of two `TopologicalSpace.NonemptyCompacts`, as a `TopologicalSpace.NonemptyCompacts` in the product space.

Equations

- K.prod L = { toCompacts := K.prod L.toCompacts, nonempty' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.coe_prod {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (K : NonemptyCompacts α) (L : NonemptyCompacts β) :
↑(K.prod L) = ↑K ×ˢ ↑L
source
@[simp]
theorem TopologicalSpace.NonemptyCompacts.singleton_prod_singleton {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (x : α) (y : β) :
{x}.prod {y} = {(x, y)}

### Positive compact sets #

source
structure TopologicalSpace.PositiveCompacts (α : Type u_4) [TopologicalSpace α] extends TopologicalSpace.Compacts α :
Type u_4

The type of compact sets with nonempty interior of a topological space. See also `TopologicalSpace.Compacts` and `TopologicalSpace.NonemptyCompacts`.

- carrier : Set α
- isCompact' : IsCompact self.carrier
- interior_nonempty' : (interior self.carrier).Nonempty

Instances For

source
instance TopologicalSpace.PositiveCompacts.instSetLike {α : Type u_1} [TopologicalSpace α] :
SetLike (PositiveCompacts α) α
Equations

- TopologicalSpace.PositiveCompacts.instSetLike = { coe := fun (s : TopologicalSpace.PositiveCompacts α) => s.carrier, coe_injective' := ⋯ }

source
def TopologicalSpace.PositiveCompacts.Simps.coe {α : Type u_1} [TopologicalSpace α] (s : PositiveCompacts α) :
Set α

See Note [custom simps projection].

Equations

- TopologicalSpace.PositiveCompacts.Simps.coe s = ↑s

Instances For

source
theorem TopologicalSpace.PositiveCompacts.isCompact {α : Type u_1} [TopologicalSpace α] (s : PositiveCompacts α) :
IsCompact ↑s
source
theorem TopologicalSpace.PositiveCompacts.interior_nonempty {α : Type u_1} [TopologicalSpace α] (s : PositiveCompacts α) :
(interior ↑s).Nonempty
source
theorem TopologicalSpace.PositiveCompacts.nonempty {α : Type u_1} [TopologicalSpace α] (s : PositiveCompacts α) :
(↑s).Nonempty
source
def TopologicalSpace.PositiveCompacts.toNonemptyCompacts {α : Type u_1} [TopologicalSpace α] (s : PositiveCompacts α) :
NonemptyCompacts α

Reinterpret a positive compact as a nonempty compact.

Equations

- s.toNonemptyCompacts = { toCompacts := s.toCompacts, nonempty' := ⋯ }

Instances For

source
theorem TopologicalSpace.PositiveCompacts.ext {α : Type u_1} [TopologicalSpace α] {s t : PositiveCompacts α} (h : ↑s = ↑t) :
s = t
source
theorem TopologicalSpace.PositiveCompacts.ext_iff {α : Type u_1} [TopologicalSpace α] {s t : PositiveCompacts α} :
s = t ↔ ↑s = ↑t
source
@[simp]
theorem TopologicalSpace.PositiveCompacts.coe_mk {α : Type u_1} [TopologicalSpace α] (s : Compacts α) (h : (interior s.carrier).Nonempty) :
↑{ toCompacts := s, interior_nonempty' := h } = ↑s
source
theorem TopologicalSpace.PositiveCompacts.carrier_eq_coe {α : Type u_1} [TopologicalSpace α] (s : PositiveCompacts α) :
s.carrier = ↑s
source
@[simp]
theorem TopologicalSpace.PositiveCompacts.coe_toCompacts {α : Type u_1} [TopologicalSpace α] (s : PositiveCompacts α) :
↑s.toCompacts = ↑s
source
instance TopologicalSpace.PositiveCompacts.instMax {α : Type u_1} [TopologicalSpace α] :
Max (PositiveCompacts α)
Equations

- TopologicalSpace.PositiveCompacts.instMax = { max := fun (s t : TopologicalSpace.PositiveCompacts α) => { toCompacts := s.toCompacts ⊔ t.toCompacts, interior_nonempty' := ⋯ } }

source
instance TopologicalSpace.PositiveCompacts.instTopOfCompactSpaceOfNonempty {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [Nonempty α] :
Top (PositiveCompacts α)
Equations

- TopologicalSpace.PositiveCompacts.instTopOfCompactSpaceOfNonempty = { top := { toCompacts := ⊤, interior_nonempty' := ⋯ } }

source
instance TopologicalSpace.PositiveCompacts.instSemilatticeSup {α : Type u_1} [TopologicalSpace α] :
SemilatticeSup (PositiveCompacts α)
Equations

- TopologicalSpace.PositiveCompacts.instSemilatticeSup = Function.Injective.semilatticeSup SetLike.coe ⋯ ⋯

source
instance TopologicalSpace.PositiveCompacts.instOrderTopOfCompactSpaceOfNonempty {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [Nonempty α] :
OrderTop (PositiveCompacts α)
Equations

- TopologicalSpace.PositiveCompacts.instOrderTopOfCompactSpaceOfNonempty = OrderTop.lift SetLike.coe ⋯ ⋯

source
@[simp]
theorem TopologicalSpace.PositiveCompacts.coe_sup {α : Type u_1} [TopologicalSpace α] (s t : PositiveCompacts α) :
↑(s ⊔ t) = ↑s ∪ ↑t
source
@[simp]
theorem TopologicalSpace.PositiveCompacts.coe_top {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [Nonempty α] :
↑⊤ = Set.univ
source
def TopologicalSpace.PositiveCompacts.map {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α → β) (hf : Continuous f) (hf' : IsOpenMap f) (K : PositiveCompacts α) :
PositiveCompacts β

The image of a positive compact set under a continuous open map.

Equations

- TopologicalSpace.PositiveCompacts.map f hf hf' K = { toCompacts := TopologicalSpace.Compacts.map f hf K.toCompacts, interior_nonempty' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.PositiveCompacts.coe_map {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} (hf : Continuous f) (hf' : IsOpenMap f) (s : PositiveCompacts α) :
↑(PositiveCompacts.map f hf hf' s) = f '' ↑s
source
@[simp]
theorem TopologicalSpace.PositiveCompacts.map_id {α : Type u_1} [TopologicalSpace α] (K : PositiveCompacts α) :
PositiveCompacts.map id ⋯ ⋯ K = K
source
theorem TopologicalSpace.PositiveCompacts.map_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (hf' : IsOpenMap f) (hg' : IsOpenMap g) (K : PositiveCompacts α) :
PositiveCompacts.map (f ∘ g) ⋯ ⋯ K = PositiveCompacts.map f hf hf' (PositiveCompacts.map g hg hg' K)
source
theorem exists_positiveCompacts_subset {α : Type u_1} [TopologicalSpace α] [LocallyCompactSpace α] {U : Set α} (ho : IsOpen U) (hn : U.Nonempty) :
∃ (K : TopologicalSpace.PositiveCompacts α), ↑K ⊆ U
source
theorem IsOpen.exists_positiveCompacts_closure_subset {α : Type u_1} [TopologicalSpace α] [R1Space α] [LocallyCompactSpace α] {U : Set α} (ho : IsOpen U) (hn : U.Nonempty) :
∃ (K : TopologicalSpace.PositiveCompacts α), closure ↑K ⊆ U
source
instance TopologicalSpace.PositiveCompacts.instInhabitedOfCompactSpaceOfNonempty {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [Nonempty α] :
Inhabited (PositiveCompacts α)
Equations

- TopologicalSpace.PositiveCompacts.instInhabitedOfCompactSpaceOfNonempty = { default := ⊤ }

source
instance TopologicalSpace.PositiveCompacts.nonempty' {α : Type u_1} [TopologicalSpace α] [WeaklyLocallyCompactSpace α] [Nonempty α] :
Nonempty (PositiveCompacts α)

In a nonempty locally compact space, there exists a compact set with nonempty interior.

source
def TopologicalSpace.PositiveCompacts.prod {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (K : PositiveCompacts α) (L : PositiveCompacts β) :
PositiveCompacts (α × β)

The product of two `TopologicalSpace.PositiveCompacts`, as a `TopologicalSpace.PositiveCompacts` in the product space.

Equations

- K.prod L = { toCompacts := K.prod L.toCompacts, interior_nonempty' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.PositiveCompacts.coe_prod {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (K : PositiveCompacts α) (L : PositiveCompacts β) :
↑(K.prod L) = ↑K ×ˢ ↑L

### Compact open sets #

source
structure TopologicalSpace.CompactOpens (α : Type u_4) [TopologicalSpace α] extends TopologicalSpace.Compacts α :
Type u_4

The type of compact open sets of a topological space. This is useful in non-Hausdorff contexts, in particular spectral spaces.

- carrier : Set α
- isCompact' : IsCompact self.carrier
- isOpen' : IsOpen self.carrier

Instances For

source
instance TopologicalSpace.CompactOpens.instSetLike {α : Type u_1} [TopologicalSpace α] :
SetLike (CompactOpens α) α
Equations

- TopologicalSpace.CompactOpens.instSetLike = { coe := fun (s : TopologicalSpace.CompactOpens α) => s.carrier, coe_injective' := ⋯ }

source
def TopologicalSpace.CompactOpens.Simps.coe {α : Type u_1} [TopologicalSpace α] (s : CompactOpens α) :
Set α

See Note [custom simps projection].

Equations

- TopologicalSpace.CompactOpens.Simps.coe s = ↑s

Instances For

source
theorem TopologicalSpace.CompactOpens.isCompact {α : Type u_1} [TopologicalSpace α] (s : CompactOpens α) :
IsCompact ↑s
source
theorem TopologicalSpace.CompactOpens.isOpen {α : Type u_1} [TopologicalSpace α] (s : CompactOpens α) :
IsOpen ↑s
source
def TopologicalSpace.CompactOpens.toOpens {α : Type u_1} [TopologicalSpace α] (s : CompactOpens α) :
Opens α

Reinterpret a compact open as an open.

Equations

- s.toOpens = { carrier := ↑s, is_open' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_toOpens {α : Type u_1} [TopologicalSpace α] (s : CompactOpens α) :
↑s.toOpens = ↑s
source
def TopologicalSpace.CompactOpens.toClopens {α : Type u_1} [TopologicalSpace α] [T2Space α] (s : CompactOpens α) :
Clopens α

Reinterpret a compact open as a clopen.

Equations

- s.toClopens = { carrier := ↑s, isClopen' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_toClopens {α : Type u_1} [TopologicalSpace α] [T2Space α] (s : CompactOpens α) :
↑s.toClopens = ↑s
source
theorem TopologicalSpace.CompactOpens.ext {α : Type u_1} [TopologicalSpace α] {s t : CompactOpens α} (h : ↑s = ↑t) :
s = t
source
theorem TopologicalSpace.CompactOpens.ext_iff {α : Type u_1} [TopologicalSpace α] {s t : CompactOpens α} :
s = t ↔ ↑s = ↑t
source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_mk {α : Type u_1} [TopologicalSpace α] (s : Compacts α) (h : IsOpen s.carrier) :
↑{ toCompacts := s, isOpen' := h } = ↑s
source
instance TopologicalSpace.CompactOpens.instMax {α : Type u_1} [TopologicalSpace α] :
Max (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instMax = { max := fun (s t : TopologicalSpace.CompactOpens α) => { toCompacts := s.toCompacts ⊔ t.toCompacts, isOpen' := ⋯ } }

source
instance TopologicalSpace.CompactOpens.instBot {α : Type u_1} [TopologicalSpace α] :
Bot (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instBot = { bot := { toCompacts := ⊥, isOpen' := ⋯ } }

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_sup {α : Type u_1} [TopologicalSpace α] (s t : CompactOpens α) :
↑(s ⊔ t) = ↑s ∪ ↑t
source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_bot {α : Type u_1} [TopologicalSpace α] :
↑⊥ = ∅
source
instance TopologicalSpace.CompactOpens.instSemilatticeSup {α : Type u_1} [TopologicalSpace α] :
SemilatticeSup (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instSemilatticeSup = Function.Injective.semilatticeSup SetLike.coe ⋯ ⋯

source
instance TopologicalSpace.CompactOpens.instOrderBot {α : Type u_1} [TopologicalSpace α] :
OrderBot (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instOrderBot = OrderBot.lift SetLike.coe ⋯ ⋯

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_finsetSup {α : Type u_1} [TopologicalSpace α] {ι : Type u_4} {f : ι → CompactOpens α} {s : Finset ι} :
↑(s.sup f) = ⋃ i ∈ s, ↑(f i)
source
instance TopologicalSpace.CompactOpens.instInhabited {α : Type u_1} [TopologicalSpace α] :
Inhabited (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instInhabited = { default := ⊥ }

source
instance TopologicalSpace.CompactOpens.instInf {α : Type u_1} [TopologicalSpace α] [QuasiSeparatedSpace α] :
Min (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instInf = { min := fun (U V : TopologicalSpace.CompactOpens α) => { carrier := ↑U ∩ ↑V, isCompact' := ⋯, isOpen' := ⋯ } }

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_inf {α : Type u_1} [TopologicalSpace α] [QuasiSeparatedSpace α] (s t : CompactOpens α) :
↑(s ⊓ t) = ↑s ∩ ↑t
source
instance TopologicalSpace.CompactOpens.instSemilatticeInf {α : Type u_1} [TopologicalSpace α] [QuasiSeparatedSpace α] :
SemilatticeInf (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instSemilatticeInf = Function.Injective.semilatticeInf SetLike.coe ⋯ ⋯

source
instance TopologicalSpace.CompactOpens.instSDiff {α : Type u_1} [TopologicalSpace α] [T2Space α] :
SDiff (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instSDiff = { sdiff := fun (s t : TopologicalSpace.CompactOpens α) => { carrier := ↑s \ ↑t, isCompact' := ⋯, isOpen' := ⋯ } }

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_sdiff {α : Type u_1} [TopologicalSpace α] [T2Space α] (s t : CompactOpens α) :
↑(s \ t) = ↑s \ ↑t
source
instance TopologicalSpace.CompactOpens.instGeneralizedBooleanAlgebra {α : Type u_1} [TopologicalSpace α] [T2Space α] :
GeneralizedBooleanAlgebra (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instGeneralizedBooleanAlgebra = Function.Injective.generalizedBooleanAlgebra SetLike.coe ⋯ ⋯ ⋯ ⋯ ⋯

source
instance TopologicalSpace.CompactOpens.instTop {α : Type u_1} [TopologicalSpace α] [CompactSpace α] :
Top (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instTop = { top := { toCompacts := ⊤, isOpen' := ⋯ } }

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_top {α : Type u_1} [TopologicalSpace α] [CompactSpace α] :
↑⊤ = Set.univ
source
instance TopologicalSpace.CompactOpens.instBoundedOrder {α : Type u_1} [TopologicalSpace α] [CompactSpace α] :
BoundedOrder (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instBoundedOrder = BoundedOrder.lift SetLike.coe ⋯ ⋯ ⋯

source
instance TopologicalSpace.CompactOpens.instHasCompl {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [T2Space α] :
HasCompl (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instHasCompl = { compl := fun (s : TopologicalSpace.CompactOpens α) => { carrier := (↑s)ᶜ, isCompact' := ⋯, isOpen' := ⋯ } }

source
instance TopologicalSpace.CompactOpens.instHImp {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [T2Space α] :
HImp (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instHImp = { himp := fun (s t : TopologicalSpace.CompactOpens α) => { carrier := ↑s ⇨ ↑t, isCompact' := ⋯, isOpen' := ⋯ } }

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_compl {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [T2Space α] (s : CompactOpens α) :
↑s ᶜ = (↑s)ᶜ
source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_himp {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [T2Space α] (s t : CompactOpens α) :
↑(s ⇨ t) = ↑s ⇨ ↑t
source
instance TopologicalSpace.CompactOpens.instBooleanAlgebra {α : Type u_1} [TopologicalSpace α] [CompactSpace α] [T2Space α] :
BooleanAlgebra (CompactOpens α)
Equations

- TopologicalSpace.CompactOpens.instBooleanAlgebra = Function.Injective.booleanAlgebra SetLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

source
def TopologicalSpace.CompactOpens.map {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α → β) (hf : Continuous f) (hf' : IsOpenMap f) (s : CompactOpens α) :
CompactOpens β

The image of a compact open under a continuous open map.

Equations

- TopologicalSpace.CompactOpens.map f hf hf' s = { toCompacts := TopologicalSpace.Compacts.map f hf s.toCompacts, isOpen' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.CompactOpens.map_toCompacts {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (f : α → β) (hf : Continuous f) (hf' : IsOpenMap f) (s : CompactOpens α) :
(map f hf hf' s).toCompacts = Compacts.map f hf s.toCompacts
source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_map {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} (hf : Continuous f) (hf' : IsOpenMap f) (s : CompactOpens α) :
↑(map f hf hf' s) = f '' ↑s
source
@[simp]
theorem TopologicalSpace.CompactOpens.map_id {α : Type u_1} [TopologicalSpace α] (K : CompactOpens α) :
map id ⋯ ⋯ K = K
source
theorem TopologicalSpace.CompactOpens.map_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (hf' : IsOpenMap f) (hg' : IsOpenMap g) (K : CompactOpens α) :
map (f ∘ g) ⋯ ⋯ K = map f hf hf' (map g hg hg' K)
source
def TopologicalSpace.CompactOpens.prod {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (K : CompactOpens α) (L : CompactOpens β) :
CompactOpens (α × β)

The product of two `TopologicalSpace.CompactOpens`, as a `TopologicalSpace.CompactOpens` in the product space.

Equations

- K.prod L = { toCompacts := K.prod L.toCompacts, isOpen' := ⋯ }

Instances For

source
@[simp]
theorem TopologicalSpace.CompactOpens.coe_prod {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] (K : CompactOpens α) (L : CompactOpens β) :
↑(K.prod L) = ↑K ×ˢ ↑L