File: Mathlib/Topology/Compactness/Compact.lean

full_name: IsCompact.exists_clusterPt
code: lemma IsCompact.exists_clusterPt (hs : IsCompact s) {f : Filter X} [NeBot f] (hf : f ≤ 𝓟 s) :
    ∃ x ∈ s, ClusterPt x f 
goal: ∃ x ∈ s, ClusterPt x f

full_name: IsCompact.exists_mapClusterPt
code: lemma IsCompact.exists_mapClusterPt {ι : Type*} (hs : IsCompact s) {f : Filter ι} [NeBot f]
    {u : ι → X} (hf : Filter.map u f ≤ 𝓟 s) :
    ∃ x ∈ s, MapClusterPt x f u 
goal: ∃ x ∈ s, MapClusterPt x f u

full_name: IsCompact.compl_mem_sets
code: /-- The complement to a compact set belongs to a filter `f` if it belongs to each filter
`𝓝 x ⊓ f`, `x ∈ s`. -/
theorem IsCompact.compl_mem_sets (hs : IsCompact s) {f : Filter X} (hf : ∀ x ∈ s, sᶜ ∈ 𝓝 x ⊓ f) :
    sᶜ ∈ f 
goal: sᶜ ∈ f

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

full_name: IsCompact.induction_on
code: /-- If `p : Set X → Prop` is stable under restriction and union, and each point `x`
  of a compact set `s` has a neighborhood `t` within `s` such that `p t`, then `p s` holds. -/
@[elab_as_elim]
theorem IsCompact.induction_on (hs : IsCompact s) {p : Set X → Prop} (he : p ∅)
    (hmono : ∀ ⦃s t⦄, s ⊆ t → p t → p s) (hunion : ∀ ⦃s t⦄, p s → p t → p (s ∪ t))
    (hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t) : p s 
goal: p s

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

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

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

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

full_name: IsCompact.image_of_continuousOn
code: theorem IsCompact.image_of_continuousOn {f : X → Y} (hs : IsCompact s) (hf : ContinuousOn f s) :
    IsCompact (f '' s) 
goal: IsCompact (f '' s)

full_name: IsCompact.image
code: theorem IsCompact.image {f : X → Y} (hs : IsCompact s) (hf : Continuous f) : IsCompact (f '' s) 
goal: IsCompact (f '' s)

full_name: IsCompact.adherence_nhdset
code: theorem IsCompact.adherence_nhdset {f : Filter X} (hs : IsCompact s) (hf₂ : f ≤ 𝓟 s)
    (ht₁ : IsOpen t) (ht₂ : ∀ x ∈ s, ClusterPt x f → x ∈ t) : t ∈ f 
goal: t ∈ f

full_name: isCompact_iff_ultrafilter_le_nhds
code: theorem isCompact_iff_ultrafilter_le_nhds :
    IsCompact s ↔ ∀ f : Ultrafilter X, ↑f ≤ 𝓟 s → ∃ x ∈ s, ↑f ≤ 𝓝 x 
goal: IsCompact s ↔ ∀ (f : Ultrafilter X), ↑f ≤ 𝓟 s → ∃ x ∈ s, ↑f ≤ 𝓝 x

full_name: isCompact_iff_ultrafilter_le_nhds'
code: theorem isCompact_iff_ultrafilter_le_nhds' :
    IsCompact s ↔ ∀ f : Ultrafilter X, s ∈ f → ∃ x ∈ s, ↑f ≤ 𝓝 x 
goal: IsCompact s ↔ ∀ (f : Ultrafilter X), s ∈ f → ∃ x ∈ s, ↑f ≤ 𝓝 x

full_name: IsCompact.le_nhds_of_unique_clusterPt
code: /-- If a compact set belongs to a filter and this filter has a unique cluster point `y` in this set,
then the filter is less than or equal to `𝓝 y`. -/
lemma IsCompact.le_nhds_of_unique_clusterPt (hs : IsCompact s) {l : Filter X} {y : X}
    (hmem : s ∈ l) (h : ∀ x ∈ s, ClusterPt x l → x = y) : l ≤ 𝓝 y 
goal: l ≤ 𝓝 y

full_name: IsCompact.tendsto_nhds_of_unique_mapClusterPt
code: /-- If values of `f : Y → X` belong to a compact set `s` eventually along a filter `l`
and `y` is a unique `MapClusterPt` for `f` along `l` in `s`,
then `f` tends to `𝓝 y` along `l`. -/
lemma IsCompact.tendsto_nhds_of_unique_mapClusterPt {l : Filter Y} {y : X} {f : Y → X}
    (hs : IsCompact s) (hmem : ∀ᶠ x in l, f x ∈ s) (h : ∀ x ∈ s, MapClusterPt x l f → x = y) :
    Tendsto f l (𝓝 y) 
goal: Filter.Tendsto f l (𝓝 y)

full_name: IsCompact.elim_directed_cover
code: /-- For every open directed cover of a compact set, there exists a single element of the
cover which itself includes the set. -/
theorem IsCompact.elim_directed_cover {ι : Type v} [hι : Nonempty ι] (hs : IsCompact s)
    (U : ι → Set X) (hUo : ∀ i, IsOpen (U i)) (hsU : s ⊆ ⋃ i, U i) (hdU : Directed (· ⊆ ·) U) :
    ∃ i, s ⊆ U i 
goal: ∃ i, s ⊆ U i

full_name: IsCompact.elim_finite_subcover
code: /-- For every open cover of a compact set, there exists a finite subcover. -/
theorem IsCompact.elim_finite_subcover {ι : Type v} (hs : IsCompact s) (U : ι → Set X)
    (hUo : ∀ i, IsOpen (U i)) (hsU : s ⊆ ⋃ i, U i) : ∃ t : Finset ι, s ⊆ ⋃ i ∈ t, U i 
goal: ∃ t, s ⊆ ⋃ i ∈ t, U i

full_name: IsCompact.elim_nhds_subcover_nhdsSet'
code: lemma IsCompact.elim_nhds_subcover_nhdsSet' (hs : IsCompact s) (U : ∀ x ∈ s, Set X)
    (hU : ∀ x hx, U x hx ∈ 𝓝 x) : ∃ t : Finset s, (⋃ x ∈ t, U x.1 x.2) ∈ 𝓝ˢ s 
goal: ∃ t, ⋃ x ∈ t, U ↑x ⋯ ∈ 𝓝ˢ s

full_name: IsCompact.elim_nhds_subcover_nhdsSet
code: lemma IsCompact.elim_nhds_subcover_nhdsSet (hs : IsCompact s) {U : X → Set X}
    (hU : ∀ x ∈ s, U x ∈ 𝓝 x) : ∃ t : Finset X, (∀ x ∈ t, x ∈ s) ∧ (⋃ x ∈ t, U x) ∈ 𝓝ˢ s 
goal: ∃ t, (∀ x ∈ t, x ∈ s) ∧ ⋃ x ∈ t, U x ∈ 𝓝ˢ s

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

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

full_name: IsCompact.disjoint_nhdsSet_left
code: /-- The neighborhood filter of a compact set is disjoint with a filter `l` if and only if the
neighborhood filter of each point of this set is disjoint with `l`. -/
theorem IsCompact.disjoint_nhdsSet_left {l : Filter X} (hs : IsCompact s) :
    Disjoint (𝓝ˢ s) l ↔ ∀ x ∈ s, Disjoint (𝓝 x) l 
goal: Disjoint (𝓝ˢ s) l ↔ ∀ x ∈ s, Disjoint (𝓝 x) l

full_name: IsCompact.disjoint_nhdsSet_right
code: /-- A filter `l` is disjoint with the neighborhood filter of a compact set if and only if it is
disjoint with the neighborhood filter of each point of this set. -/
theorem IsCompact.disjoint_nhdsSet_right {l : Filter X} (hs : IsCompact s) :
    Disjoint l (𝓝ˢ s) ↔ ∀ x ∈ s, Disjoint l (𝓝 x) 
goal: Disjoint l (𝓝ˢ s) ↔ ∀ x ∈ s, Disjoint l (𝓝 x)

full_name: IsCompact.elim_directed_family_closed
code: /-- For every directed family of closed sets whose intersection avoids a compact set,
there exists a single element of the family which itself avoids this compact set. -/
theorem IsCompact.elim_directed_family_closed {ι : Type v} [hι : Nonempty ι] (hs : IsCompact s)
    (t : ι → Set X) (htc : ∀ i, IsClosed (t i)) (hst : (s ∩ ⋂ i, t i) = ∅)
    (hdt : Directed (· ⊇ ·) t) : ∃ i : ι, s ∩ t i = ∅ 
goal: ∃ i, s ∩ t i = ∅

full_name: IsCompact.elim_finite_subfamily_closed
code: /-- For every family of closed sets whose intersection avoids a compact set,
there exists a finite subfamily whose intersection avoids this compact set. -/
theorem IsCompact.elim_finite_subfamily_closed {ι : Type v} (hs : IsCompact s)
    (t : ι → Set X) (htc : ∀ i, IsClosed (t i)) (hst : (s ∩ ⋂ i, t i) = ∅) :
    ∃ u : Finset ι, (s ∩ ⋂ i ∈ u, t i) = ∅ 
goal: ∃ u, s ∩ ⋂ i ∈ u, t i = ∅

full_name: LocallyFinite.finite_nonempty_inter_compact
code: /-- If `s` is a compact set in a topological space `X` and `f : ι → Set X` is a locally finite
family of sets, then `f i ∩ s` is nonempty only for a finitely many `i`. -/
theorem LocallyFinite.finite_nonempty_inter_compact {f : ι → Set X}
    (hf : LocallyFinite f) (hs : IsCompact s) : { i | (f i ∩ s).Nonempty }.Finite 
goal: {i | (f i ∩ s).Nonempty}.Finite

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

full_name: IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed
code: /-- Cantor's intersection theorem for `iInter`:
the intersection of a directed family of nonempty compact closed sets is nonempty. -/
theorem IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed
    {ι : Type v} [hι : Nonempty ι] (t : ι → Set X) (htd : Directed (· ⊇ ·) t)
    (htn : ∀ i, (t i).Nonempty) (htc : ∀ i, IsCompact (t i)) (htcl : ∀ i, IsClosed (t i)) :
    (⋂ i, t i).Nonempty 
goal: (⋂ i, t i).Nonempty

full_name: IsCompact.nonempty_sInter_of_directed_nonempty_isCompact_isClosed
code: /-- Cantor's intersection theorem for `sInter`:
the intersection of a directed family of nonempty compact closed sets is nonempty. -/
theorem IsCompact.nonempty_sInter_of_directed_nonempty_isCompact_isClosed
    {S : Set (Set X)} [hS : Nonempty S] (hSd : DirectedOn (· ⊇ ·) S) (hSn : ∀ U ∈ S, U.Nonempty)
    (hSc : ∀ U ∈ S, IsCompact U) (hScl : ∀ U ∈ S, IsClosed U) : (⋂₀ S).Nonempty 
goal: (⋂₀ S).Nonempty

full_name: IsCompact.nonempty_iInter_of_sequence_nonempty_isCompact_isClosed
code: /-- Cantor's intersection theorem for sequences indexed by `ℕ`:
the intersection of a decreasing sequence of nonempty compact closed sets is nonempty. -/
theorem IsCompact.nonempty_iInter_of_sequence_nonempty_isCompact_isClosed (t : ℕ → Set X)
    (htd : ∀ i, t (i + 1) ⊆ t i) (htn : ∀ i, (t i).Nonempty) (ht0 : IsCompact (t 0))
    (htcl : ∀ i, IsClosed (t i)) : (⋂ i, t i).Nonempty 
goal: (⋂ i, t i).Nonempty

full_name: IsCompact.elim_finite_subcover_image
code: /-- For every open cover of a compact set, there exists a finite subcover. -/
theorem IsCompact.elim_finite_subcover_image {b : Set ι} {c : ι → Set X} (hs : IsCompact s)
    (hc₁ : ∀ i ∈ b, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i ∈ b, c i) :
    ∃ b', b' ⊆ b ∧ Set.Finite b' ∧ s ⊆ ⋃ i ∈ b', c i 
goal: ∃ b' ⊆ b, b'.Finite ∧ s ⊆ ⋃ i ∈ b', c i

full_name: isCompact_of_finite_subcover
code: /-- A set `s` is compact if for every open cover of `s`, there exists a finite subcover. -/
theorem isCompact_of_finite_subcover
    (h : ∀ {ι : Type u} (U : ι → Set X), (∀ i, IsOpen (U i)) → (s ⊆ ⋃ i, U i) →
      ∃ t : Finset ι, s ⊆ ⋃ i ∈ t, U i) :
    IsCompact s 
goal: IsCompact s

full_name: isCompact_of_finite_subfamily_closed
code: /-- A set `s` is compact if for every family of closed sets whose intersection avoids `s`,
there exists a finite subfamily whose intersection avoids `s`. -/
theorem isCompact_of_finite_subfamily_closed
    (h : ∀ {ι : Type u} (t : ι → Set X), (∀ i, IsClosed (t i)) → (s ∩ ⋂ i, t i) = ∅ →
      ∃ u : Finset ι, (s ∩ ⋂ i ∈ u, t i) = ∅) :
    IsCompact s 
goal: IsCompact s

full_name: isCompact_iff_finite_subcover
code: /-- A set `s` is compact if and only if
for every open cover of `s`, there exists a finite subcover. -/
theorem isCompact_iff_finite_subcover :
    IsCompact s ↔ ∀ {ι : Type u} (U : ι → Set X),
      (∀ i, IsOpen (U i)) → (s ⊆ ⋃ i, U i) → ∃ t : Finset ι, s ⊆ ⋃ i ∈ t, U i 
goal: IsCompact s ↔ ∀ {ι : Type u} (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → ∃ t, s ⊆ ⋃ i ∈ t, U i

full_name: isCompact_iff_finite_subfamily_closed
code: /-- A set `s` is compact if and only if
for every family of closed sets whose intersection avoids `s`,
there exists a finite subfamily whose intersection avoids `s`. -/
theorem isCompact_iff_finite_subfamily_closed :
    IsCompact s ↔ ∀ {ι : Type u} (t : ι → Set X),
      (∀ i, IsClosed (t i)) → (s ∩ ⋂ i, t i) = ∅ → ∃ u : Finset ι, (s ∩ ⋂ i ∈ u, t i) = ∅ 
goal: IsCompact s ↔ ∀ {ι : Type u} (t : ι → Set X), (∀ (i : ι), IsClosed (t i)) → s ∩ ⋂ i, t i = ∅ → ∃ u, s ∩ ⋂ i ∈ u, t i = ∅

full_name: IsCompact.mem_nhdsSet_prod_of_forall
code: /-- If `s : Set (X × Y)` belongs to `𝓝 x ×ˢ l` for all `x` from a compact set `K`,
then it belongs to `(𝓝ˢ K) ×ˢ l`,
i.e., there exist an open `U ⊇ K` and `t ∈ l` such that `U ×ˢ t ⊆ s`. -/
theorem IsCompact.mem_nhdsSet_prod_of_forall {K : Set X} {l : Filter Y} {s : Set (X × Y)}
    (hK : IsCompact K) (hs : ∀ x ∈ K, s ∈ 𝓝 x ×ˢ l) : s ∈ (𝓝ˢ K) ×ˢ l 
goal: s ∈ 𝓝ˢ K ×ˢ l

full_name: IsCompact.nhdsSet_prod_eq_biSup
code: theorem IsCompact.nhdsSet_prod_eq_biSup {K : Set X} (hK : IsCompact K) (l : Filter Y) :
    (𝓝ˢ K) ×ˢ l = ⨆ x ∈ K, 𝓝 x ×ˢ l 
goal: 𝓝ˢ K ×ˢ l = ⨆ x ∈ K, 𝓝 x ×ˢ l

full_name: IsCompact.prod_nhdsSet_eq_biSup
code: theorem IsCompact.prod_nhdsSet_eq_biSup {K : Set Y} (hK : IsCompact K) (l : Filter X) :
    l ×ˢ (𝓝ˢ K) = ⨆ y ∈ K, l ×ˢ 𝓝 y 
goal: l ×ˢ 𝓝ˢ K = ⨆ y ∈ K, l ×ˢ 𝓝 y

full_name: IsCompact.mem_prod_nhdsSet_of_forall
code: /-- If `s : Set (X × Y)` belongs to `l ×ˢ 𝓝 y` for all `y` from a compact set `K`,
then it belongs to `l ×ˢ (𝓝ˢ K)`,
i.e., there exist `t ∈ l` and an open `U ⊇ K` such that `t ×ˢ U ⊆ s`. -/
theorem IsCompact.mem_prod_nhdsSet_of_forall {K : Set Y} {l : Filter X} {s : Set (X × Y)}
    (hK : IsCompact K) (hs : ∀ y ∈ K, s ∈ l ×ˢ 𝓝 y) : s ∈ l ×ˢ 𝓝ˢ K 
goal: s ∈ l ×ˢ 𝓝ˢ K

full_name: IsCompact.nhdsSet_inf_eq_biSup
code: theorem IsCompact.nhdsSet_inf_eq_biSup {K : Set X} (hK : IsCompact K) (l : Filter X) :
    (𝓝ˢ K) ⊓ l = ⨆ x ∈ K, 𝓝 x ⊓ l 
goal: 𝓝ˢ K ⊓ l = ⨆ x ∈ K, 𝓝 x ⊓ l

full_name: IsCompact.inf_nhdsSet_eq_biSup
code: theorem IsCompact.inf_nhdsSet_eq_biSup {K : Set X} (hK : IsCompact K) (l : Filter X) :
    l ⊓ (𝓝ˢ K) = ⨆ x ∈ K, l ⊓ 𝓝 x 
goal: l ⊓ 𝓝ˢ K = ⨆ x ∈ K, l ⊓ 𝓝 x

full_name: IsCompact.mem_nhdsSet_inf_of_forall
code: /-- If `s : Set X` belongs to `𝓝 x ⊓ l` for all `x` from a compact set `K`,
then it belongs to `(𝓝ˢ K) ⊓ l`,
i.e., there exist an open `U ⊇ K` and `T ∈ l` such that `U ∩ T ⊆ s`. -/
theorem IsCompact.mem_nhdsSet_inf_of_forall {K : Set X} {l : Filter X} {s : Set X}
    (hK : IsCompact K) (hs : ∀ x ∈ K, s ∈ 𝓝 x ⊓ l) : s ∈ (𝓝ˢ K) ⊓ l 
goal: s ∈ 𝓝ˢ K ⊓ l

full_name: IsCompact.mem_inf_nhdsSet_of_forall
code: /-- If `s : Set S` belongs to `l ⊓ 𝓝 x` for all `x` from a compact set `K`,
then it belongs to `l ⊓ (𝓝ˢ K)`,
i.e., there exist `T ∈ l` and an open `U ⊇ K` such that `T ∩ U ⊆ s`. -/
theorem IsCompact.mem_inf_nhdsSet_of_forall {K : Set X} {l : Filter X} {s : Set X}
    (hK : IsCompact K) (hs : ∀ y ∈ K, s ∈ l ⊓ 𝓝 y) : s ∈ l ⊓ 𝓝ˢ K 
goal: s ∈ l ⊓ 𝓝ˢ K

full_name: IsCompact.eventually_forall_of_forall_eventually
code: /-- To show that `∀ y ∈ K, P x y` holds for `x` close enough to `x₀` when `K` is compact,
it is sufficient to show that for all `y₀ ∈ K` there `P x y` holds for `(x, y)` close enough
to `(x₀, y₀)`.

Provided for backwards compatibility,
see `IsCompact.mem_prod_nhdsSet_of_forall` for a stronger statement.
-/
theorem IsCompact.eventually_forall_of_forall_eventually {x₀ : X} {K : Set Y} (hK : IsCompact K)
    {P : X → Y → Prop} (hP : ∀ y ∈ K, ∀ᶠ z : X × Y in 𝓝 (x₀, y), P z.1 z.2) :
    ∀ᶠ x in 𝓝 x₀, ∀ y ∈ K, P x y 
goal: ∀ᶠ (x : X) in 𝓝 x₀, ∀ y ∈ K, P x y

full_name: isCompact_empty
code: @[simp]
theorem isCompact_empty : IsCompact (∅ : Set X) 
goal: IsCompact ∅

full_name: isCompact_singleton
code: @[simp]
theorem isCompact_singleton {x : X} : IsCompact ({x} : Set X) 
goal: IsCompact {x}

full_name: Set.Subsingleton.isCompact
code: theorem Set.Subsingleton.isCompact (hs : s.Subsingleton) : IsCompact s 
goal: IsCompact s

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

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

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

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

full_name: isCompact_iUnion
code: theorem isCompact_iUnion {ι : Sort*} {f : ι → Set X} [Finite ι] (h : ∀ i, IsCompact (f i)) :
    IsCompact (⋃ i, f i) 
goal: IsCompact (⋃ i, f i)

full_name: Set.Finite.isCompact
code: theorem Set.Finite.isCompact (hs : s.Finite) : IsCompact s 
goal: IsCompact s

full_name: IsCompact.finite_of_discrete
code: theorem IsCompact.finite_of_discrete [DiscreteTopology X] (hs : IsCompact s) : s.Finite 
goal: s.Finite

full_name: isCompact_iff_finite
code: theorem isCompact_iff_finite [DiscreteTopology X] : IsCompact s ↔ s.Finite 
goal: IsCompact s ↔ s.Finite

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

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

full_name: exists_subset_nhds_of_isCompact'
code: /-- If `V : ι → Set X` is a decreasing family of closed compact sets then any neighborhood of
`⋂ i, V i` contains some `V i`. We assume each `V i` is compact *and* closed because `X` is
not assumed to be Hausdorff. See `exists_subset_nhd_of_compact` for version assuming this. -/
theorem exists_subset_nhds_of_isCompact' [Nonempty ι] {V : ι → Set X}
    (hV : Directed (· ⊇ ·) V) (hV_cpct : ∀ i, IsCompact (V i)) (hV_closed : ∀ i, IsClosed (V i))
    {U : Set X} (hU : ∀ x ∈ ⋂ i, V i, U ∈ 𝓝 x) : ∃ i, V i ⊆ U 
goal: ∃ i, V i ⊆ U

full_name: eq_finite_iUnion_of_isTopologicalBasis_of_isCompact_open
code: lemma eq_finite_iUnion_of_isTopologicalBasis_of_isCompact_open (b : ι → Set X)
    (hb : IsTopologicalBasis (Set.range b)) (U : Set X) (hUc : IsCompact U) (hUo : IsOpen U) :
    ∃ s : Set ι, s.Finite ∧ U = ⋃ i ∈ s, b i 
goal: ∃ s, s.Finite ∧ U = ⋃ i ∈ s, b i

full_name: eq_sUnion_finset_of_isTopologicalBasis_of_isCompact_open
code: lemma eq_sUnion_finset_of_isTopologicalBasis_of_isCompact_open (b : Set (Set X))
    (hb : IsTopologicalBasis b) (U : Set X) (hUc : IsCompact U) (hUo : IsOpen U) :
    ∃ s : Finset b, U = s.toSet.sUnion 
goal: ∃ s, U = ⋃₀ (Subtype.val '' ↑s)

full_name: isCompact_open_iff_eq_finite_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 isCompact_open_iff_eq_finite_iUnion_of_isTopologicalBasis (b : ι → Set X)
    (hb : IsTopologicalBasis (Set.range b)) (hb' : ∀ i, IsCompact (b i)) (U : Set X) :
    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: Filter.hasBasis_cocompact
code: theorem hasBasis_cocompact : (cocompact X).HasBasis IsCompact compl 
goal: (Filter.cocompact X).HasBasis IsCompact compl

full_name: Filter.mem_cocompact
code: theorem mem_cocompact : s ∈ cocompact X ↔ ∃ t, IsCompact t ∧ tᶜ ⊆ s 
goal: s ∈ Filter.cocompact X ↔ ∃ t, IsCompact t ∧ tᶜ ⊆ s

full_name: Filter.mem_cocompact'
code: theorem mem_cocompact' : s ∈ cocompact X ↔ ∃ t, IsCompact t ∧ sᶜ ⊆ t 
goal: s ∈ Filter.cocompact X ↔ ∃ t, IsCompact t ∧ sᶜ ⊆ t

full_name: IsCompact.compl_mem_cocompact
code: theorem _root_.IsCompact.compl_mem_cocompact (hs : IsCompact s) : sᶜ ∈ Filter.cocompact X 
goal: sᶜ ∈ Filter.cocompact X

full_name: Filter.cocompact_le_cofinite
code: theorem cocompact_le_cofinite : cocompact X ≤ cofinite 
goal: Filter.cocompact X ≤ Filter.cofinite

full_name: Filter.cocompact_eq_cofinite
code: theorem cocompact_eq_cofinite (X : Type*) [TopologicalSpace X] [DiscreteTopology X] :
    cocompact X = cofinite 
goal: Filter.cocompact X = Filter.cofinite

full_name: Filter.disjoint_cocompact_left
code: /-- A filter is disjoint from the cocompact filter if and only if it contains a compact set. -/
theorem disjoint_cocompact_left (f : Filter X) :
    Disjoint (Filter.cocompact X) f ↔ ∃ K ∈ f, IsCompact K 
goal: Disjoint (Filter.cocompact X) f ↔ ∃ K ∈ f, IsCompact K

full_name: Filter.disjoint_cocompact_right
code: /-- A filter is disjoint from the cocompact filter if and only if it contains a compact set. -/
theorem disjoint_cocompact_right (f : Filter X) :
    Disjoint f (Filter.cocompact X) ↔ ∃ K ∈ f, IsCompact K 
goal: Disjoint f (Filter.cocompact X) ↔ ∃ K ∈ f, IsCompact K

full_name: Nat.cocompact_eq
code: @[deprecated "see `cocompact_eq_atTop` with `import Mathlib.Topology.Instances.Nat`"
  (since := "2024-02-07")]
theorem _root_.Nat.cocompact_eq : cocompact ℕ = atTop 
goal: Filter.cocompact ℕ = Filter.atTop

full_name: Filter.Tendsto.isCompact_insert_range_of_cocompact
code: theorem Tendsto.isCompact_insert_range_of_cocompact {f : X → Y} {y}
    (hf : Tendsto f (cocompact X) (𝓝 y)) (hfc : Continuous f) : IsCompact (insert y (range f)) 
goal: IsCompact (insert y (Set.range f))

full_name: Filter.Tendsto.isCompact_insert_range_of_cofinite
code: theorem Tendsto.isCompact_insert_range_of_cofinite {f : ι → X} {x} (hf : Tendsto f cofinite (𝓝 x)) :
    IsCompact (insert x (range f)) 
goal: IsCompact (insert x (Set.range f))

full_name: Filter.Tendsto.isCompact_insert_range
code: theorem Tendsto.isCompact_insert_range {f : ℕ → X} {x} (hf : Tendsto f atTop (𝓝 x)) :
    IsCompact (insert x (range f)) 
goal: IsCompact (insert x (Set.range f))

full_name: Filter.hasBasis_coclosedCompact
code: theorem hasBasis_coclosedCompact :
    (Filter.coclosedCompact X).HasBasis (fun s => IsClosed s ∧ IsCompact s) compl 
goal: (Filter.coclosedCompact X).HasBasis (fun s => IsClosed s ∧ IsCompact s) compl

full_name: Filter.mem_coclosedCompact_iff
code: /-- A set belongs to `coclosedCompact` if and only if the closure of its complement is compact. -/
theorem mem_coclosedCompact_iff :
    s ∈ coclosedCompact X ↔ IsCompact (closure sᶜ) 
goal: s ∈ Filter.coclosedCompact X ↔ IsCompact (closure sᶜ)

full_name: Filter.mem_coclosedCompact
code: @[deprecated mem_coclosedCompact_iff (since := "2024-02-16")]
theorem mem_coclosedCompact : s ∈ coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ s 
goal: s ∈ Filter.coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ s

full_name: Filter.mem_coclosed_compact'
code: @[deprecated mem_coclosedCompact_iff (since := "2024-02-16")]
theorem mem_coclosed_compact' : s ∈ coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ sᶜ ⊆ t 
goal: s ∈ Filter.coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ sᶜ ⊆ t

full_name: Filter.compl_mem_coclosedCompact
code: /-- Complement of a set belongs to `coclosedCompact` if and only if its closure is compact. -/
theorem compl_mem_coclosedCompact : sᶜ ∈ coclosedCompact X ↔ IsCompact (closure s) 
goal: sᶜ ∈ Filter.coclosedCompact X ↔ IsCompact (closure s)

full_name: Filter.cocompact_le_coclosedCompact
code: theorem cocompact_le_coclosedCompact : cocompact X ≤ coclosedCompact X 
goal: Filter.cocompact X ≤ Filter.coclosedCompact X

full_name: IsCompact.compl_mem_coclosedCompact_of_isClosed
code: theorem IsCompact.compl_mem_coclosedCompact_of_isClosed (hs : IsCompact s) (hs' : IsClosed s) :
    sᶜ ∈ Filter.coclosedCompact X 
goal: sᶜ ∈ Filter.coclosedCompact X

full_name: Bornology.inCompact
code: /-- Sets that are contained in a compact set form a bornology. Its `cobounded` filter is
`Filter.cocompact`. See also `Bornology.relativelyCompact` the bornology of sets with compact
closure. -/
def inCompact : Bornology X 
goal: Bornology X

full_name: Bornology.inCompact.isBounded_iff
code: theorem inCompact.isBounded_iff : @IsBounded _ (inCompact X) s ↔ ∃ t, IsCompact t ∧ s ⊆ t 
goal: Bornology.IsBounded s ↔ ∃ t, IsCompact t ∧ s ⊆ t

full_name: IsCompact.nhdsSet_prod_eq
code: /-- If `s` and `t` are compact sets, then the set neighborhoods filter of `s ×ˢ t`
is the product of set neighborhoods filters for `s` and `t`.

For general sets, only the `≤` inequality holds, see `nhdsSet_prod_le`. -/
theorem IsCompact.nhdsSet_prod_eq {t : Set Y} (hs : IsCompact s) (ht : IsCompact t) :
    𝓝ˢ (s ×ˢ t) = 𝓝ˢ s ×ˢ 𝓝ˢ t 
goal: 𝓝ˢ (s ×ˢ t) = 𝓝ˢ s ×ˢ 𝓝ˢ t

full_name: nhdsSet_prod_le_of_disjoint_cocompact
code: theorem nhdsSet_prod_le_of_disjoint_cocompact {f : Filter Y} (hs : IsCompact s)
    (hf : Disjoint f (Filter.cocompact Y)) :
    𝓝ˢ s ×ˢ f ≤ 𝓝ˢ (s ×ˢ Set.univ) 
goal: 𝓝ˢ s ×ˢ f ≤ 𝓝ˢ (s ×ˢ Set.univ)

full_name: prod_nhdsSet_le_of_disjoint_cocompact
code: theorem prod_nhdsSet_le_of_disjoint_cocompact {f : Filter X} (ht : IsCompact t)
    (hf : Disjoint f (Filter.cocompact X)) :
    f ×ˢ 𝓝ˢ t ≤ 𝓝ˢ (Set.univ ×ˢ t) 
goal: f ×ˢ 𝓝ˢ t ≤ 𝓝ˢ (Set.univ ×ˢ t)

full_name: generalized_tube_lemma
code: /-- If `s` and `t` are compact sets and `n` is an open neighborhood of `s × t`, then there exist
open neighborhoods `u ⊇ s` and `v ⊇ t` such that `u × v ⊆ n`.

See also `IsCompact.nhdsSet_prod_eq`. -/
theorem generalized_tube_lemma (hs : IsCompact s) {t : Set Y} (ht : IsCompact t)
    {n : Set (X × Y)} (hn : IsOpen n) (hp : s ×ˢ t ⊆ n) :
    ∃ (u : Set X) (v : Set Y), IsOpen u ∧ IsOpen v ∧ s ⊆ u ∧ t ⊆ v ∧ u ×ˢ v ⊆ n 
goal: ∃ u v, IsOpen u ∧ IsOpen v ∧ s ⊆ u ∧ t ⊆ v ∧ u ×ˢ v ⊆ n

full_name: Subsingleton.compactSpace
code: instance (priority := 10) Subsingleton.compactSpace [Subsingleton X] : CompactSpace X 
goal: CompactSpace X

full_name: isCompact_univ_iff
code: theorem isCompact_univ_iff : IsCompact (univ : Set X) ↔ CompactSpace X 
goal: IsCompact Set.univ ↔ CompactSpace X

full_name: isCompact_univ
code: theorem isCompact_univ [h : CompactSpace X] : IsCompact (univ : Set X) 
goal: IsCompact Set.univ

full_name: exists_clusterPt_of_compactSpace
code: theorem exists_clusterPt_of_compactSpace [CompactSpace X] (f : Filter X) [NeBot f] :
    ∃ x, ClusterPt x f 
goal: ∃ x, ClusterPt x f

full_name: Ultrafilter.le_nhds_lim
code: nonrec theorem Ultrafilter.le_nhds_lim [CompactSpace X] (F : Ultrafilter X) : ↑F ≤ 𝓝 F.lim 
goal: ↑F ≤ 𝓝 F.lim

full_name: CompactSpace.elim_nhds_subcover
code: theorem CompactSpace.elim_nhds_subcover [CompactSpace X] (U : X → Set X) (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Finset X, ⋃ x ∈ t, U x = ⊤ 
goal: ∃ t, ⋃ x ∈ t, U x = ⊤

full_name: compactSpace_of_finite_subfamily_closed
code: theorem compactSpace_of_finite_subfamily_closed
    (h : ∀ {ι : Type u} (t : ι → Set X), (∀ i, IsClosed (t i)) → ⋂ i, t i = ∅ →
      ∃ u : Finset ι, ⋂ i ∈ u, t i = ∅) :
    CompactSpace X 
goal: CompactSpace X

full_name: IsClosed.isCompact
code: theorem IsClosed.isCompact [CompactSpace X] (h : IsClosed s) : IsCompact s 
goal: IsCompact s

full_name: le_nhds_of_unique_clusterPt
code: /-- If a filter has a unique cluster point `y` in a compact topological space,
then the filter is less than or equal to `𝓝 y`. -/
lemma le_nhds_of_unique_clusterPt [CompactSpace X] {l : Filter X} {y : X}
    (h : ∀ x, ClusterPt x l → x = y) : l ≤ 𝓝 y 
goal: l ≤ 𝓝 y

full_name: tendsto_nhds_of_unique_mapClusterPt
code: /-- If `y` is a unique `MapClusterPt` for `f` along `l`
and the codomain of `f` is a compact space,
then `f` tends to `𝓝 y` along `l`. -/
lemma tendsto_nhds_of_unique_mapClusterPt [CompactSpace X] {l : Filter Y} {y : X} {f : Y → X}
    (h : ∀ x, MapClusterPt x l f → x = y) :
    Tendsto f l (𝓝 y) 
goal: Filter.Tendsto f l (𝓝 y)

full_name: noncompact_univ
code: lemma noncompact_univ (X : Type*) [TopologicalSpace X] [NoncompactSpace X] :
    ¬IsCompact (univ : Set X) 
goal: ¬IsCompact Set.univ

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

full_name: instNeBotCocompactOfNoncompactSpace
code: instance [NoncompactSpace X] : NeBot (Filter.cocompact X) 
goal: (Filter.cocompact X).NeBot

full_name: Filter.cocompact_eq_bot
code: @[simp]
theorem Filter.cocompact_eq_bot [CompactSpace X] : Filter.cocompact X = ⊥ 
goal: Filter.cocompact X = ⊥

full_name: instNeBotCoclosedCompactOfNoncompactSpace
code: instance [NoncompactSpace X] : NeBot (Filter.coclosedCompact X) 
goal: (Filter.coclosedCompact X).NeBot

full_name: noncompactSpace_of_neBot
code: theorem noncompactSpace_of_neBot (_ : NeBot (Filter.cocompact X)) : NoncompactSpace X 
goal: (Filter.cocompact X).NeBot → NoncompactSpace X

full_name: Filter.cocompact_neBot_iff
code: theorem Filter.cocompact_neBot_iff : NeBot (Filter.cocompact X) ↔ NoncompactSpace X 
goal: (Filter.cocompact X).NeBot ↔ NoncompactSpace X

full_name: not_compactSpace_iff
code: theorem not_compactSpace_iff : ¬CompactSpace X ↔ NoncompactSpace X 
goal: ¬CompactSpace X ↔ NoncompactSpace X

full_name: instNoncompactSpaceInt
code: instance : NoncompactSpace ℤ 
goal: NoncompactSpace ℤ

full_name: finite_of_compact_of_discrete
code: /-- A compact discrete space is finite. -/
theorem finite_of_compact_of_discrete [CompactSpace X] [DiscreteTopology X] : Finite X 
goal: Finite X

full_name: Set.Infinite.exists_accPt_cofinite_inf_principal_of_subset_isCompact
code: lemma Set.Infinite.exists_accPt_cofinite_inf_principal_of_subset_isCompact
    {K : Set X} (hs : s.Infinite) (hK : IsCompact K) (hsub : s ⊆ K) :
    ∃ x ∈ K, AccPt x (cofinite ⊓ 𝓟 s) 
goal: ∃ x ∈ K, AccPt x (Filter.cofinite ⊓ 𝓟 s)

full_name: Set.Infinite.exists_accPt_of_subset_isCompact
code: lemma Set.Infinite.exists_accPt_of_subset_isCompact {K : Set X} (hs : s.Infinite)
    (hK : IsCompact K) (hsub : s ⊆ K) : ∃ x ∈ K, AccPt x (𝓟 s) 
goal: ∃ x ∈ K, AccPt x (𝓟 s)

full_name: Set.Infinite.exists_accPt_cofinite_inf_principal
code: lemma Set.Infinite.exists_accPt_cofinite_inf_principal [CompactSpace X] (hs : s.Infinite) :
    ∃ x, AccPt x (cofinite ⊓ 𝓟 s) 
goal: ∃ x, AccPt x (Filter.cofinite ⊓ 𝓟 s)

full_name: Set.Infinite.exists_accPt_principal
code: lemma Set.Infinite.exists_accPt_principal [CompactSpace X] (hs : s.Infinite) : ∃ x, AccPt x (𝓟 s) 
goal: ∃ x, AccPt x (𝓟 s)

full_name: exists_nhds_ne_neBot
code: theorem exists_nhds_ne_neBot (X : Type*) [TopologicalSpace X] [CompactSpace X] [Infinite X] :
    ∃ z : X, (𝓝[≠] z).NeBot 
goal: ∃ z, (𝓝[≠] z).NeBot

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

full_name: finite_cover_nhds
code: theorem finite_cover_nhds [CompactSpace X] {U : X → Set X} (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Finset X, ⋃ x ∈ t, U x = univ 
goal: ∃ t, ⋃ x ∈ t, U x = Set.univ

full_name: LocallyFinite.finite_nonempty_of_compact
code: /-- If `X` is a compact space, then a locally finite family of sets of `X` can have only finitely
many nonempty elements. -/
theorem LocallyFinite.finite_nonempty_of_compact [CompactSpace X] {f : ι → Set X}
    (hf : LocallyFinite f) : { i | (f i).Nonempty }.Finite 
goal: {i | (f i).Nonempty}.Finite

full_name: LocallyFinite.finite_of_compact
code: /-- If `X` is a compact space, then a locally finite family of nonempty sets of `X` can have only
finitely many elements, `Set.Finite` version. -/
theorem LocallyFinite.finite_of_compact [CompactSpace X] {f : ι → Set X}
    (hf : LocallyFinite f) (hne : ∀ i, (f i).Nonempty) : (univ : Set ι).Finite 
goal: Set.univ.Finite

full_name: LocallyFinite.fintypeOfCompact
code: /-- If `X` is a compact space, then a locally finite family of nonempty sets of `X` can have only
finitely many elements, `Fintype` version. -/
noncomputable def LocallyFinite.fintypeOfCompact [CompactSpace X] {f : ι → Set X}
    (hf : LocallyFinite f) (hne : ∀ i, (f i).Nonempty) : Fintype ι 
goal: Fintype ι

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

full_name: isCompact_range
code: theorem isCompact_range [CompactSpace X] {f : X → Y} (hf : Continuous f) : IsCompact (range f) 
goal: IsCompact (Set.range f)

full_name: isCompact_diagonal
code: theorem isCompact_diagonal [CompactSpace X] : IsCompact (diagonal X) 
goal: IsCompact (Set.diagonal X)

full_name: isClosedMap_snd_of_compactSpace
code: /-- If `X` is a compact topological space, then `Prod.snd : X × Y → Y` is a closed map. -/
theorem isClosedMap_snd_of_compactSpace [CompactSpace X] :
    IsClosedMap (Prod.snd : X × Y → Y) 
goal: IsClosedMap Prod.snd

full_name: isClosedMap_fst_of_compactSpace
code: /-- If `Y` is a compact topological space, then `Prod.fst : X × Y → X` is a closed map. -/
theorem isClosedMap_fst_of_compactSpace [CompactSpace Y] : IsClosedMap (Prod.fst : X × Y → X) 
goal: IsClosedMap Prod.fst

full_name: exists_subset_nhds_of_compactSpace
code: theorem exists_subset_nhds_of_compactSpace [CompactSpace X] [Nonempty ι]
    {V : ι → Set X} (hV : Directed (· ⊇ ·) V) (hV_closed : ∀ i, IsClosed (V i)) {U : Set X}
    (hU : ∀ x ∈ ⋂ i, V i, U ∈ 𝓝 x) : ∃ i, V i ⊆ U 
goal: ∃ i, V i ⊆ U

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

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

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

full_name: Inducing.isCompact_preimage_iff
code: lemma Inducing.isCompact_preimage_iff {f : X → Y} (hf : Inducing f) {K : Set Y}
    (Kf : K ⊆ range f) : IsCompact (f ⁻¹' K) ↔ IsCompact K 
goal: IsCompact (f ⁻¹' K) ↔ IsCompact K

full_name: Inducing.isCompact_preimage'
code: /-- The preimage of a compact set in the image of an inducing map is compact. -/
lemma Inducing.isCompact_preimage' {f : X → Y} (hf : Inducing f) {K : Set Y}
    (hK : IsCompact K) (Kf : K ⊆ range f) : IsCompact (f ⁻¹' K) 
goal: IsCompact (f ⁻¹' K)

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

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

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

full_name: isCompact_iff_isCompact_univ
code: theorem isCompact_iff_isCompact_univ : IsCompact s ↔ IsCompact (univ : Set s) 
goal: IsCompact s ↔ IsCompact Set.univ

full_name: isCompact_iff_compactSpace
code: theorem isCompact_iff_compactSpace : IsCompact s ↔ CompactSpace s 
goal: IsCompact s ↔ CompactSpace ↑s

full_name: IsCompact.finite
code: theorem IsCompact.finite (hs : IsCompact s) (hs' : DiscreteTopology s) : s.Finite 
goal: s.Finite

full_name: exists_nhds_ne_inf_principal_neBot
code: theorem exists_nhds_ne_inf_principal_neBot (hs : IsCompact s) (hs' : s.Infinite) :
    ∃ z ∈ s, (𝓝[≠] z ⊓ 𝓟 s).NeBot 
goal: ∃ z ∈ s, (𝓝[≠] z ⊓ 𝓟 s).NeBot

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

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

full_name: IsCompact.prod
code: theorem IsCompact.prod {t : Set Y} (hs : IsCompact s) (ht : IsCompact t) :
    IsCompact (s ×ˢ t) 
goal: IsCompact (s ×ˢ t)

full_name: Finite.compactSpace
code: /-- Finite topological spaces are compact. -/
instance (priority := 100) Finite.compactSpace [Finite X] : CompactSpace X 
goal: CompactSpace X

full_name: ULift.compactSpace
code: instance ULift.compactSpace [CompactSpace X] : CompactSpace (ULift.{v} X) 
goal: CompactSpace (ULift.{v, u} X)

full_name: instCompactSpaceProd
code: /-- The product of two compact spaces is compact. -/
instance [CompactSpace X] [CompactSpace Y] : CompactSpace (X × Y) 
goal: CompactSpace (X × Y)

full_name: instCompactSpaceSum
code: /-- The disjoint union of two compact spaces is compact. -/
instance [CompactSpace X] [CompactSpace Y] : CompactSpace (X ⊕ Y) 
goal: CompactSpace (X ⊕ Y)

full_name: instCompactSpaceSigmaOfFinite
code: instance {X : ι → Type*} [Finite ι] [∀ i, TopologicalSpace (X i)] [∀ i, CompactSpace (X i)] :
    CompactSpace (Σi, X i) 
goal: CompactSpace ((i : ι) × X i)

full_name: Filter.coprod_cocompact
code: /-- The coproduct of the cocompact filters on two topological spaces is the cocompact filter on
their product. -/
theorem Filter.coprod_cocompact :
    (Filter.cocompact X).coprod (Filter.cocompact Y) = Filter.cocompact (X × Y) 
goal: (Filter.cocompact X).coprod (Filter.cocompact Y) = Filter.cocompact (X × Y)

full_name: Prod.noncompactSpace_iff
code: theorem Prod.noncompactSpace_iff :
    NoncompactSpace (X × Y) ↔ NoncompactSpace X ∧ Nonempty Y ∨ Nonempty X ∧ NoncompactSpace Y 
goal: NoncompactSpace (X × Y) ↔ NoncompactSpace X ∧ Nonempty Y ∨ Nonempty X ∧ NoncompactSpace Y

full_name: Prod.noncompactSpace_left
code: instance (priority := 100) Prod.noncompactSpace_left [NoncompactSpace X] [Nonempty Y] :
    NoncompactSpace (X × Y) 
goal: NoncompactSpace (X × Y)

full_name: Prod.noncompactSpace_right
code: instance (priority := 100) Prod.noncompactSpace_right [Nonempty X] [NoncompactSpace Y] :
    NoncompactSpace (X × Y) 
goal: NoncompactSpace (X × Y)

full_name: isCompact_pi_infinite
code: /-- **Tychonoff's theorem**: product of compact sets is compact. -/
theorem isCompact_pi_infinite {s : ∀ i, Set (X i)} :
    (∀ i, IsCompact (s i)) → IsCompact { x : ∀ i, X i | ∀ i, x i ∈ s i } 
goal: (∀ (i : ι), IsCompact (s i)) → IsCompact {x | ∀ (i : ι), x i ∈ s i}

full_name: isCompact_univ_pi
code: /-- **Tychonoff's theorem** formulated using `Set.pi`: product of compact sets is compact. -/
theorem isCompact_univ_pi {s : ∀ i, Set (X i)} (h : ∀ i, IsCompact (s i)) :
    IsCompact (pi univ s) 
goal: IsCompact (Set.univ.pi s)

full_name: Pi.compactSpace
code: instance Pi.compactSpace [∀ i, CompactSpace (X i)] : CompactSpace (∀ i, X i) 
goal: CompactSpace ((i : ι) → X i)

full_name: Function.compactSpace
code: instance Function.compactSpace [CompactSpace Y] : CompactSpace (ι → Y) 
goal: CompactSpace (ι → Y)

full_name: Pi.isCompact_iff_of_isClosed
code: lemma Pi.isCompact_iff_of_isClosed {s : Set (Π i, X i)} (hs : IsClosed s) :
    IsCompact s ↔ ∀ i, IsCompact (eval i '' s) 
goal: IsCompact s ↔ ∀ (i : ι), IsCompact (Function.eval i '' s)

full_name: Pi.exists_compact_superset_iff
code: protected lemma Pi.exists_compact_superset_iff {s : Set (Π i, X i)} :
    (∃ K, IsCompact K ∧ s ⊆ K) ↔ ∀ i, ∃ Ki, IsCompact Ki ∧ s ⊆ eval i ⁻¹' Ki 
goal: (∃ K, IsCompact K ∧ s ⊆ K) ↔ ∀ (i : ι), ∃ Ki, IsCompact Ki ∧ s ⊆ Function.eval i ⁻¹' Ki

full_name: Filter.coprodᵢ_cocompact
code: /-- **Tychonoff's theorem** formulated in terms of filters: `Filter.cocompact` on an indexed product
type `Π d, X d` the `Filter.coprodᵢ` of filters `Filter.cocompact` on `X d`. -/
theorem Filter.coprodᵢ_cocompact {X : ι → Type*} [∀ d, TopologicalSpace (X d)] :
    (Filter.coprodᵢ fun d => Filter.cocompact (X d)) = Filter.cocompact (∀ d, X d) 
goal: (Filter.coprodᵢ fun d => Filter.cocompact (X d)) = Filter.cocompact ((d : ι) → X d)

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

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

full_name: IsClosed.exists_minimal_nonempty_closed_subset
code: theorem IsClosed.exists_minimal_nonempty_closed_subset [CompactSpace X] {S : Set X}
    (hS : IsClosed S) (hne : S.Nonempty) :
    ∃ V : Set X, V ⊆ S ∧ V.Nonempty ∧ IsClosed V ∧
      ∀ V' : Set X, V' ⊆ V → V'.Nonempty → IsClosed V' → V' = V 
goal: ∃ V ⊆ S, V.Nonempty ∧ IsClosed V ∧ ∀ V' ⊆ V, V'.Nonempty → IsClosed V' → V' = V