File: Mathlib/Topology/Sets/Opens.lean

full_name: TopologicalSpace.Opens
code: /-- The type of open subsets of a topological space. -/
structure Opens where
  /-- The underlying set of a bundled `TopologicalSpace.Opens` object. -/
  carrier : Set α
  /-- The `TopologicalSpace.Opens.carrier _` is an open set. -/
  is_open' : IsOpen carrier
goal: Type u_2

full_name: TopologicalSpace.Opens.carrier
code: /-- The type of open subsets of a topological space. -/
structure Opens where
  /-- The underlying set of a bundled `TopologicalSpace.Opens` object. -/
  carrier : Set α
  /-- The `TopologicalSpace.Opens.carrier _` is an open set. -/
  is_open' : IsOpen carrier
goal: Set α

full_name: TopologicalSpace.Opens.is_open'
code: /-- The type of open subsets of a topological space. -/
structure Opens where
  /-- The underlying set of a bundled `TopologicalSpace.Opens` object. -/
  carrier : Set α
  /-- The `TopologicalSpace.Opens.carrier _` is an open set. -/
  is_open' : IsOpen carrier
goal: IsOpen self.carrier

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

full_name: TopologicalSpace.Opens.instCanLiftSetCoeIsOpen
code: instance : CanLift (Set α) (Opens α) (↑) IsOpen 
goal: CanLift (Set α) (TopologicalSpace.Opens α) SetLike.coe IsOpen

full_name: TopologicalSpace.Opens.forall
code: theorem «forall» {p : Opens α → Prop} : (∀ U, p U) ↔ ∀ (U : Set α) (hU : IsOpen U), p ⟨U, hU⟩ 
goal: (∀ (U : TopologicalSpace.Opens α), p U) ↔ ∀ (U : Set α) (hU : IsOpen U), p { carrier := U, is_open' := hU }

full_name: TopologicalSpace.Opens.carrier_eq_coe
code: @[simp] theorem carrier_eq_coe (U : Opens α) : U.1 = ↑U 
goal: U.carrier = ↑U

full_name: TopologicalSpace.Opens.coe_mk
code: /-- the coercion `Opens α → Set α` applied to a pair is the same as taking the first component -/
@[simp]
theorem coe_mk {U : Set α} {hU : IsOpen U} : ↑(⟨U, hU⟩ : Opens α) = U 
goal: ↑{ carrier := U, is_open' := hU } = U

full_name: TopologicalSpace.Opens.mem_mk
code: @[simp]
theorem mem_mk {x : α} {U : Set α} {h : IsOpen U} : x ∈ mk U h ↔ x ∈ U 
goal: x ∈ { carrier := U, is_open' := h } ↔ x ∈ U

full_name: TopologicalSpace.Opens.nonempty_coeSort
code: protected theorem nonempty_coeSort {U : Opens α} : Nonempty U ↔ (U : Set α).Nonempty 
goal: Nonempty ↥U ↔ (↑U).Nonempty

full_name: TopologicalSpace.Opens.nonempty_coe
code: protected theorem nonempty_coe {U : Opens α} : (U : Set α).Nonempty ↔ ∃ x, x ∈ U 
goal: (↑U).Nonempty ↔ ∃ x, x ∈ U

full_name: TopologicalSpace.Opens.ext
code: @[ext] -- Porting note (#11215): TODO: replace with `∀ x, x ∈ U ↔ x ∈ V`
theorem ext {U V : Opens α} (h : (U : Set α) = V) : U = V 
goal: U = V

full_name: TopologicalSpace.Opens.coe_inj
code: theorem coe_inj {U V : Opens α} : (U : Set α) = V ↔ U = V 
goal: ↑U = ↑V ↔ U = V

full_name: TopologicalSpace.Opens.isOpen
code: protected theorem isOpen (U : Opens α) : IsOpen (U : Set α) 
goal: IsOpen ↑U

full_name: TopologicalSpace.Opens.mk_coe
code: @[simp] theorem mk_coe (U : Opens α) : mk (↑U) U.isOpen = U 
goal: { carrier := ↑U, is_open' := ⋯ } = U

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

full_name: TopologicalSpace.Opens.interior
code: /-- The interior of a set, as an element of `Opens`. -/
nonrec def interior (s : Set α) : Opens α 
goal: TopologicalSpace.Opens α

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

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

full_name: TopologicalSpace.Opens.instCompleteLattice
code: instance : CompleteLattice (Opens α) 
goal: CompleteLattice (TopologicalSpace.Opens α)

full_name: TopologicalSpace.Opens.mk_inf_mk
code: @[simp]
theorem mk_inf_mk {U V : Set α} {hU : IsOpen U} {hV : IsOpen V} :
    (⟨U, hU⟩ ⊓ ⟨V, hV⟩ : Opens α) = ⟨U ⊓ V, IsOpen.inter hU hV⟩ 
goal: { carrier := U, is_open' := hU } ⊓ { carrier := V, is_open' := hV } = { carrier := U ⊓ V, is_open' := ⋯ }

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

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

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

full_name: TopologicalSpace.Opens.mk_empty
code: @[simp] theorem mk_empty : (⟨∅, isOpen_empty⟩ : Opens α) = ⊥ 
goal: { carrier := ∅, is_open' := ⋯ } = ⊥

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

full_name: TopologicalSpace.Opens.mem_top
code: @[simp]
lemma mem_top (x : α) : x ∈ (⊤ : Opens α) 
goal: x ∈ ⊤

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

full_name: TopologicalSpace.Opens.mk_univ
code: @[simp] theorem mk_univ : (⟨univ, isOpen_univ⟩ : Opens α) = ⊤ 
goal: { carrier := Set.univ, is_open' := ⋯ } = ⊤

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

full_name: TopologicalSpace.Opens.coe_sSup
code: @[simp, norm_cast]
theorem coe_sSup {S : Set (Opens α)} : (↑(sSup S) : Set α) = ⋃ i ∈ S, ↑i 
goal: ↑(sSup S) = ⋃ i ∈ S, ↑i

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

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

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

full_name: TopologicalSpace.Opens.instUniqueOfIsEmpty
code: instance [IsEmpty α] : Unique (Opens α) 
goal: Unique (TopologicalSpace.Opens α)

full_name: TopologicalSpace.Opens.instNontrivialOfNonempty
code: instance [Nonempty α] : Nontrivial (Opens α) 
goal: Nontrivial (TopologicalSpace.Opens α)

full_name: TopologicalSpace.Opens.coe_iSup
code: @[simp, norm_cast]
theorem coe_iSup {ι} (s : ι → Opens α) : ((⨆ i, s i : Opens α) : Set α) = ⋃ i, s i 
goal: ↑(⨆ i, s i) = ⋃ i, ↑(s i)

full_name: TopologicalSpace.Opens.iSup_def
code: theorem iSup_def {ι} (s : ι → Opens α) : ⨆ i, s i = ⟨⋃ i, s i, isOpen_iUnion fun i => (s i).2⟩ 
goal: ⨆ i, s i = { carrier := ⋃ i, ↑(s i), is_open' := ⋯ }

full_name: TopologicalSpace.Opens.iSup_mk
code: @[simp]
theorem iSup_mk {ι} (s : ι → Set α) (h : ∀ i, IsOpen (s i)) :
    (⨆ i, ⟨s i, h i⟩ : Opens α) = ⟨⋃ i, s i, isOpen_iUnion h⟩ 
goal: ⨆ i, { carrier := s i, is_open' := ⋯ } = { carrier := ⋃ i, s i, is_open' := ⋯ }

full_name: TopologicalSpace.Opens.mem_iSup
code: @[simp]
theorem mem_iSup {ι} {x : α} {s : ι → Opens α} : x ∈ iSup s ↔ ∃ i, x ∈ s i 
goal: x ∈ iSup s ↔ ∃ i, x ∈ s i

full_name: TopologicalSpace.Opens.mem_sSup
code: @[simp]
theorem mem_sSup {Us : Set (Opens α)} {x : α} : x ∈ sSup Us ↔ ∃ u ∈ Us, x ∈ u 
goal: x ∈ sSup Us ↔ ∃ u ∈ Us, x ∈ u

full_name: TopologicalSpace.Opens.frameMinimalAxioms
code: /-- Open sets in a topological space form a frame. -/
def frameMinimalAxioms : Frame.MinimalAxioms (Opens α) 
goal: Order.Frame.MinimalAxioms (TopologicalSpace.Opens α)

full_name: TopologicalSpace.Opens.instFrame
code: instance instFrame : Frame (Opens α) 
goal: Order.Frame (TopologicalSpace.Opens α)

full_name: TopologicalSpace.Opens.openEmbedding'
code: theorem openEmbedding' (U : Opens α) : OpenEmbedding (Subtype.val : U → α) 
goal: OpenEmbedding Subtype.val

full_name: TopologicalSpace.Opens.openEmbedding_of_le
code: theorem openEmbedding_of_le {U V : Opens α} (i : U ≤ V) :
    OpenEmbedding (Set.inclusion <| SetLike.coe_subset_coe.2 i) 
goal: OpenEmbedding (Set.inclusion ⋯)

full_name: TopologicalSpace.Opens.not_nonempty_iff_eq_bot
code: theorem not_nonempty_iff_eq_bot (U : Opens α) : ¬Set.Nonempty (U : Set α) ↔ U = ⊥ 
goal: ¬(↑U).Nonempty ↔ U = ⊥

full_name: TopologicalSpace.Opens.ne_bot_iff_nonempty
code: theorem ne_bot_iff_nonempty (U : Opens α) : U ≠ ⊥ ↔ Set.Nonempty (U : Set α) 
goal: U ≠ ⊥ ↔ (↑U).Nonempty

full_name: TopologicalSpace.Opens.eq_bot_or_top
code: /-- An open set in the indiscrete topology is either empty or the whole space. -/
theorem eq_bot_or_top {α} [t : TopologicalSpace α] (h : t = ⊤) (U : Opens α) : U = ⊥ ∨ U = ⊤ 
goal: U = ⊥ ∨ U = ⊤

full_name: TopologicalSpace.Opens.instIsSimpleOrderOfNonemptyOfSubsingleton
code: instance [Nonempty α] [Subsingleton α] : IsSimpleOrder (Opens α) 
goal: IsSimpleOrder (TopologicalSpace.Opens α)

full_name: TopologicalSpace.Opens.IsBasis
code: /-- A set of `opens α` is a basis if the set of corresponding sets is a topological basis. -/
def IsBasis (B : Set (Opens α)) : Prop 
goal: Prop

full_name: TopologicalSpace.Opens.isBasis_iff_nbhd
code: theorem isBasis_iff_nbhd {B : Set (Opens α)} :
    IsBasis B ↔ ∀ {U : Opens α} {x}, x ∈ U → ∃ U' ∈ B, x ∈ U' ∧ U' ≤ U 
goal: TopologicalSpace.Opens.IsBasis B ↔ ∀ {U : TopologicalSpace.Opens α} {x : α}, x ∈ U → ∃ U' ∈ B, x ∈ U' ∧ U' ≤ U

full_name: TopologicalSpace.Opens.isBasis_iff_cover
code: theorem isBasis_iff_cover {B : Set (Opens α)} :
    IsBasis B ↔ ∀ U : Opens α, ∃ Us, Us ⊆ B ∧ U = sSup Us 
goal: TopologicalSpace.Opens.IsBasis B ↔ ∀ (U : TopologicalSpace.Opens α), ∃ Us ⊆ B, U = sSup Us

full_name: TopologicalSpace.Opens.IsBasis.isCompact_open_iff_eq_finite_iUnion
code: /-- If `α` has a basis consisting of compact opens, then an open set in `α` is compact open iff
  it is a finite union of some elements in the basis -/
theorem IsBasis.isCompact_open_iff_eq_finite_iUnion {ι : Type*} (b : ι → Opens α)
    (hb : IsBasis (Set.range b)) (hb' : ∀ i, IsCompact (b i : Set α)) (U : Set α) :
    IsCompact U ∧ IsOpen U ↔ ∃ s : Set ι, s.Finite ∧ U = ⋃ i ∈ s, b i 
goal: IsCompact U ∧ IsOpen U ↔ ∃ s, s.Finite ∧ U = ⋃ i ∈ s, ↑(b i)

full_name: TopologicalSpace.Opens.IsBasis.le_iff
code: lemma IsBasis.le_iff {α} {t₁ t₂ : TopologicalSpace α}
    {Us : Set (Opens α)} (hUs : @IsBasis α t₂ Us) :
    t₁ ≤ t₂ ↔ ∀ U ∈ Us, IsOpen[t₁] U 
goal: t₁ ≤ t₂ ↔ ∀ U ∈ Us, IsOpen ↑U

full_name: TopologicalSpace.Opens.isCompactElement_iff
code: @[simp]
theorem isCompactElement_iff (s : Opens α) :
    CompleteLattice.IsCompactElement s ↔ IsCompact (s : Set α) 
goal: CompleteLattice.IsCompactElement s ↔ IsCompact ↑s

full_name: TopologicalSpace.Opens.comap
code: /-- The preimage of an open set, as an open set. -/
def comap (f : C(α, β)) : FrameHom (Opens β) (Opens α) 
goal: FrameHom (TopologicalSpace.Opens β) (TopologicalSpace.Opens α)

full_name: TopologicalSpace.Opens.comap_id
code: @[simp]
theorem comap_id : comap (ContinuousMap.id α) = FrameHom.id _ 
goal: TopologicalSpace.Opens.comap (ContinuousMap.id α) = FrameHom.id (TopologicalSpace.Opens α)

full_name: TopologicalSpace.Opens.comap_mono
code: theorem comap_mono (f : C(α, β)) {s t : Opens β} (h : s ≤ t) : comap f s ≤ comap f t 
goal: (TopologicalSpace.Opens.comap f) s ≤ (TopologicalSpace.Opens.comap f) t

full_name: TopologicalSpace.Opens.coe_comap
code: @[simp]
theorem coe_comap (f : C(α, β)) (U : Opens β) : ↑(comap f U) = f ⁻¹' U 
goal: ↑((TopologicalSpace.Opens.comap f) U) = ⇑f ⁻¹' ↑U

full_name: TopologicalSpace.Opens.comap_comp
code: protected theorem comap_comp (g : C(β, γ)) (f : C(α, β)) :
    comap (g.comp f) = (comap f).comp (comap g) 
goal: TopologicalSpace.Opens.comap (g.comp f) = (TopologicalSpace.Opens.comap f).comp (TopologicalSpace.Opens.comap g)

full_name: TopologicalSpace.Opens.comap_comap
code: protected theorem comap_comap (g : C(β, γ)) (f : C(α, β)) (U : Opens γ) :
    comap f (comap g U) = comap (g.comp f) U 
goal: (TopologicalSpace.Opens.comap f) ((TopologicalSpace.Opens.comap g) U) = (TopologicalSpace.Opens.comap (g.comp f)) U

full_name: TopologicalSpace.Opens.comap_injective
code: theorem comap_injective [T0Space β] : Injective (comap : C(α, β) → FrameHom (Opens β) (Opens α)) 
goal: Function.Injective TopologicalSpace.Opens.comap

full_name: Homeomorph.opensCongr
code: /-- A homeomorphism induces an order-preserving equivalence on open sets, by taking comaps. -/
@[simps (config := .asFn) apply]
def _root_.Homeomorph.opensCongr (f : α ≃ₜ β) : Opens α ≃o Opens β 
goal: TopologicalSpace.Opens α ≃o TopologicalSpace.Opens β

full_name: Homeomorph.opensCongr_apply
code: /-- A homeomorphism induces an order-preserving equivalence on open sets, by taking comaps. -/
@[simps (config := .asFn) apply]
def _root_.Homeomorph.opensCongr (f : α ≃ₜ β) : Opens α ≃o Opens β 
goal: ⇑f.opensCongr = ⇑(TopologicalSpace.Opens.comap f.symm.toContinuousMap)

full_name: Homeomorph.opensCongr_symm
code: @[simp]
theorem _root_.Homeomorph.opensCongr_symm (f : α ≃ₜ β) : f.opensCongr.symm = f.symm.opensCongr 
goal: f.opensCongr.symm = f.symm.opensCongr

full_name: TopologicalSpace.Opens.instFinite
code: instance [Finite α] : Finite (Opens α) 
goal: Finite (TopologicalSpace.Opens α)

full_name: TopologicalSpace.OpenNhdsOf
code: /-- The open neighborhoods of a point. See also `Opens` or `nhds`. -/
structure OpenNhdsOf (x : α) extends Opens α where
  /-- The point `x` belongs to every `U : TopologicalSpace.OpenNhdsOf x`. -/
  mem' : x ∈ carrier
goal: Type u_2

full_name: TopologicalSpace.OpenNhdsOf.mem'
code: /-- The open neighborhoods of a point. See also `Opens` or `nhds`. -/
structure OpenNhdsOf (x : α) extends Opens α where
  /-- The point `x` belongs to every `U : TopologicalSpace.OpenNhdsOf x`. -/
  mem' : x ∈ carrier
goal: x ∈ self.carrier

full_name: TopologicalSpace.OpenNhdsOf.toOpens_injective
code: theorem toOpens_injective : Injective (toOpens : OpenNhdsOf x → Opens α)
  
goal: Function.Injective TopologicalSpace.OpenNhdsOf.toOpens

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

full_name: TopologicalSpace.OpenNhdsOf.canLiftSet
code: instance canLiftSet : CanLift (Set α) (OpenNhdsOf x) (↑) fun s => IsOpen s ∧ x ∈ s 
goal: CanLift (Set α) (TopologicalSpace.OpenNhdsOf x) SetLike.coe fun s => IsOpen s ∧ x ∈ s

full_name: TopologicalSpace.OpenNhdsOf.mem
code: protected theorem mem (U : OpenNhdsOf x) : x ∈ U 
goal: x ∈ U

full_name: TopologicalSpace.OpenNhdsOf.isOpen
code: protected theorem isOpen (U : OpenNhdsOf x) : IsOpen (U : Set α) 
goal: IsOpen ↑U

full_name: TopologicalSpace.OpenNhdsOf.instOrderTop
code: instance : OrderTop (OpenNhdsOf x) 
goal: OrderTop (TopologicalSpace.OpenNhdsOf x)

full_name: TopologicalSpace.OpenNhdsOf.instInhabited
code: instance : Inhabited (OpenNhdsOf x) 
goal: Inhabited (TopologicalSpace.OpenNhdsOf x)

full_name: TopologicalSpace.OpenNhdsOf.instInf
code: instance : Inf (OpenNhdsOf x) 
goal: Inf (TopologicalSpace.OpenNhdsOf x)

full_name: TopologicalSpace.OpenNhdsOf.instSup
code: instance : Sup (OpenNhdsOf x) 
goal: Sup (TopologicalSpace.OpenNhdsOf x)

full_name: TopologicalSpace.OpenNhdsOf.instUniqueOfSubsingleton
code: instance [Subsingleton α] : Unique (OpenNhdsOf x) 
goal: Unique (TopologicalSpace.OpenNhdsOf x)

full_name: TopologicalSpace.OpenNhdsOf.instDistribLattice
code: instance : DistribLattice (OpenNhdsOf x) 
goal: DistribLattice (TopologicalSpace.OpenNhdsOf x)

full_name: TopologicalSpace.OpenNhdsOf.basis_nhds
code: theorem basis_nhds : (𝓝 x).HasBasis (fun _ : OpenNhdsOf x => True) (↑) 
goal: (𝓝 x).HasBasis (fun x => True) SetLike.coe

full_name: TopologicalSpace.OpenNhdsOf.comap
code: /-- Preimage of an open neighborhood of `f x` under a continuous map `f` as a `LatticeHom`. -/
def comap (f : C(α, β)) (x : α) : LatticeHom (OpenNhdsOf (f x)) (OpenNhdsOf x) 
goal: LatticeHom (TopologicalSpace.OpenNhdsOf (f x)) (TopologicalSpace.OpenNhdsOf x)