File: Mathlib/Topology/Compactness/Lindelof.lean

full_name: IsLindelof
code: /-- A set `s` is Lindelöf if every nontrivial filter `f` with the countable intersection
  property that contains `s`, has a clusterpoint in `s`. The filter-free definition is given by
  `isLindelof_iff_countable_subcover`. -/
def IsLindelof (s : Set X) 
goal: Prop

full_name: IsLindelof.compl_mem_sets
code: /-- The complement to a Lindelöf set belongs to a filter `f` with the countable intersection
  property if it belongs to each filter `𝓝 x ⊓ f`, `x ∈ s`. -/
theorem IsLindelof.compl_mem_sets (hs : IsLindelof s) {f : Filter X} [CountableInterFilter f]
    (hf : ∀ x ∈ s, sᶜ ∈ 𝓝 x ⊓ f) : sᶜ ∈ f 
goal: sᶜ ∈ f

full_name: IsLindelof.compl_mem_sets_of_nhdsWithin
code: /-- The complement to a Lindelöf set belongs to a filter `f` with the countable intersection
  property if each `x ∈ s` has a neighborhood `t` within `s` such that `tᶜ` belongs to `f`. -/
theorem IsLindelof.compl_mem_sets_of_nhdsWithin (hs : IsLindelof s) {f : Filter X}
    [CountableInterFilter f] (hf : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, tᶜ ∈ f) : sᶜ ∈ f 
goal: sᶜ ∈ f

full_name: IsLindelof.induction_on
code: /-- If `p : Set X → Prop` is stable under restriction and union, and each point `x`
  of a Lindelöf set `s` has a neighborhood `t` within `s` such that `p t`, then `p s` holds. -/
@[elab_as_elim]
theorem IsLindelof.induction_on (hs : IsLindelof s) {p : Set X → Prop}
    (hmono : ∀ ⦃s t⦄, s ⊆ t → p t → p s)
    (hcountable_union : ∀ (S : Set (Set X)), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S))
    (hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t) : p s 
goal: p s

full_name: IsLindelof.inter_right
code: /-- The intersection of a Lindelöf set and a closed set is a Lindelöf set. -/
theorem IsLindelof.inter_right (hs : IsLindelof s) (ht : IsClosed t) : IsLindelof (s ∩ t) 
goal: IsLindelof (s ∩ t)

full_name: IsLindelof.inter_left
code: /-- The intersection of a closed set and a Lindelöf set is a Lindelöf set. -/
theorem IsLindelof.inter_left (ht : IsLindelof t) (hs : IsClosed s) : IsLindelof (s ∩ t) 
goal: IsLindelof (s ∩ t)

full_name: IsLindelof.diff
code: /-- The set difference of a Lindelöf set and an open set is a Lindelöf set. -/
theorem IsLindelof.diff (hs : IsLindelof s) (ht : IsOpen t) : IsLindelof (s \ t) 
goal: IsLindelof (s \ t)

full_name: IsLindelof.of_isClosed_subset
code: /-- A closed subset of a Lindelöf set is a Lindelöf set. -/
theorem IsLindelof.of_isClosed_subset (hs : IsLindelof s) (ht : IsClosed t) (h : t ⊆ s) :
    IsLindelof t 
goal: IsLindelof t

full_name: IsLindelof.image_of_continuousOn
code: /-- A continuous image of a Lindelöf set is a Lindelöf set. -/
theorem IsLindelof.image_of_continuousOn {f : X → Y} (hs : IsLindelof s) (hf : ContinuousOn f s) :
    IsLindelof (f '' s) 
goal: IsLindelof (f '' s)

full_name: IsLindelof.image
code: /-- A continuous image of a Lindelöf set is a Lindelöf set within the codomain. -/
theorem IsLindelof.image {f : X → Y} (hs : IsLindelof s) (hf : Continuous f) :
    IsLindelof (f '' s) 
goal: IsLindelof (f '' s)

full_name: IsLindelof.adherence_nhdset
code: /-- A filter with the countable intersection property that is finer than the principal filter on
a Lindelöf set `s` contains any open set that contains all clusterpoints of `s`. -/
theorem IsLindelof.adherence_nhdset {f : Filter X} [CountableInterFilter f] (hs : IsLindelof s)
    (hf₂ : f ≤ 𝓟 s) (ht₁ : IsOpen t) (ht₂ : ∀ x ∈ s, ClusterPt x f → x ∈ t) : t ∈ f 
goal: t ∈ f

full_name: IsLindelof.elim_countable_subcover
code: /-- For every open cover of a Lindelöf set, there exists a countable subcover. -/
theorem IsLindelof.elim_countable_subcover {ι : Type v} (hs : IsLindelof s) (U : ι → Set X)
    (hUo : ∀ i, IsOpen (U i)) (hsU : s ⊆ ⋃ i, U i) :
    ∃ r : Set ι, r.Countable ∧ (s ⊆ ⋃ i ∈ r, U i) 
goal: ∃ r, r.Countable ∧ s ⊆ ⋃ i ∈ r, U i

full_name: IsLindelof.elim_nhds_subcover'
code: theorem IsLindelof.elim_nhds_subcover' (hs : IsLindelof s) (U : ∀ x ∈ s, Set X)
    (hU : ∀ x (hx : x ∈ s), U x ‹x ∈ s› ∈ 𝓝 x) :
    ∃ t : Set s, t.Countable ∧ s ⊆ ⋃ x ∈ t, U (x : s) x.2 
goal: ∃ t, t.Countable ∧ s ⊆ ⋃ x ∈ t, U ↑x ⋯

full_name: IsLindelof.elim_nhds_subcover
code: theorem IsLindelof.elim_nhds_subcover (hs : IsLindelof s) (U : X → Set X)
    (hU : ∀ x ∈ s, U x ∈ 𝓝 x) :
    ∃ t : Set X, t.Countable ∧ (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x 
goal: ∃ t, t.Countable ∧ (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x

full_name: IsLindelof.indexed_countable_subcover
code: /-- For every nonempty open cover of a Lindelöf set, there exists a subcover indexed by ℕ. -/
theorem IsLindelof.indexed_countable_subcover {ι : Type v} [Nonempty ι]
    (hs : IsLindelof s) (U : ι → Set X) (hUo : ∀ i, IsOpen (U i)) (hsU : s ⊆ ⋃ i, U i) :
    ∃ f : ℕ → ι, s ⊆ ⋃ n, U (f n) 
goal: ∃ f, s ⊆ ⋃ n, U (f n)

full_name: IsLindelof.disjoint_nhdsSet_left
code: /-- The neighborhood filter of a Lindelöf set is disjoint with a filter `l` with the countable
intersection property if and only if the neighborhood filter of each point of this set
is disjoint with `l`. -/
theorem IsLindelof.disjoint_nhdsSet_left {l : Filter X} [CountableInterFilter l]
    (hs : IsLindelof s) :
    Disjoint (𝓝ˢ s) l ↔ ∀ x ∈ s, Disjoint (𝓝 x) l 
goal: Disjoint (𝓝ˢ s) l ↔ ∀ x ∈ s, Disjoint (𝓝 x) l

full_name: IsLindelof.disjoint_nhdsSet_right
code: /-- A filter `l` with the countable intersection property is disjoint with the neighborhood
filter of a Lindelöf set if and only if it is disjoint with the neighborhood filter of each point
of this set. -/
theorem IsLindelof.disjoint_nhdsSet_right {l : Filter X} [CountableInterFilter l]
    (hs : IsLindelof s) : Disjoint l (𝓝ˢ s) ↔ ∀ x ∈ s, Disjoint l (𝓝 x) 
goal: Disjoint l (𝓝ˢ s) ↔ ∀ x ∈ s, Disjoint l (𝓝 x)

full_name: IsLindelof.elim_countable_subfamily_closed
code: /-- For every family of closed sets whose intersection avoids a Lindelö set,
there exists a countable subfamily whose intersection avoids this Lindelöf set. -/
theorem IsLindelof.elim_countable_subfamily_closed {ι : Type v} (hs : IsLindelof s)
    (t : ι → Set X) (htc : ∀ i, IsClosed (t i)) (hst : (s ∩ ⋂ i, t i) = ∅) :
    ∃ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i) = ∅ 
goal: ∃ u, u.Countable ∧ s ∩ ⋂ i ∈ u, t i = ∅

full_name: IsLindelof.inter_iInter_nonempty
code: /-- To show that a Lindelöf set intersects the intersection of a family of closed sets,
  it is sufficient to show that it intersects every countable subfamily. -/
theorem IsLindelof.inter_iInter_nonempty {ι : Type v} (hs : IsLindelof s) (t : ι → Set X)
    (htc : ∀ i, IsClosed (t i)) (hst : ∀ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i).Nonempty) :
    (s ∩ ⋂ i, t i).Nonempty 
goal: (s ∩ ⋂ i, t i).Nonempty

full_name: IsLindelof.elim_countable_subcover_image
code: /-- For every open cover of a Lindelöf set, there exists a countable subcover. -/
theorem IsLindelof.elim_countable_subcover_image {b : Set ι} {c : ι → Set X} (hs : IsLindelof s)
    (hc₁ : ∀ i ∈ b, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i ∈ b, c i) :
    ∃ b', b' ⊆ b ∧ Set.Countable b' ∧ s ⊆ ⋃ i ∈ b', c i 
goal: ∃ b' ⊆ b, b'.Countable ∧ s ⊆ ⋃ i ∈ b', c i

full_name: isLindelof_of_countable_subcover
code: /-- A set `s` is Lindelöf if for every open cover of `s`, there exists a countable subcover. -/
theorem isLindelof_of_countable_subcover
    (h : ∀ {ι : Type u} (U : ι → Set X), (∀ i, IsOpen (U i)) → (s ⊆ ⋃ i, U i) →
    ∃ t : Set ι, t.Countable ∧ s ⊆ ⋃ i ∈ t, U i) :
    IsLindelof s 
goal: IsLindelof s

full_name: isLindelof_of_countable_subfamily_closed
code: /-- A set `s` is Lindelöf if for every family of closed sets whose intersection avoids `s`,
there exists a countable subfamily whose intersection avoids `s`. -/
theorem isLindelof_of_countable_subfamily_closed
    (h :
      ∀ {ι : Type u} (t : ι → Set X), (∀ i, IsClosed (t i)) → (s ∩ ⋂ i, t i) = ∅ →
        ∃ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i) = ∅) :
    IsLindelof s 
goal: IsLindelof s

full_name: isLindelof_iff_countable_subcover
code: /-- A set `s` is Lindelöf if and only if
for every open cover of `s`, there exists a countable subcover. -/
theorem isLindelof_iff_countable_subcover :
    IsLindelof s ↔ ∀ {ι : Type u} (U : ι → Set X),
      (∀ i, IsOpen (U i)) → (s ⊆ ⋃ i, U i) → ∃ t : Set ι, t.Countable ∧ s ⊆ ⋃ i ∈ t, U i 
goal: IsLindelof s ↔
  ∀ {ι : Type u} (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → ∃ t, t.Countable ∧ s ⊆ ⋃ i ∈ t, U i

full_name: isLindelof_iff_countable_subfamily_closed
code: /-- A set `s` is Lindelöf if and only if
for every family of closed sets whose intersection avoids `s`,
there exists a countable subfamily whose intersection avoids `s`. -/
theorem isLindelof_iff_countable_subfamily_closed :
    IsLindelof s ↔ ∀ {ι : Type u} (t : ι → Set X),
    (∀ i, IsClosed (t i)) → (s ∩ ⋂ i, t i) = ∅
    → ∃ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i) = ∅ 
goal: IsLindelof s ↔
  ∀ {ι : Type u} (t : ι → Set X),
    (∀ (i : ι), IsClosed (t i)) → s ∩ ⋂ i, t i = ∅ → ∃ u, u.Countable ∧ s ∩ ⋂ i ∈ u, t i = ∅

full_name: isLindelof_empty
code: /-- The empty set is a Lindelof set. -/
@[simp]
theorem isLindelof_empty : IsLindelof (∅ : Set X) 
goal: IsLindelof ∅

full_name: isLindelof_singleton
code: /-- A singleton set is a Lindelof set. -/
@[simp]
theorem isLindelof_singleton {x : X} : IsLindelof ({x} : Set X) 
goal: IsLindelof {x}

full_name: Set.Subsingleton.isLindelof
code: theorem Set.Subsingleton.isLindelof (hs : s.Subsingleton) : IsLindelof s 
goal: IsLindelof s

full_name: Set.Countable.isLindelof_biUnion
code: theorem Set.Countable.isLindelof_biUnion {s : Set ι} {f : ι → Set X} (hs : s.Countable)
    (hf : ∀ i ∈ s, IsLindelof (f i)) : IsLindelof (⋃ i ∈ s, f i) 
goal: IsLindelof (⋃ i ∈ s, f i)

full_name: Set.Finite.isLindelof_biUnion
code: theorem Set.Finite.isLindelof_biUnion {s : Set ι} {f : ι → Set X} (hs : s.Finite)
    (hf : ∀ i ∈ s, IsLindelof (f i)) : IsLindelof (⋃ i ∈ s, f i) 
goal: IsLindelof (⋃ i ∈ s, f i)

full_name: Finset.isLindelof_biUnion
code: theorem Finset.isLindelof_biUnion (s : Finset ι) {f : ι → Set X} (hf : ∀ i ∈ s, IsLindelof (f i)) :
    IsLindelof (⋃ i ∈ s, f i) 
goal: IsLindelof (⋃ i ∈ s, f i)

full_name: isLindelof_accumulate
code: theorem isLindelof_accumulate {K : ℕ → Set X} (hK : ∀ n, IsLindelof (K n)) (n : ℕ) :
    IsLindelof (Accumulate K n) 
goal: IsLindelof (Set.Accumulate K n)

full_name: Set.Countable.isLindelof_sUnion
code: theorem Set.Countable.isLindelof_sUnion {S : Set (Set X)} (hf : S.Countable)
    (hc : ∀ s ∈ S, IsLindelof s) : IsLindelof (⋃₀ S) 
goal: IsLindelof (⋃₀ S)

full_name: Set.Finite.isLindelof_sUnion
code: theorem Set.Finite.isLindelof_sUnion {S : Set (Set X)} (hf : S.Finite)
    (hc : ∀ s ∈ S, IsLindelof s) : IsLindelof (⋃₀ S) 
goal: IsLindelof (⋃₀ S)

full_name: isLindelof_iUnion
code: theorem isLindelof_iUnion {ι : Sort*} {f : ι → Set X} [Countable ι] (h : ∀ i, IsLindelof (f i)) :
    IsLindelof (⋃ i, f i) 
goal: IsLindelof (⋃ i, f i)

full_name: Set.Countable.isLindelof
code: theorem Set.Countable.isLindelof (hs : s.Countable) : IsLindelof s 
goal: IsLindelof s

full_name: Set.Finite.isLindelof
code: theorem Set.Finite.isLindelof (hs : s.Finite) : IsLindelof s 
goal: IsLindelof s

full_name: IsLindelof.countable_of_discrete
code: theorem IsLindelof.countable_of_discrete [DiscreteTopology X] (hs : IsLindelof s) :
    s.Countable 
goal: s.Countable

full_name: isLindelof_iff_countable
code: theorem isLindelof_iff_countable [DiscreteTopology X] : IsLindelof s ↔ s.Countable 
goal: IsLindelof s ↔ s.Countable

full_name: IsLindelof.union
code: theorem IsLindelof.union (hs : IsLindelof s) (ht : IsLindelof t) : IsLindelof (s ∪ t) 
goal: IsLindelof (s ∪ t)

full_name: IsLindelof.insert
code: protected theorem IsLindelof.insert (hs : IsLindelof s) (a) : IsLindelof (insert a s) 
goal: IsLindelof (insert a s)

full_name: isLindelof_open_iff_eq_countable_iUnion_of_isTopologicalBasis
code: /-- If `X` has a basis consisting of compact opens, then an open set in `X` is compact open iff
it is a finite union of some elements in the basis -/
theorem isLindelof_open_iff_eq_countable_iUnion_of_isTopologicalBasis (b : ι → Set X)
    (hb : IsTopologicalBasis (Set.range b)) (hb' : ∀ i, IsLindelof (b i)) (U : Set X) :
    IsLindelof U ∧ IsOpen U ↔ ∃ s : Set ι, s.Countable ∧ U = ⋃ i ∈ s, b i 
goal: IsLindelof U ∧ IsOpen U ↔ ∃ s, s.Countable ∧ U = ⋃ i ∈ s, b i

full_name: Filter.coLindelof
code: /-- `Filter.coLindelof` is the filter generated by complements to Lindelöf sets. -/
def Filter.coLindelof (X : Type*) [TopologicalSpace X] : Filter X 
goal: Filter X

full_name: hasBasis_coLindelof
code: theorem hasBasis_coLindelof : (coLindelof X).HasBasis IsLindelof compl 
goal: (Filter.coLindelof X).HasBasis IsLindelof compl

full_name: mem_coLindelof
code: theorem mem_coLindelof : s ∈ coLindelof X ↔ ∃ t, IsLindelof t ∧ tᶜ ⊆ s 
goal: s ∈ Filter.coLindelof X ↔ ∃ t, IsLindelof t ∧ tᶜ ⊆ s

full_name: mem_coLindelof'
code: theorem mem_coLindelof' : s ∈ coLindelof X ↔ ∃ t, IsLindelof t ∧ sᶜ ⊆ t 
goal: s ∈ Filter.coLindelof X ↔ ∃ t, IsLindelof t ∧ sᶜ ⊆ t

full_name: IsLindelof.compl_mem_coLindelof
code: theorem _root_.IsLindelof.compl_mem_coLindelof (hs : IsLindelof s) : sᶜ ∈ coLindelof X 
goal: sᶜ ∈ Filter.coLindelof X

full_name: coLindelof_le_cofinite
code: theorem coLindelof_le_cofinite : coLindelof X ≤ cofinite 
goal: Filter.coLindelof X ≤ Filter.cofinite

full_name: Tendsto.isLindelof_insert_range_of_coLindelof
code: theorem Tendsto.isLindelof_insert_range_of_coLindelof {f : X → Y} {y}
    (hf : Tendsto f (coLindelof X) (𝓝 y)) (hfc : Continuous f) :
    IsLindelof (insert y (range f)) 
goal: IsLindelof (insert y (Set.range f))

full_name: Filter.coclosedLindelof
code: /-- `Filter.coclosedLindelof` is the filter generated by complements to closed Lindelof sets. -/
def Filter.coclosedLindelof (X : Type*) [TopologicalSpace X] : Filter X 
goal: Filter X

full_name: hasBasis_coclosedLindelof
code: theorem hasBasis_coclosedLindelof :
    (Filter.coclosedLindelof X).HasBasis (fun s => IsClosed s ∧ IsLindelof s) compl 
goal: (Filter.coclosedLindelof X).HasBasis (fun s => IsClosed s ∧ IsLindelof s) compl

full_name: mem_coclosedLindelof
code: theorem mem_coclosedLindelof : s ∈ coclosedLindelof X ↔
    ∃ t, IsClosed t ∧ IsLindelof t ∧ tᶜ ⊆ s 
goal: s ∈ Filter.coclosedLindelof X ↔ ∃ t, IsClosed t ∧ IsLindelof t ∧ tᶜ ⊆ s

full_name: mem_coclosed_Lindelof'
code: theorem mem_coclosed_Lindelof' : s ∈ coclosedLindelof X ↔
    ∃ t, IsClosed t ∧ IsLindelof t ∧ sᶜ ⊆ t 
goal: s ∈ Filter.coclosedLindelof X ↔ ∃ t, IsClosed t ∧ IsLindelof t ∧ sᶜ ⊆ t

full_name: coLindelof_le_coclosedLindelof
code: theorem coLindelof_le_coclosedLindelof : coLindelof X ≤ coclosedLindelof X 
goal: Filter.coLindelof X ≤ Filter.coclosedLindelof X

full_name: IsLindeof.compl_mem_coclosedLindelof_of_isClosed
code: theorem IsLindeof.compl_mem_coclosedLindelof_of_isClosed (hs : IsLindelof s) (hs' : IsClosed s) :
    sᶜ ∈ Filter.coclosedLindelof X 
goal: sᶜ ∈ Filter.coclosedLindelof X

full_name: LindelofSpace
code: /-- X is a Lindelöf space iff every open cover has a countable subcover. -/
class LindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- In a Lindelöf space, `Set.univ` is a Lindelöf set. -/
  isLindelof_univ : IsLindelof (univ : Set X)
goal: Prop

full_name: LindelofSpace.isLindelof_univ
code: /-- X is a Lindelöf space iff every open cover has a countable subcover. -/
class LindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- In a Lindelöf space, `Set.univ` is a Lindelöf set. -/
  isLindelof_univ : IsLindelof (univ : Set X)
goal: IsLindelof Set.univ

full_name: Subsingleton.lindelofSpace
code: instance (priority := 10) Subsingleton.lindelofSpace [Subsingleton X] : LindelofSpace X 
goal: LindelofSpace X

full_name: isLindelof_univ_iff
code: theorem isLindelof_univ_iff : IsLindelof (univ : Set X) ↔ LindelofSpace X 
goal: IsLindelof Set.univ ↔ LindelofSpace X

full_name: isLindelof_univ
code: theorem isLindelof_univ [h : LindelofSpace X] : IsLindelof (univ : Set X) 
goal: IsLindelof Set.univ

full_name: cluster_point_of_Lindelof
code: theorem cluster_point_of_Lindelof [LindelofSpace X] (f : Filter X) [NeBot f]
    [CountableInterFilter f] : ∃ x, ClusterPt x f 
goal: ∃ x, ClusterPt x f

full_name: LindelofSpace.elim_nhds_subcover
code: theorem LindelofSpace.elim_nhds_subcover [LindelofSpace X] (U : X → Set X) (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Set X, t.Countable ∧ ⋃ x ∈ t, U x = univ 
goal: ∃ t, t.Countable ∧ ⋃ x ∈ t, U x = Set.univ

full_name: lindelofSpace_of_countable_subfamily_closed
code: theorem lindelofSpace_of_countable_subfamily_closed
    (h : ∀ {ι : Type u} (t : ι → Set X), (∀ i, IsClosed (t i)) → ⋂ i, t i = ∅ →
      ∃ u : Set ι, u.Countable ∧ ⋂ i ∈ u, t i = ∅) :
    LindelofSpace X 
goal: LindelofSpace X

full_name: IsClosed.isLindelof
code: theorem IsClosed.isLindelof [LindelofSpace X] (h : IsClosed s) : IsLindelof s 
goal: IsLindelof s

full_name: IsCompact.isLindelof
code: /-- A compact set `s` is Lindelöf. -/
theorem IsCompact.isLindelof (hs : IsCompact s) :
    IsLindelof s 
goal: IsLindelof s

full_name: IsSigmaCompact.isLindelof
code: /-- A σ-compact set `s` is Lindelöf-/
theorem IsSigmaCompact.isLindelof (hs : IsSigmaCompact s) :
    IsLindelof s 
goal: IsLindelof s

full_name: instLindelofSpaceOfCompactSpace
code: /-- A compact space `X` is Lindelöf. -/
instance (priority := 100) [CompactSpace X] : LindelofSpace X 
goal: LindelofSpace X

full_name: instLindelofSpaceOfSigmaCompactSpace
code: /-- A sigma-compact space `X` is Lindelöf. -/
instance (priority := 100) [SigmaCompactSpace X] : LindelofSpace X 
goal: LindelofSpace X

full_name: NonLindelofSpace
code: /-- `X` is a non-Lindelöf topological space if it is not a Lindelöf space. -/
class NonLindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- In a non-Lindelöf space, `Set.univ` is not a Lindelöf set. -/
  nonLindelof_univ : ¬IsLindelof (univ : Set X)
goal: Prop

full_name: NonLindelofSpace.nonLindelof_univ
code: /-- `X` is a non-Lindelöf topological space if it is not a Lindelöf space. -/
class NonLindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- In a non-Lindelöf space, `Set.univ` is not a Lindelöf set. -/
  nonLindelof_univ : ¬IsLindelof (univ : Set X)
goal: ¬IsLindelof Set.univ

full_name: nonLindelof_univ
code: lemma nonLindelof_univ (X : Type*) [TopologicalSpace X] [NonLindelofSpace X] :
    ¬IsLindelof (univ : Set X) 
goal: ¬IsLindelof Set.univ

full_name: IsLindelof.ne_univ
code: theorem IsLindelof.ne_univ [NonLindelofSpace X] (hs : IsLindelof s) : s ≠ univ 
goal: s ≠ Set.univ

full_name: instNeBotCoLindelofOfNonLindelofSpace
code: instance [NonLindelofSpace X] : NeBot (Filter.coLindelof X) 
goal: (Filter.coLindelof X).NeBot

full_name: Filter.coLindelof_eq_bot
code: @[simp]
theorem Filter.coLindelof_eq_bot [LindelofSpace X] : Filter.coLindelof X = ⊥ 
goal: Filter.coLindelof X = ⊥

full_name: instNeBotCoclosedLindelofOfNonLindelofSpace
code: instance [NonLindelofSpace X] : NeBot (Filter.coclosedLindelof X) 
goal: (Filter.coclosedLindelof X).NeBot

full_name: nonLindelofSpace_of_neBot
code: theorem nonLindelofSpace_of_neBot (_ : NeBot (Filter.coLindelof X)) : NonLindelofSpace X 
goal: (Filter.coLindelof X).NeBot → NonLindelofSpace X

full_name: Filter.coLindelof_neBot_iff
code: theorem Filter.coLindelof_neBot_iff : NeBot (Filter.coLindelof X) ↔ NonLindelofSpace X 
goal: (Filter.coLindelof X).NeBot ↔ NonLindelofSpace X

full_name: not_LindelofSpace_iff
code: theorem not_LindelofSpace_iff : ¬LindelofSpace X ↔ NonLindelofSpace X 
goal: ¬LindelofSpace X ↔ NonLindelofSpace X

full_name: instLindelofSpaceOfCompactSpace_1
code: /-- A compact space `X` is Lindelöf.  -/
instance (priority := 100) [CompactSpace X] : LindelofSpace X 
goal: LindelofSpace X

full_name: countable_of_Lindelof_of_discrete
code: theorem countable_of_Lindelof_of_discrete [LindelofSpace X] [DiscreteTopology X] : Countable X 
goal: Countable X

full_name: countable_cover_nhds_interior
code: theorem countable_cover_nhds_interior [LindelofSpace X] {U : X → Set X} (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Set X, t.Countable ∧ ⋃ x ∈ t, interior (U x) = univ 
goal: ∃ t, t.Countable ∧ ⋃ x ∈ t, interior (U x) = Set.univ

full_name: countable_cover_nhds
code: theorem countable_cover_nhds [LindelofSpace X] {U : X → Set X} (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Set X, t.Countable ∧ ⋃ x ∈ t, U x = univ 
goal: ∃ t, t.Countable ∧ ⋃ x ∈ t, U x = Set.univ

full_name: Filter.comap_coLindelof_le
code: /-- The comap of the coLindelöf filter on `Y` by a continuous function `f : X → Y` is less than or
equal to the coLindelöf filter on `X`.
This is a reformulation of the fact that images of Lindelöf sets are Lindelöf. -/
theorem Filter.comap_coLindelof_le {f : X → Y} (hf : Continuous f) :
    (Filter.coLindelof Y).comap f ≤ Filter.coLindelof X 
goal: Filter.comap f (Filter.coLindelof Y) ≤ Filter.coLindelof X

full_name: isLindelof_range
code: theorem isLindelof_range [LindelofSpace X] {f : X → Y} (hf : Continuous f) :
    IsLindelof (range f) 
goal: IsLindelof (Set.range f)

full_name: isLindelof_diagonal
code: theorem isLindelof_diagonal [LindelofSpace X] : IsLindelof (diagonal X) 
goal: IsLindelof (Set.diagonal X)

full_name: Inducing.isLindelof_iff
code: /-- If `f : X → Y` is an `Inducing` map, the image `f '' s` of a set `s` is Lindelöf
  if and only if `s` is compact. -/
theorem Inducing.isLindelof_iff {f : X → Y} (hf : Inducing f) :
    IsLindelof s ↔ IsLindelof (f '' s) 
goal: IsLindelof s ↔ IsLindelof (f '' s)

full_name: Embedding.isLindelof_iff
code: /-- If `f : X → Y` is an `Embedding`, the image `f '' s` of a set `s` is Lindelöf
  if and only if `s` is Lindelöf. -/
theorem Embedding.isLindelof_iff {f : X → Y} (hf : Embedding f) :
    IsLindelof s ↔ IsLindelof (f '' s) 
goal: IsLindelof s ↔ IsLindelof (f '' s)

full_name: Inducing.isLindelof_preimage
code: /-- The preimage of a Lindelöf set under an inducing map is a Lindelöf set. -/
theorem Inducing.isLindelof_preimage {f : X → Y} (hf : Inducing f) (hf' : IsClosed (range f))
    {K : Set Y} (hK : IsLindelof K) : IsLindelof (f ⁻¹' K) 
goal: IsLindelof (f ⁻¹' K)

full_name: ClosedEmbedding.isLindelof_preimage
code: /-- The preimage of a Lindelöf set under a closed embedding is a Lindelöf set. -/
theorem ClosedEmbedding.isLindelof_preimage {f : X → Y} (hf : ClosedEmbedding f)
    {K : Set Y} (hK : IsLindelof K) : IsLindelof (f ⁻¹' K) 
goal: IsLindelof (f ⁻¹' K)

full_name: ClosedEmbedding.tendsto_coLindelof
code: /-- A closed embedding is proper, ie, inverse images of Lindelöf sets are contained in Lindelöf.
Moreover, the preimage of a Lindelöf set is Lindelöf, see `ClosedEmbedding.isLindelof_preimage`. -/
theorem ClosedEmbedding.tendsto_coLindelof {f : X → Y} (hf : ClosedEmbedding f) :
    Tendsto f (Filter.coLindelof X) (Filter.coLindelof Y) 
goal: Filter.Tendsto f (Filter.coLindelof X) (Filter.coLindelof Y)

full_name: Subtype.isLindelof_iff
code: /-- Sets of subtype are Lindelöf iff the image under a coercion is. -/
theorem Subtype.isLindelof_iff {p : X → Prop} {s : Set { x // p x }} :
    IsLindelof s ↔ IsLindelof ((↑) '' s : Set X) 
goal: IsLindelof s ↔ IsLindelof (Subtype.val '' s)

full_name: isLindelof_iff_isLindelof_univ
code: theorem isLindelof_iff_isLindelof_univ : IsLindelof s ↔ IsLindelof (univ : Set s) 
goal: IsLindelof s ↔ IsLindelof Set.univ

full_name: isLindelof_iff_LindelofSpace
code: theorem isLindelof_iff_LindelofSpace : IsLindelof s ↔ LindelofSpace s 
goal: IsLindelof s ↔ LindelofSpace ↑s

full_name: IsLindelof.of_coe
code: lemma IsLindelof.of_coe [LindelofSpace s] : IsLindelof s 
goal: IsLindelof s

full_name: IsLindelof.countable
code: theorem IsLindelof.countable (hs : IsLindelof s) (hs' : DiscreteTopology s) : s.Countable 
goal: s.Countable

full_name: ClosedEmbedding.nonLindelofSpace
code: protected theorem ClosedEmbedding.nonLindelofSpace [NonLindelofSpace X] {f : X → Y}
    (hf : ClosedEmbedding f) : NonLindelofSpace Y 
goal: NonLindelofSpace Y

full_name: ClosedEmbedding.LindelofSpace
code: protected theorem ClosedEmbedding.LindelofSpace [h : LindelofSpace Y] {f : X → Y}
    (hf : ClosedEmbedding f) : LindelofSpace X 
goal: LindelofSpace X

full_name: Countable.LindelofSpace
code: /-- Countable topological spaces are Lindelof. -/
instance (priority := 100) Countable.LindelofSpace [Countable X] : LindelofSpace X 
goal: LindelofSpace X

full_name: instLindelofSpaceSum
code: /-- The disjoint union of two Lindelöf spaces is Lindelöf. -/
instance [LindelofSpace X] [LindelofSpace Y] : LindelofSpace (X ⊕ Y) 
goal: LindelofSpace (X ⊕ Y)

full_name: instLindelofSpaceSigmaOfCountable
code: instance {X : ι → Type*} [Countable ι] [∀ i, TopologicalSpace (X i)] [∀ i, LindelofSpace (X i)] :
    LindelofSpace (Σi, X i) 
goal: LindelofSpace ((i : ι) × X i)

full_name: Quot.LindelofSpace
code: instance Quot.LindelofSpace {r : X → X → Prop} [LindelofSpace X] : LindelofSpace (Quot r) 
goal: LindelofSpace (Quot r)

full_name: Quotient.LindelofSpace
code: instance Quotient.LindelofSpace {s : Setoid X} [LindelofSpace X] : LindelofSpace (Quotient s) 
goal: LindelofSpace (Quotient s)

full_name: LindelofSpace.of_continuous_surjective
code: /-- A continuous image of a Lindelöf set is a Lindelöf set within the codomain. -/
theorem LindelofSpace.of_continuous_surjective {f : X → Y} [LindelofSpace X] (hf : Continuous f)
    (hsur : Function.Surjective f) : LindelofSpace Y 
goal: LindelofSpace Y

full_name: IsHereditarilyLindelof
code: /-- A set `s` is Hereditarily Lindelöf if every subset is a Lindelof set. We require this only
for open sets in the definition, and then conclude that this holds for all sets by ADD. -/
def IsHereditarilyLindelof (s : Set X) 
goal: Prop

full_name: HereditarilyLindelofSpace.isHereditarilyLindelof_univ
code: /-- Type class for Hereditarily Lindelöf spaces.  -/
class HereditarilyLindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- In a Hereditarily Lindelöf space, `Set.univ` is a Hereditarily Lindelöf set. -/
  isHereditarilyLindelof_univ : IsHereditarilyLindelof (univ : Set X)
goal: IsHereditarilyLindelof Set.univ

full_name: HereditarilyLindelofSpace
code: /-- Type class for Hereditarily Lindelöf spaces.  -/
class HereditarilyLindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- In a Hereditarily Lindelöf space, `Set.univ` is a Hereditarily Lindelöf set. -/
  isHereditarilyLindelof_univ : IsHereditarilyLindelof (univ : Set X)
goal: Prop

full_name: IsHereditarilyLindelof.isLindelof_subset
code: lemma IsHereditarilyLindelof.isLindelof_subset (hs : IsHereditarilyLindelof s) (ht : t ⊆ s) :
    IsLindelof t 
goal: IsLindelof t

full_name: IsHereditarilyLindelof.isLindelof
code: lemma IsHereditarilyLindelof.isLindelof (hs : IsHereditarilyLindelof s) :
    IsLindelof s 
goal: IsLindelof s

full_name: HereditarilyLindelof.to_Lindelof
code: instance (priority := 100) HereditarilyLindelof.to_Lindelof [HereditarilyLindelofSpace X] :
    LindelofSpace X 
goal: LindelofSpace X

full_name: HereditarilyLindelof_LindelofSets
code: theorem HereditarilyLindelof_LindelofSets [HereditarilyLindelofSpace X] (s : Set X) :
    IsLindelof s 
goal: IsLindelof s

full_name: SecondCountableTopology.toHereditarilyLindelof
code: instance (priority := 100) SecondCountableTopology.toHereditarilyLindelof
    [SecondCountableTopology X] : HereditarilyLindelofSpace X 
goal: HereditarilyLindelofSpace X

full_name: eq_open_union_countable
code: lemma eq_open_union_countable [HereditarilyLindelofSpace X] {ι : Type u} (U : ι → Set X)
    (h : ∀ i, IsOpen (U i)) : ∃ t : Set ι, t.Countable ∧ ⋃ i∈t, U i = ⋃ i, U i 
goal: ∃ t, t.Countable ∧ ⋃ i ∈ t, U i = ⋃ i, U i

full_name: HereditarilyLindelof.lindelofSpace_subtype
code: instance HereditarilyLindelof.lindelofSpace_subtype [HereditarilyLindelofSpace X] (p : X → Prop) :
    LindelofSpace {x // p x} 
goal: LindelofSpace { x // p x }