File: Mathlib/Topology/AlexandrovDiscrete.lean

full_name: AlexandrovDiscrete
code: /-- A topological space is **Alexandrov-discrete** or **finitely generated** if the intersection of
a family of open sets is open. -/
class AlexandrovDiscrete (α : Type*) [TopologicalSpace α] : Prop where
  /-- The intersection of a family of open sets is an open set. Use `isOpen_sInter` in the root
  namespace instead. -/
  protected isOpen_sInter : ∀ S : Set (Set α), (∀ s ∈ S, IsOpen s) → IsOpen (⋂₀ S)
goal: Prop

full_name: AlexandrovDiscrete.isOpen_sInter
code: /-- A topological space is **Alexandrov-discrete** or **finitely generated** if the intersection of
a family of open sets is open. -/
class AlexandrovDiscrete (α : Type*) [TopologicalSpace α] : Prop where
  /-- The intersection of a family of open sets is an open set. Use `isOpen_sInter` in the root
  namespace instead. -/
  protected isOpen_sInter : ∀ S : Set (Set α), (∀ s ∈ S, IsOpen s) → IsOpen (⋂₀ S)
goal: (∀ s ∈ S, IsOpen s) → IsOpen (⋂₀ S)

full_name: DiscreteTopology.toAlexandrovDiscrete
code: instance DiscreteTopology.toAlexandrovDiscrete [DiscreteTopology α] : AlexandrovDiscrete α 
goal: AlexandrovDiscrete α

full_name: Finite.toAlexandrovDiscrete
code: instance Finite.toAlexandrovDiscrete [Finite α] : AlexandrovDiscrete α 
goal: AlexandrovDiscrete α

full_name: isOpen_sInter
code: lemma isOpen_sInter : (∀ s ∈ S, IsOpen s) → IsOpen (⋂₀ S) 
goal: (∀ s ∈ S, IsOpen s) → IsOpen (⋂₀ S)

full_name: isOpen_iInter
code: lemma isOpen_iInter (hf : ∀ i, IsOpen (f i)) : IsOpen (⋂ i, f i) 
goal: IsOpen (⋂ i, f i)

full_name: isOpen_iInter₂
code: lemma isOpen_iInter₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsOpen (f i j)) :
    IsOpen (⋂ i, ⋂ j, f i j) 
goal: IsOpen (⋂ i, ⋂ j, f i j)

full_name: isClosed_sUnion
code: lemma isClosed_sUnion (hS : ∀ s ∈ S, IsClosed s) : IsClosed (⋃₀ S) 
goal: IsClosed (⋃₀ S)

full_name: isClosed_iUnion
code: lemma isClosed_iUnion (hf : ∀ i, IsClosed (f i)) : IsClosed (⋃ i, f i) 
goal: IsClosed (⋃ i, f i)

full_name: isClosed_iUnion₂
code: lemma isClosed_iUnion₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsClosed (f i j)) :
    IsClosed (⋃ i, ⋃ j, f i j) 
goal: IsClosed (⋃ i, ⋃ j, f i j)

full_name: isClopen_sInter
code: lemma isClopen_sInter (hS : ∀ s ∈ S, IsClopen s) : IsClopen (⋂₀ S) 
goal: IsClopen (⋂₀ S)

full_name: isClopen_iInter
code: lemma isClopen_iInter (hf : ∀ i, IsClopen (f i)) : IsClopen (⋂ i, f i) 
goal: IsClopen (⋂ i, f i)

full_name: isClopen_iInter₂
code: lemma isClopen_iInter₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsClopen (f i j)) :
    IsClopen (⋂ i, ⋂ j, f i j) 
goal: IsClopen (⋂ i, ⋂ j, f i j)

full_name: isClopen_sUnion
code: lemma isClopen_sUnion (hS : ∀ s ∈ S, IsClopen s) : IsClopen (⋃₀ S) 
goal: IsClopen (⋃₀ S)

full_name: isClopen_iUnion
code: lemma isClopen_iUnion (hf : ∀ i, IsClopen (f i)) : IsClopen (⋃ i, f i) 
goal: IsClopen (⋃ i, f i)

full_name: isClopen_iUnion₂
code: lemma isClopen_iUnion₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsClopen (f i j)) :
    IsClopen (⋃ i, ⋃ j, f i j) 
goal: IsClopen (⋃ i, ⋃ j, f i j)

full_name: interior_iInter
code: lemma interior_iInter (f : ι → Set α) : interior (⋂ i, f i) = ⋂ i, interior (f i) 
goal: interior (⋂ i, f i) = ⋂ i, interior (f i)

full_name: interior_sInter
code: lemma interior_sInter (S : Set (Set α)) : interior (⋂₀ S) = ⋂ s ∈ S, interior s 
goal: interior (⋂₀ S) = ⋂ s ∈ S, interior s

full_name: closure_iUnion
code: lemma closure_iUnion (f : ι → Set α) : closure (⋃ i, f i) = ⋃ i, closure (f i) 
goal: closure (⋃ i, f i) = ⋃ i, closure (f i)

full_name: closure_sUnion
code: lemma closure_sUnion (S : Set (Set α)) : closure (⋃₀ S) = ⋃ s ∈ S, closure s 
goal: closure (⋃₀ S) = ⋃ s ∈ S, closure s

full_name: exterior
code: /-- The *exterior* of a set is the intersection of all its neighborhoods. In an Alexandrov-discrete
space, this is the smallest neighborhood of the set.

Note that this construction is unnamed in the literature. We choose the name in analogy to
`interior`. -/
def exterior (s : Set α) : Set α 
goal: Set α

full_name: exterior_singleton_eq_ker_nhds
code: lemma exterior_singleton_eq_ker_nhds (a : α) : exterior {a} = (𝓝 a).ker 
goal: exterior {a} = (𝓝 a).ker

full_name: exterior_def
code: lemma exterior_def (s : Set α) : exterior s = ⋂₀ {t : Set α | IsOpen t ∧ s ⊆ t} 
goal: exterior s = ⋂₀ {t | IsOpen t ∧ s ⊆ t}

full_name: mem_exterior
code: lemma mem_exterior : a ∈ exterior s ↔ ∀ U, IsOpen U → s ⊆ U → a ∈ U 
goal: a ∈ exterior s ↔ ∀ (U : Set α), IsOpen U → s ⊆ U → a ∈ U

full_name: subset_exterior_iff
code: lemma subset_exterior_iff : s ⊆ exterior t ↔ ∀ U, IsOpen U → t ⊆ U → s ⊆ U 
goal: s ⊆ exterior t ↔ ∀ (U : Set α), IsOpen U → t ⊆ U → s ⊆ U

full_name: subset_exterior
code: lemma subset_exterior : s ⊆ exterior s 
goal: s ⊆ exterior s

full_name: exterior_minimal
code: lemma exterior_minimal (h₁ : s ⊆ t) (h₂ : IsOpen t) : exterior s ⊆ t 
goal: exterior s ⊆ t

full_name: IsOpen.exterior_eq
code: lemma IsOpen.exterior_eq (h : IsOpen s) : exterior s = s 
goal: exterior s = s

full_name: IsOpen.exterior_subset_iff
code: lemma IsOpen.exterior_subset_iff (ht : IsOpen t) : exterior s ⊆ t ↔ s ⊆ t 
goal: exterior s ⊆ t ↔ s ⊆ t

full_name: exterior_mono
code: @[mono] lemma exterior_mono : Monotone (exterior : Set α → Set α) 
goal: Monotone exterior

full_name: exterior_empty
code: @[simp] lemma exterior_empty : exterior (∅ : Set α) = ∅ 
goal: exterior ∅ = ∅

full_name: exterior_univ
code: @[simp] lemma exterior_univ : exterior (univ : Set α) = univ 
goal: exterior Set.univ = Set.univ

full_name: exterior_eq_empty
code: @[simp] lemma exterior_eq_empty : exterior s = ∅ ↔ s = ∅ 
goal: exterior s = ∅ ↔ s = ∅

full_name: isOpen_exterior
code: @[simp] lemma isOpen_exterior : IsOpen (exterior s) 
goal: IsOpen (exterior s)

full_name: exterior_mem_nhdsSet
code: lemma exterior_mem_nhdsSet : exterior s ∈ 𝓝ˢ s 
goal: exterior s ∈ 𝓝ˢ s

full_name: exterior_eq_iff_isOpen
code: @[simp] lemma exterior_eq_iff_isOpen : exterior s = s ↔ IsOpen s 
goal: exterior s = s ↔ IsOpen s

full_name: exterior_subset_iff_isOpen
code: @[simp] lemma exterior_subset_iff_isOpen : exterior s ⊆ s ↔ IsOpen s 
goal: exterior s ⊆ s ↔ IsOpen s

full_name: exterior_subset_iff
code: lemma exterior_subset_iff : exterior s ⊆ t ↔ ∃ U, IsOpen U ∧ s ⊆ U ∧ U ⊆ t 
goal: exterior s ⊆ t ↔ ∃ U, IsOpen U ∧ s ⊆ U ∧ U ⊆ t

full_name: exterior_subset_iff_mem_nhdsSet
code: lemma exterior_subset_iff_mem_nhdsSet : exterior s ⊆ t ↔ t ∈ 𝓝ˢ s 
goal: exterior s ⊆ t ↔ t ∈ 𝓝ˢ s

full_name: exterior_singleton_subset_iff_mem_nhds
code: lemma exterior_singleton_subset_iff_mem_nhds : exterior {a} ⊆ t ↔ t ∈ 𝓝 a 
goal: exterior {a} ⊆ t ↔ t ∈ 𝓝 a

full_name: IsOpen.exterior_subset
code: lemma IsOpen.exterior_subset (ht : IsOpen t) : exterior s ⊆ t ↔ s ⊆ t 
goal: exterior s ⊆ t ↔ s ⊆ t

full_name: gc_exterior_interior
code: lemma gc_exterior_interior : GaloisConnection (exterior : Set α → Set α) interior 
goal: GaloisConnection exterior interior

full_name: exterior_exterior
code: @[simp] lemma exterior_exterior (s : Set α) : exterior (exterior s) = exterior s 
goal: exterior (exterior s) = exterior s

full_name: exterior_union
code: @[simp] lemma exterior_union (s t : Set α) : exterior (s ∪ t) = exterior s ∪ exterior t 
goal: exterior (s ∪ t) = exterior s ∪ exterior t

full_name: nhdsSet_exterior
code: @[simp] lemma nhdsSet_exterior (s : Set α) : 𝓝ˢ (exterior s) = 𝓝ˢ s 
goal: 𝓝ˢ (exterior s) = 𝓝ˢ s

full_name: principal_exterior
code: @[simp] lemma principal_exterior (s : Set α) : 𝓟 (exterior s) = 𝓝ˢ s 
goal: 𝓟 (exterior s) = 𝓝ˢ s

full_name: exterior_subset_exterior
code: @[simp] lemma exterior_subset_exterior : exterior s ⊆ exterior t ↔ 𝓝ˢ s ≤ 𝓝ˢ t 
goal: exterior s ⊆ exterior t ↔ 𝓝ˢ s ≤ 𝓝ˢ t

full_name: specializes_iff_exterior_subset
code: lemma specializes_iff_exterior_subset : x ⤳ y ↔ exterior {x} ⊆ exterior {y} 
goal: x ⤳ y ↔ exterior {x} ⊆ exterior {y}

full_name: isOpen_iff_forall_specializes
code: lemma isOpen_iff_forall_specializes : IsOpen s ↔ ∀ x y, x ⤳ y → y ∈ s → x ∈ s 
goal: IsOpen s ↔ ∀ (x y : α), x ⤳ y → y ∈ s → x ∈ s

full_name: Set.Finite.isCompact_exterior
code: lemma Set.Finite.isCompact_exterior (hs : s.Finite) : IsCompact (exterior s) 
goal: IsCompact (exterior s)

full_name: Inducing.alexandrovDiscrete
code: lemma Inducing.alexandrovDiscrete {f : β → α} (h : Inducing f) : AlexandrovDiscrete β 
goal: AlexandrovDiscrete β

full_name: alexandrovDiscrete_coinduced
code: lemma alexandrovDiscrete_coinduced {β : Type*} {f : α → β} :
    @AlexandrovDiscrete β (coinduced f ‹_›) 
goal: AlexandrovDiscrete β

full_name: AlexandrovDiscrete.sup
code: lemma AlexandrovDiscrete.sup {t₁ t₂ : TopologicalSpace α} (_ : @AlexandrovDiscrete α t₁)
    (_ : @AlexandrovDiscrete α t₂) :
    @AlexandrovDiscrete α (t₁ ⊔ t₂) 
goal: AlexandrovDiscrete α → AlexandrovDiscrete α → AlexandrovDiscrete α

full_name: alexandrovDiscrete_iSup
code: lemma alexandrovDiscrete_iSup {t : ι → TopologicalSpace α} (_ : ∀ i, @AlexandrovDiscrete α (t i)) :
    @AlexandrovDiscrete α (⨆ i, t i) 
goal: (∀ (i : ι), AlexandrovDiscrete α) → AlexandrovDiscrete α

full_name: AlexandrovDiscrete.toFirstCountable
code: instance AlexandrovDiscrete.toFirstCountable : FirstCountableTopology α 
goal: FirstCountableTopology α

full_name: AlexandrovDiscrete.toLocallyCompactSpace
code: instance AlexandrovDiscrete.toLocallyCompactSpace : LocallyCompactSpace α 
goal: LocallyCompactSpace α

full_name: Subtype.instAlexandrovDiscrete
code: instance Subtype.instAlexandrovDiscrete {p : α → Prop} : AlexandrovDiscrete {a // p a} 
goal: AlexandrovDiscrete { a // p a }

full_name: Quotient.instAlexandrovDiscrete
code: instance Quotient.instAlexandrovDiscrete {s : Setoid α} : AlexandrovDiscrete (Quotient s) 
goal: AlexandrovDiscrete (Quotient s)

full_name: Sum.instAlexandrovDiscrete
code: instance Sum.instAlexandrovDiscrete : AlexandrovDiscrete (α ⊕ β) 
goal: AlexandrovDiscrete (α ⊕ β)

full_name: Sigma.instAlexandrovDiscrete
code: instance Sigma.instAlexandrovDiscrete {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    [∀ i, AlexandrovDiscrete (π i)] : AlexandrovDiscrete (Σ i, π i) 
goal: AlexandrovDiscrete ((i : ι) × π i)