File: Mathlib/Topology/UniformSpace/Cauchy.lean

full_name: Cauchy
code: /-- A filter `f` is Cauchy if for every entourage `r`, there exists an
  `s ∈ f` such that `s × s ⊆ r`. This is a generalization of Cauchy
  sequences, because if `a : ℕ → α` then the filter of sets containing
  cofinitely many of the `a n` is Cauchy iff `a` is a Cauchy sequence. -/
def Cauchy (f : Filter α) 
goal: Prop

full_name: IsComplete
code: /-- A set `s` is called *complete*, if any Cauchy filter `f` such that `s ∈ f`
has a limit in `s` (formally, it satisfies `f ≤ 𝓝 x` for some `x ∈ s`). -/
def IsComplete (s : Set α) 
goal: Prop

full_name: Filter.HasBasis.cauchy_iff
code: theorem Filter.HasBasis.cauchy_iff {ι} {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s)
    {f : Filter α} :
    Cauchy f ↔ NeBot f ∧ ∀ i, p i → ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s i 
goal: Cauchy f ↔ f.NeBot ∧ ∀ (i : ι), p i → ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s i

full_name: cauchy_iff'
code: theorem cauchy_iff' {f : Filter α} :
    Cauchy f ↔ NeBot f ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s 
goal: Cauchy f ↔ f.NeBot ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s

full_name: cauchy_iff
code: theorem cauchy_iff {f : Filter α} : Cauchy f ↔ NeBot f ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s 
goal: Cauchy f ↔ f.NeBot ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s

full_name: cauchy_iff_le
code: lemma cauchy_iff_le {l : Filter α} [hl : l.NeBot] :
    Cauchy l ↔ l ×ˢ l ≤ 𝓤 α 
goal: Cauchy l ↔ l ×ˢ l ≤ 𝓤 α

full_name: Cauchy.ultrafilter_of
code: theorem Cauchy.ultrafilter_of {l : Filter α} (h : Cauchy l) :
    Cauchy (@Ultrafilter.of _ l h.1 : Filter α) 
goal: Cauchy ↑(Ultrafilter.of l)

full_name: cauchy_map_iff
code: theorem cauchy_map_iff {l : Filter β} {f : β → α} :
    Cauchy (l.map f) ↔ NeBot l ∧ Tendsto (fun p : β × β => (f p.1, f p.2)) (l ×ˢ l) (𝓤 α) 
goal: Cauchy (Filter.map f l) ↔ l.NeBot ∧ Filter.Tendsto (fun p => (f p.1, f p.2)) (l ×ˢ l) (𝓤 α)

full_name: cauchy_map_iff'
code: theorem cauchy_map_iff' {l : Filter β} [hl : NeBot l] {f : β → α} :
    Cauchy (l.map f) ↔ Tendsto (fun p : β × β => (f p.1, f p.2)) (l ×ˢ l) (𝓤 α) 
goal: Cauchy (Filter.map f l) ↔ Filter.Tendsto (fun p => (f p.1, f p.2)) (l ×ˢ l) (𝓤 α)

full_name: Cauchy.mono
code: theorem Cauchy.mono {f g : Filter α} [hg : NeBot g] (h_c : Cauchy f) (h_le : g ≤ f) : Cauchy g 
goal: Cauchy g

full_name: Cauchy.mono'
code: theorem Cauchy.mono' {f g : Filter α} (h_c : Cauchy f) (_ : NeBot g) (h_le : g ≤ f) : Cauchy g 
goal: g.NeBot → g ≤ f → Cauchy g

full_name: cauchy_nhds
code: theorem cauchy_nhds {a : α} : Cauchy (𝓝 a) 
goal: Cauchy (𝓝 a)

full_name: cauchy_pure
code: theorem cauchy_pure {a : α} : Cauchy (pure a) 
goal: Cauchy (pure a)

full_name: Filter.Tendsto.cauchy_map
code: theorem Filter.Tendsto.cauchy_map {l : Filter β} [NeBot l] {f : β → α} {a : α}
    (h : Tendsto f l (𝓝 a)) : Cauchy (map f l) 
goal: Cauchy (Filter.map f l)

full_name: Cauchy.mono_uniformSpace
code: lemma Cauchy.mono_uniformSpace {u v : UniformSpace β} {F : Filter β} (huv : u ≤ v)
    (hF : Cauchy (uniformSpace := u) F) : Cauchy (uniformSpace := v) F 
goal: Cauchy F

full_name: cauchy_inf_uniformSpace
code: lemma cauchy_inf_uniformSpace {u v : UniformSpace β} {F : Filter β} :
    Cauchy (uniformSpace := u ⊓ v) F ↔
    Cauchy (uniformSpace := u) F ∧ Cauchy (uniformSpace := v) F 
goal: Cauchy F ↔ Cauchy F ∧ Cauchy F

full_name: cauchy_iInf_uniformSpace
code: lemma cauchy_iInf_uniformSpace {ι : Sort*} [Nonempty ι] {u : ι → UniformSpace β}
    {l : Filter β} :
    Cauchy (uniformSpace := ⨅ i, u i) l ↔ ∀ i, Cauchy (uniformSpace := u i) l 
goal: Cauchy l ↔ ∀ (i : ι), Cauchy l

full_name: cauchy_iInf_uniformSpace'
code: lemma cauchy_iInf_uniformSpace' {ι : Sort*} {u : ι → UniformSpace β}
    {l : Filter β} [l.NeBot] :
    Cauchy (uniformSpace := ⨅ i, u i) l ↔ ∀ i, Cauchy (uniformSpace := u i) l 
goal: Cauchy l ↔ ∀ (i : ι), Cauchy l

full_name: cauchy_comap_uniformSpace
code: lemma cauchy_comap_uniformSpace {u : UniformSpace β} {f : α → β} {l : Filter α} :
    Cauchy (uniformSpace := comap f u) l ↔ Cauchy (map f l) 
goal: Cauchy l ↔ Cauchy (Filter.map f l)

full_name: cauchy_prod_iff
code: lemma cauchy_prod_iff [UniformSpace β] {F : Filter (α × β)} :
    Cauchy F ↔ Cauchy (map Prod.fst F) ∧ Cauchy (map Prod.snd F) 
goal: Cauchy F ↔ Cauchy (Filter.map Prod.fst F) ∧ Cauchy (Filter.map Prod.snd F)

full_name: Cauchy.prod
code: theorem Cauchy.prod [UniformSpace β] {f : Filter α} {g : Filter β} (hf : Cauchy f) (hg : Cauchy g) :
    Cauchy (f ×ˢ g) 
goal: Cauchy (f ×ˢ g)

full_name: le_nhds_of_cauchy_adhp_aux
code: /-- The common part of the proofs of `le_nhds_of_cauchy_adhp` and
`SequentiallyComplete.le_nhds_of_seq_tendsto_nhds`: if for any entourage `s`
one can choose a set `t ∈ f` of diameter `s` such that it contains a point `y`
with `(x, y) ∈ s`, then `f` converges to `x`. -/
theorem le_nhds_of_cauchy_adhp_aux {f : Filter α} {x : α}
    (adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t) : f ≤ 𝓝 x 
goal: f ≤ 𝓝 x

full_name: le_nhds_of_cauchy_adhp
code: /-- If `x` is an adherent (cluster) point for a Cauchy filter `f`, then it is a limit point
for `f`. -/
theorem le_nhds_of_cauchy_adhp {f : Filter α} {x : α} (hf : Cauchy f) (adhs : ClusterPt x f) :
    f ≤ 𝓝 x 
goal: f ≤ 𝓝 x

full_name: le_nhds_iff_adhp_of_cauchy
code: theorem le_nhds_iff_adhp_of_cauchy {f : Filter α} {x : α} (hf : Cauchy f) :
    f ≤ 𝓝 x ↔ ClusterPt x f 
goal: f ≤ 𝓝 x ↔ ClusterPt x f

full_name: Cauchy.map
code: nonrec theorem Cauchy.map [UniformSpace β] {f : Filter α} {m : α → β} (hf : Cauchy f)
    (hm : UniformContinuous m) : Cauchy (map m f) 
goal: Cauchy (Filter.map m f)

full_name: Cauchy.comap
code: nonrec theorem Cauchy.comap [UniformSpace β] {f : Filter β} {m : α → β} (hf : Cauchy f)
    (hm : comap (fun p : α × α => (m p.1, m p.2)) (𝓤 β) ≤ 𝓤 α) [NeBot (comap m f)] :
    Cauchy (comap m f) 
goal: Cauchy (Filter.comap m f)

full_name: Cauchy.comap'
code: theorem Cauchy.comap' [UniformSpace β] {f : Filter β} {m : α → β} (hf : Cauchy f)
    (hm : Filter.comap (fun p : α × α => (m p.1, m p.2)) (𝓤 β) ≤ 𝓤 α)
    (_ : NeBot (Filter.comap m f)) : Cauchy (Filter.comap m f) 
goal: (Filter.comap m f).NeBot → Cauchy (Filter.comap m f)

full_name: CauchySeq
code: /-- Cauchy sequences. Usually defined on ℕ, but often it is also useful to say that a function
defined on ℝ is Cauchy at +∞ to deduce convergence. Therefore, we define it in a type class that
is general enough to cover both ℕ and ℝ, which are the main motivating examples. -/
def CauchySeq [Preorder β] (u : β → α) 
goal: Prop

full_name: CauchySeq.tendsto_uniformity
code: theorem CauchySeq.tendsto_uniformity [Preorder β] {u : β → α} (h : CauchySeq u) :
    Tendsto (Prod.map u u) atTop (𝓤 α) 
goal: Filter.Tendsto (Prod.map u u) Filter.atTop (𝓤 α)

full_name: CauchySeq.nonempty
code: theorem CauchySeq.nonempty [Preorder β] {u : β → α} (hu : CauchySeq u) : Nonempty β 
goal: Nonempty β

full_name: CauchySeq.mem_entourage
code: theorem CauchySeq.mem_entourage {β : Type*} [SemilatticeSup β] {u : β → α} (h : CauchySeq u)
    {V : Set (α × α)} (hV : V ∈ 𝓤 α) : ∃ k₀, ∀ i j, k₀ ≤ i → k₀ ≤ j → (u i, u j) ∈ V 
goal: ∃ k₀, ∀ (i j : β), k₀ ≤ i → k₀ ≤ j → (u i, u j) ∈ V

full_name: Filter.Tendsto.cauchySeq
code: theorem Filter.Tendsto.cauchySeq [SemilatticeSup β] [Nonempty β] {f : β → α} {x}
    (hx : Tendsto f atTop (𝓝 x)) : CauchySeq f 
goal: CauchySeq f

full_name: cauchySeq_const
code: theorem cauchySeq_const [SemilatticeSup β] [Nonempty β] (x : α) : CauchySeq fun _ : β => x 
goal: CauchySeq fun x_1 => x

full_name: cauchySeq_iff_tendsto
code: theorem cauchySeq_iff_tendsto [Nonempty β] [SemilatticeSup β] {u : β → α} :
    CauchySeq u ↔ Tendsto (Prod.map u u) atTop (𝓤 α) 
goal: CauchySeq u ↔ Filter.Tendsto (Prod.map u u) Filter.atTop (𝓤 α)

full_name: CauchySeq.comp_tendsto
code: theorem CauchySeq.comp_tendsto {γ} [Preorder β] [SemilatticeSup γ] [Nonempty γ] {f : β → α}
    (hf : CauchySeq f) {g : γ → β} (hg : Tendsto g atTop atTop) : CauchySeq (f ∘ g) 
goal: CauchySeq (f ∘ g)

full_name: CauchySeq.comp_injective
code: theorem CauchySeq.comp_injective [SemilatticeSup β] [NoMaxOrder β] [Nonempty β] {u : ℕ → α}
    (hu : CauchySeq u) {f : β → ℕ} (hf : Injective f) : CauchySeq (u ∘ f) 
goal: CauchySeq (u ∘ f)

full_name: Function.Bijective.cauchySeq_comp_iff
code: theorem Function.Bijective.cauchySeq_comp_iff {f : ℕ → ℕ} (hf : Bijective f) (u : ℕ → α) :
    CauchySeq (u ∘ f) ↔ CauchySeq u 
goal: CauchySeq (u ∘ f) ↔ CauchySeq u

full_name: CauchySeq.subseq_subseq_mem
code: theorem CauchySeq.subseq_subseq_mem {V : ℕ → Set (α × α)} (hV : ∀ n, V n ∈ 𝓤 α) {u : ℕ → α}
    (hu : CauchySeq u) {f g : ℕ → ℕ} (hf : Tendsto f atTop atTop) (hg : Tendsto g atTop atTop) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, ((u ∘ f ∘ φ) n, (u ∘ g ∘ φ) n) ∈ V n 
goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), ((u ∘ f ∘ φ) n, (u ∘ g ∘ φ) n) ∈ V n

full_name: cauchySeq_iff'
code: theorem cauchySeq_iff' {u : ℕ → α} :
    CauchySeq u ↔ ∀ V ∈ 𝓤 α, ∀ᶠ k in atTop, k ∈ Prod.map u u ⁻¹' V 
goal: CauchySeq u ↔ ∀ V ∈ 𝓤 α, ∀ᶠ (k : ℕ × ℕ) in Filter.atTop, k ∈ Prod.map u u ⁻¹' V

full_name: cauchySeq_iff
code: theorem cauchySeq_iff {u : ℕ → α} :
    CauchySeq u ↔ ∀ V ∈ 𝓤 α, ∃ N, ∀ k ≥ N, ∀ l ≥ N, (u k, u l) ∈ V 
goal: CauchySeq u ↔ ∀ V ∈ 𝓤 α, ∃ N, ∀ k ≥ N, ∀ l ≥ N, (u k, u l) ∈ V

full_name: CauchySeq.prod_map
code: theorem CauchySeq.prod_map {γ δ} [UniformSpace β] [Preorder γ] [Preorder δ] {u : γ → α}
    {v : δ → β} (hu : CauchySeq u) (hv : CauchySeq v) : CauchySeq (Prod.map u v) 
goal: CauchySeq (Prod.map u v)

full_name: CauchySeq.prod
code: theorem CauchySeq.prod {γ} [UniformSpace β] [Preorder γ] {u : γ → α} {v : γ → β}
    (hu : CauchySeq u) (hv : CauchySeq v) : CauchySeq fun x => (u x, v x) 
goal: CauchySeq fun x => (u x, v x)

full_name: CauchySeq.eventually_eventually
code: theorem CauchySeq.eventually_eventually [SemilatticeSup β] {u : β → α} (hu : CauchySeq u)
    {V : Set (α × α)} (hV : V ∈ 𝓤 α) : ∀ᶠ k in atTop, ∀ᶠ l in atTop, (u k, u l) ∈ V 
goal: ∀ᶠ (k : β) (l : β) in Filter.atTop, (u k, u l) ∈ V

full_name: UniformContinuous.comp_cauchySeq
code: theorem UniformContinuous.comp_cauchySeq {γ} [UniformSpace β] [Preorder γ] {f : α → β}
    (hf : UniformContinuous f) {u : γ → α} (hu : CauchySeq u) : CauchySeq (f ∘ u) 
goal: CauchySeq (f ∘ u)

full_name: CauchySeq.subseq_mem
code: theorem CauchySeq.subseq_mem {V : ℕ → Set (α × α)} (hV : ∀ n, V n ∈ 𝓤 α) {u : ℕ → α}
    (hu : CauchySeq u) : ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, (u <| φ (n + 1), u <| φ n) ∈ V n 
goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), (u (φ (n + 1)), u (φ n)) ∈ V n

full_name: Filter.Tendsto.subseq_mem_entourage
code: theorem Filter.Tendsto.subseq_mem_entourage {V : ℕ → Set (α × α)} (hV : ∀ n, V n ∈ 𝓤 α) {u : ℕ → α}
    {a : α} (hu : Tendsto u atTop (𝓝 a)) : ∃ φ : ℕ → ℕ, StrictMono φ ∧ (u (φ 0), a) ∈ V 0 ∧
      ∀ n, (u <| φ (n + 1), u <| φ n) ∈ V (n + 1) 
goal: ∃ φ, StrictMono φ ∧ (u (φ 0), a) ∈ V 0 ∧ ∀ (n : ℕ), (u (φ (n + 1)), u (φ n)) ∈ V (n + 1)

full_name: tendsto_nhds_of_cauchySeq_of_subseq
code: /-- If a Cauchy sequence has a convergent subsequence, then it converges. -/
theorem tendsto_nhds_of_cauchySeq_of_subseq [Preorder β] {u : β → α} (hu : CauchySeq u)
    {ι : Type*} {f : ι → β} {p : Filter ι} [NeBot p] (hf : Tendsto f p atTop) {a : α}
    (ha : Tendsto (u ∘ f) p (𝓝 a)) : Tendsto u atTop (𝓝 a) 
goal: Filter.Tendsto u Filter.atTop (𝓝 a)

full_name: cauchySeq_shift
code: /-- Any shift of a Cauchy sequence is also a Cauchy sequence. -/
theorem cauchySeq_shift {u : ℕ → α} (k : ℕ) : CauchySeq (fun n ↦ u (n + k)) ↔ CauchySeq u 
goal: (CauchySeq fun n => u (n + k)) ↔ CauchySeq u

full_name: Filter.HasBasis.cauchySeq_iff
code: theorem Filter.HasBasis.cauchySeq_iff {γ} [Nonempty β] [SemilatticeSup β] {u : β → α} {p : γ → Prop}
    {s : γ → Set (α × α)} (h : (𝓤 α).HasBasis p s) :
    CauchySeq u ↔ ∀ i, p i → ∃ N, ∀ m, N ≤ m → ∀ n, N ≤ n → (u m, u n) ∈ s i 
goal: CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i

full_name: Filter.HasBasis.cauchySeq_iff'
code: theorem Filter.HasBasis.cauchySeq_iff' {γ} [Nonempty β] [SemilatticeSup β] {u : β → α}
    {p : γ → Prop} {s : γ → Set (α × α)} (H : (𝓤 α).HasBasis p s) :
    CauchySeq u ↔ ∀ i, p i → ∃ N, ∀ n ≥ N, (u n, u N) ∈ s i 
goal: CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ n ≥ N, (u n, u N) ∈ s i

full_name: cauchySeq_of_controlled
code: theorem cauchySeq_of_controlled [SemilatticeSup β] [Nonempty β] (U : β → Set (α × α))
    (hU : ∀ s ∈ 𝓤 α, ∃ n, U n ⊆ s) {f : β → α}
    (hf : ∀ ⦃N m n : β⦄, N ≤ m → N ≤ n → (f m, f n) ∈ U N) : CauchySeq f 
goal: CauchySeq f

full_name: isComplete_iff_clusterPt
code: theorem isComplete_iff_clusterPt {s : Set α} :
    IsComplete s ↔ ∀ l, Cauchy l → l ≤ 𝓟 s → ∃ x ∈ s, ClusterPt x l 
goal: IsComplete s ↔ ∀ (l : Filter α), Cauchy l → l ≤ 𝓟 s → ∃ x ∈ s, ClusterPt x l

full_name: isComplete_iff_ultrafilter
code: theorem isComplete_iff_ultrafilter {s : Set α} :
    IsComplete s ↔ ∀ l : Ultrafilter α, Cauchy (l : Filter α) → ↑l ≤ 𝓟 s → ∃ x ∈ s, ↑l ≤ 𝓝 x 
goal: IsComplete s ↔ ∀ (l : Ultrafilter α), Cauchy ↑l → ↑l ≤ 𝓟 s → ∃ x ∈ s, ↑l ≤ 𝓝 x

full_name: isComplete_iff_ultrafilter'
code: theorem isComplete_iff_ultrafilter' {s : Set α} :
    IsComplete s ↔ ∀ l : Ultrafilter α, Cauchy (l : Filter α) → s ∈ l → ∃ x ∈ s, ↑l ≤ 𝓝 x 
goal: IsComplete s ↔ ∀ (l : Ultrafilter α), Cauchy ↑l → s ∈ l → ∃ x ∈ s, ↑l ≤ 𝓝 x

full_name: IsComplete.union
code: protected theorem IsComplete.union {s t : Set α} (hs : IsComplete s) (ht : IsComplete t) :
    IsComplete (s ∪ t) 
goal: IsComplete (s ∪ t)

full_name: isComplete_iUnion_separated
code: theorem isComplete_iUnion_separated {ι : Sort*} {s : ι → Set α} (hs : ∀ i, IsComplete (s i))
    {U : Set (α × α)} (hU : U ∈ 𝓤 α) (hd : ∀ (i j : ι), ∀ x ∈ s i, ∀ y ∈ s j, (x, y) ∈ U → i = j) :
    IsComplete (⋃ i, s i) 
goal: IsComplete (⋃ i, s i)

full_name: CompleteSpace.complete
code: /-- A complete space is defined here using uniformities. A uniform space
  is complete if every Cauchy filter converges. -/
class CompleteSpace (α : Type u) [UniformSpace α] : Prop where
  /-- In a complete uniform space, every Cauchy filter converges. -/
  complete : ∀ {f : Filter α}, Cauchy f → ∃ x, f ≤ 𝓝 x
goal: Cauchy f → ∃ x, f ≤ 𝓝 x

full_name: CompleteSpace
code: /-- A complete space is defined here using uniformities. A uniform space
  is complete if every Cauchy filter converges. -/
class CompleteSpace (α : Type u) [UniformSpace α] : Prop where
  /-- In a complete uniform space, every Cauchy filter converges. -/
  complete : ∀ {f : Filter α}, Cauchy f → ∃ x, f ≤ 𝓝 x
goal: Prop

full_name: complete_univ
code: theorem complete_univ {α : Type u} [UniformSpace α] [CompleteSpace α] :
    IsComplete (univ : Set α) 
goal: IsComplete Set.univ

full_name: CompleteSpace.prod
code: instance CompleteSpace.prod [UniformSpace β] [CompleteSpace α] [CompleteSpace β] :
    CompleteSpace (α × β) 
goal: CompleteSpace (α × β)

full_name: CompleteSpace.fst_of_prod
code: lemma CompleteSpace.fst_of_prod [UniformSpace β] [CompleteSpace (α × β)] [h : Nonempty β] :
    CompleteSpace α 
goal: CompleteSpace α

full_name: CompleteSpace.snd_of_prod
code: lemma CompleteSpace.snd_of_prod [UniformSpace β] [CompleteSpace (α × β)] [h : Nonempty α] :
    CompleteSpace β 
goal: CompleteSpace β

full_name: completeSpace_prod_of_nonempty
code: lemma completeSpace_prod_of_nonempty [UniformSpace β] [Nonempty α] [Nonempty β] :
    CompleteSpace (α × β) ↔ CompleteSpace α ∧ CompleteSpace β 
goal: CompleteSpace (α × β) ↔ CompleteSpace α ∧ CompleteSpace β

full_name: CompleteSpace.addOpposite
code: @[to_additive]
instance CompleteSpace.mulOpposite [CompleteSpace α] : CompleteSpace αᵐᵒᵖ 
goal: CompleteSpace αᵃᵒᵖ

full_name: CompleteSpace.mulOpposite
code: @[to_additive]
instance CompleteSpace.mulOpposite [CompleteSpace α] : CompleteSpace αᵐᵒᵖ 
goal: CompleteSpace αᵐᵒᵖ

full_name: completeSpace_of_isComplete_univ
code: /-- If `univ` is complete, the space is a complete space -/
theorem completeSpace_of_isComplete_univ (h : IsComplete (univ : Set α)) : CompleteSpace α 
goal: CompleteSpace α

full_name: completeSpace_iff_isComplete_univ
code: theorem completeSpace_iff_isComplete_univ : CompleteSpace α ↔ IsComplete (univ : Set α) 
goal: CompleteSpace α ↔ IsComplete Set.univ

full_name: completeSpace_iff_ultrafilter
code: theorem completeSpace_iff_ultrafilter :
    CompleteSpace α ↔ ∀ l : Ultrafilter α, Cauchy (l : Filter α) → ∃ x : α, ↑l ≤ 𝓝 x 
goal: CompleteSpace α ↔ ∀ (l : Ultrafilter α), Cauchy ↑l → ∃ x, ↑l ≤ 𝓝 x

full_name: cauchy_iff_exists_le_nhds
code: theorem cauchy_iff_exists_le_nhds [CompleteSpace α] {l : Filter α} [NeBot l] :
    Cauchy l ↔ ∃ x, l ≤ 𝓝 x 
goal: Cauchy l ↔ ∃ x, l ≤ 𝓝 x

full_name: cauchy_map_iff_exists_tendsto
code: theorem cauchy_map_iff_exists_tendsto [CompleteSpace α] {l : Filter β} {f : β → α} [NeBot l] :
    Cauchy (l.map f) ↔ ∃ x, Tendsto f l (𝓝 x) 
goal: Cauchy (Filter.map f l) ↔ ∃ x, Filter.Tendsto f l (𝓝 x)

full_name: cauchySeq_tendsto_of_complete
code: /-- A Cauchy sequence in a complete space converges -/
theorem cauchySeq_tendsto_of_complete [Preorder β] [CompleteSpace α] {u : β → α}
    (H : CauchySeq u) : ∃ x, Tendsto u atTop (𝓝 x) 
goal: ∃ x, Filter.Tendsto u Filter.atTop (𝓝 x)

full_name: cauchySeq_tendsto_of_isComplete
code: /-- If `K` is a complete subset, then any cauchy sequence in `K` converges to a point in `K` -/
theorem cauchySeq_tendsto_of_isComplete [Preorder β] {K : Set α} (h₁ : IsComplete K)
    {u : β → α} (h₂ : ∀ n, u n ∈ K) (h₃ : CauchySeq u) : ∃ v ∈ K, Tendsto u atTop (𝓝 v) 
goal: ∃ v ∈ K, Filter.Tendsto u Filter.atTop (𝓝 v)

full_name: Cauchy.le_nhds_lim
code: theorem Cauchy.le_nhds_lim [CompleteSpace α] {f : Filter α} (hf : Cauchy f) :
    haveI := hf.1.nonempty; f ≤ 𝓝 (lim f) 
goal: f ≤ 𝓝 (lim f)

full_name: CauchySeq.tendsto_limUnder
code: theorem CauchySeq.tendsto_limUnder [Preorder β] [CompleteSpace α] {u : β → α} (h : CauchySeq u) :
    haveI := h.1.nonempty; Tendsto u atTop (𝓝 <| limUnder atTop u) 
goal: Filter.Tendsto u Filter.atTop (𝓝 (limUnder Filter.atTop u))

full_name: IsClosed.isComplete
code: theorem IsClosed.isComplete [CompleteSpace α] {s : Set α} (h : IsClosed s) : IsComplete s 
goal: IsComplete s

full_name: TotallyBounded
code: /-- A set `s` is totally bounded if for every entourage `d` there is a finite
  set of points `t` such that every element of `s` is `d`-near to some element of `t`. -/
def TotallyBounded (s : Set α) : Prop 
goal: Prop

full_name: TotallyBounded.exists_subset
code: theorem TotallyBounded.exists_subset {s : Set α} (hs : TotallyBounded s) {U : Set (α × α)}
    (hU : U ∈ 𝓤 α) : ∃ t, t ⊆ s ∧ Set.Finite t ∧ s ⊆ ⋃ y ∈ t, { x | (x, y) ∈ U } 
goal: ∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, {x | (x, y) ∈ U}

full_name: totallyBounded_iff_subset
code: theorem totallyBounded_iff_subset {s : Set α} :
    TotallyBounded s ↔
      ∀ d ∈ 𝓤 α, ∃ t, t ⊆ s ∧ Set.Finite t ∧ s ⊆ ⋃ y ∈ t, { x | (x, y) ∈ d } 
goal: TotallyBounded s ↔ ∀ d ∈ 𝓤 α, ∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, {x | (x, y) ∈ d}

full_name: Filter.HasBasis.totallyBounded_iff
code: theorem Filter.HasBasis.totallyBounded_iff {ι} {p : ι → Prop} {U : ι → Set (α × α)}
    (H : (𝓤 α).HasBasis p U) {s : Set α} :
    TotallyBounded s ↔ ∀ i, p i → ∃ t : Set α, Set.Finite t ∧ s ⊆ ⋃ y ∈ t, { x | (x, y) ∈ U i } 
goal: TotallyBounded s ↔ ∀ (i : ι), p i → ∃ t, t.Finite ∧ s ⊆ ⋃ y ∈ t, {x | (x, y) ∈ U i}

full_name: totallyBounded_of_forall_symm
code: theorem totallyBounded_of_forall_symm {s : Set α}
    (h : ∀ V ∈ 𝓤 α, SymmetricRel V → ∃ t : Set α, Set.Finite t ∧ s ⊆ ⋃ y ∈ t, ball y V) :
    TotallyBounded s 
goal: TotallyBounded s

full_name: TotallyBounded.subset
code: theorem TotallyBounded.subset {s₁ s₂ : Set α} (hs : s₁ ⊆ s₂) (h : TotallyBounded s₂) :
    TotallyBounded s₁ 
goal: TotallyBounded s₁

full_name: TotallyBounded.closure
code: /-- The closure of a totally bounded set is totally bounded. -/
theorem TotallyBounded.closure {s : Set α} (h : TotallyBounded s) : TotallyBounded (closure s) 
goal: TotallyBounded (closure s)

full_name: totallyBounded_closure
code: @[simp]
lemma totallyBounded_closure {s : Set α} : TotallyBounded (closure s) ↔ TotallyBounded s 
goal: TotallyBounded (closure s) ↔ TotallyBounded s

full_name: totallyBounded_iUnion
code: /-- A finite indexed union is totally bounded
if and only if each set of the family is totally bounded. -/
@[simp]
lemma totallyBounded_iUnion {ι : Sort*} [Finite ι] {s : ι → Set α} :
    TotallyBounded (⋃ i, s i) ↔ ∀ i, TotallyBounded (s i) 
goal: TotallyBounded (⋃ i, s i) ↔ ∀ (i : ι), TotallyBounded (s i)

full_name: totallyBounded_biUnion
code: /-- A union indexed by a finite set is totally bounded
if and only if each set of the family is totally bounded. -/
lemma totallyBounded_biUnion {ι : Type*} {I : Set ι} (hI : I.Finite) {s : ι → Set α} :
    TotallyBounded (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, TotallyBounded (s i) 
goal: TotallyBounded (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, TotallyBounded (s i)

full_name: totallyBounded_sUnion
code: /-- A union of a finite family of sets is totally bounded
if and only if each set of the family is totally bounded. -/
lemma totallyBounded_sUnion {S : Set (Set α)} (hS : S.Finite) :
    TotallyBounded (⋃₀ S) ↔ ∀ s ∈ S, TotallyBounded s 
goal: TotallyBounded (⋃₀ S) ↔ ∀ s ∈ S, TotallyBounded s

full_name: Set.Finite.totallyBounded
code: /-- A finite set is totally bounded. -/
lemma Set.Finite.totallyBounded {s : Set α} (hs : s.Finite) : TotallyBounded s 
goal: TotallyBounded s

full_name: Set.Subsingleton.totallyBounded
code: /-- A subsingleton is totally bounded. -/
lemma Set.Subsingleton.totallyBounded {s : Set α} (hs : s.Subsingleton) :
    TotallyBounded s 
goal: TotallyBounded s

full_name: totallyBounded_singleton
code: @[simp]
lemma totallyBounded_singleton (a : α) : TotallyBounded {a} 
goal: TotallyBounded {a}

full_name: totallyBounded_empty
code: @[simp]
theorem totallyBounded_empty : TotallyBounded (∅ : Set α) 
goal: TotallyBounded ∅

full_name: totallyBounded_union
code: /-- The union of two sets is totally bounded
if and only if each of the two sets is totally bounded.-/
@[simp]
lemma totallyBounded_union {s t : Set α} :
    TotallyBounded (s ∪ t) ↔ TotallyBounded s ∧ TotallyBounded t 
goal: TotallyBounded (s ∪ t) ↔ TotallyBounded s ∧ TotallyBounded t

full_name: TotallyBounded.union
code: /-- The union of two totally bounded sets is totally bounded. -/
protected lemma TotallyBounded.union {s t : Set α} (hs : TotallyBounded s) (ht : TotallyBounded t) :
    TotallyBounded (s ∪ t) 
goal: TotallyBounded (s ∪ t)

full_name: totallyBounded_insert
code: @[simp]
lemma totallyBounded_insert (a : α) {s : Set α} :
    TotallyBounded (insert a s) ↔ TotallyBounded s 
goal: TotallyBounded (insert a s) ↔ TotallyBounded s

full_name: TotallyBounded.image
code: /-- The image of a totally bounded set under a uniformly continuous map is totally bounded. -/
theorem TotallyBounded.image [UniformSpace β] {f : α → β} {s : Set α} (hs : TotallyBounded s)
    (hf : UniformContinuous f) : TotallyBounded (f '' s) 
goal: TotallyBounded (f '' s)

full_name: Ultrafilter.cauchy_of_totallyBounded
code: theorem Ultrafilter.cauchy_of_totallyBounded {s : Set α} (f : Ultrafilter α) (hs : TotallyBounded s)
    (h : ↑f ≤ 𝓟 s) : Cauchy (f : Filter α) 
goal: Cauchy ↑f

full_name: totallyBounded_iff_filter
code: theorem totallyBounded_iff_filter {s : Set α} :
    TotallyBounded s ↔ ∀ f, NeBot f → f ≤ 𝓟 s → ∃ c ≤ f, Cauchy c 
goal: TotallyBounded s ↔ ∀ (f : Filter α), f.NeBot → f ≤ 𝓟 s → ∃ c ≤ f, Cauchy c

full_name: totallyBounded_iff_ultrafilter
code: theorem totallyBounded_iff_ultrafilter {s : Set α} :
    TotallyBounded s ↔ ∀ f : Ultrafilter α, ↑f ≤ 𝓟 s → Cauchy (f : Filter α) 
goal: TotallyBounded s ↔ ∀ (f : Ultrafilter α), ↑f ≤ 𝓟 s → Cauchy ↑f

full_name: isCompact_iff_totallyBounded_isComplete
code: theorem isCompact_iff_totallyBounded_isComplete {s : Set α} :
    IsCompact s ↔ TotallyBounded s ∧ IsComplete s 
goal: IsCompact s ↔ TotallyBounded s ∧ IsComplete s

full_name: IsCompact.totallyBounded
code: protected theorem IsCompact.totallyBounded {s : Set α} (h : IsCompact s) : TotallyBounded s 
goal: TotallyBounded s

full_name: IsCompact.isComplete
code: protected theorem IsCompact.isComplete {s : Set α} (h : IsCompact s) : IsComplete s 
goal: IsComplete s

full_name: complete_of_compact
code: instance (priority := 100) complete_of_compact {α : Type u} [UniformSpace α] [CompactSpace α] :
    CompleteSpace α 
goal: CompleteSpace α

full_name: isCompact_of_totallyBounded_isClosed
code: theorem isCompact_of_totallyBounded_isClosed [CompleteSpace α] {s : Set α} (ht : TotallyBounded s)
    (hc : IsClosed s) : IsCompact s 
goal: IsCompact s

full_name: CauchySeq.totallyBounded_range
code: /-- Every Cauchy sequence over `ℕ` is totally bounded. -/
theorem CauchySeq.totallyBounded_range {s : ℕ → α} (hs : CauchySeq s) :
    TotallyBounded (range s) 
goal: TotallyBounded (Set.range s)

full_name: SequentiallyComplete.setSeqAux
code: /-- An auxiliary sequence of sets approximating a Cauchy filter. -/
def setSeqAux (n : ℕ) : { s : Set α // s ∈ f ∧ s ×ˢ s ⊆ U n } 
goal: { s // s ∈ f ∧ s ×ˢ s ⊆ U n }

full_name: SequentiallyComplete.setSeq
code: /-- Given a Cauchy filter `f` and a sequence `U` of entourages, `set_seq` provides
an antitone sequence of sets `s n ∈ f` such that `s n ×ˢ s n ⊆ U`. -/
def setSeq (n : ℕ) : Set α 
goal: Set α

full_name: SequentiallyComplete.setSeq_mem
code: theorem setSeq_mem (n : ℕ) : setSeq hf U_mem n ∈ f 
goal: SequentiallyComplete.setSeq hf U_mem n ∈ f

full_name: SequentiallyComplete.setSeq_mono
code: theorem setSeq_mono ⦃m n : ℕ⦄ (h : m ≤ n) : setSeq hf U_mem n ⊆ setSeq hf U_mem m 
goal: SequentiallyComplete.setSeq hf U_mem n ⊆ SequentiallyComplete.setSeq hf U_mem m

full_name: SequentiallyComplete.setSeq_sub_aux
code: theorem setSeq_sub_aux (n : ℕ) : setSeq hf U_mem n ⊆ setSeqAux hf U_mem n 
goal: SequentiallyComplete.setSeq hf U_mem n ⊆ ↑(SequentiallyComplete.setSeqAux hf U_mem n)

full_name: SequentiallyComplete.setSeq_prod_subset
code: theorem setSeq_prod_subset {N m n} (hm : N ≤ m) (hn : N ≤ n) :
    setSeq hf U_mem m ×ˢ setSeq hf U_mem n ⊆ U N 
goal: SequentiallyComplete.setSeq hf U_mem m ×ˢ SequentiallyComplete.setSeq hf U_mem n ⊆ U N

full_name: SequentiallyComplete.seq
code: /-- A sequence of points such that `seq n ∈ setSeq n`. Here `setSeq` is an antitone
sequence of sets `setSeq n ∈ f` with diameters controlled by a given sequence
of entourages. -/
def seq (n : ℕ) : α 
goal: α

full_name: SequentiallyComplete.seq_mem
code: theorem seq_mem (n : ℕ) : seq hf U_mem n ∈ setSeq hf U_mem n 
goal: SequentiallyComplete.seq hf U_mem n ∈ SequentiallyComplete.setSeq hf U_mem n

full_name: SequentiallyComplete.seq_pair_mem
code: theorem seq_pair_mem ⦃N m n : ℕ⦄ (hm : N ≤ m) (hn : N ≤ n) :
    (seq hf U_mem m, seq hf U_mem n) ∈ U N 
goal: (SequentiallyComplete.seq hf U_mem m, SequentiallyComplete.seq hf U_mem n) ∈ U N

full_name: SequentiallyComplete.seq_is_cauchySeq
code: theorem seq_is_cauchySeq : CauchySeq <| seq hf U_mem 
goal: CauchySeq (SequentiallyComplete.seq hf U_mem)

full_name: SequentiallyComplete.le_nhds_of_seq_tendsto_nhds
code: /-- If the sequence `SequentiallyComplete.seq` converges to `a`, then `f ≤ 𝓝 a`. -/
theorem le_nhds_of_seq_tendsto_nhds ⦃a : α⦄ (ha : Tendsto (seq hf U_mem) atTop (𝓝 a)) : f ≤ 𝓝 a 
goal: f ≤ 𝓝 a

full_name: UniformSpace.complete_of_convergent_controlled_sequences
code: /-- A uniform space is complete provided that (a) its uniformity filter has a countable basis;
(b) any sequence satisfying a "controlled" version of the Cauchy condition converges. -/
theorem complete_of_convergent_controlled_sequences (U : ℕ → Set (α × α)) (U_mem : ∀ n, U n ∈ 𝓤 α)
    (HU : ∀ u : ℕ → α, (∀ N m n, N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)) :
    CompleteSpace α 
goal: CompleteSpace α

full_name: UniformSpace.complete_of_cauchySeq_tendsto
code: /-- A sequentially complete uniform space with a countable basis of the uniformity filter is
complete. -/
theorem complete_of_cauchySeq_tendsto (H' : ∀ u : ℕ → α, CauchySeq u → ∃ a, Tendsto u atTop (𝓝 a)) :
    CompleteSpace α 
goal: CompleteSpace α

full_name: UniformSpace.firstCountableTopology
code: instance (priority := 100) firstCountableTopology : FirstCountableTopology α 
goal: FirstCountableTopology α

full_name: UniformSpace.secondCountable_of_separable
code: /-- A separable uniform space with countably generated uniformity filter is second countable:
one obtains a countable basis by taking the balls centered at points in a dense subset,
and with rational "radii" from a countable open symmetric antitone basis of `𝓤 α`. We do not
register this as an instance, as there is already an instance going in the other direction
from second countable spaces to separable spaces, and we want to avoid loops. -/
theorem secondCountable_of_separable [SeparableSpace α] : SecondCountableTopology α 
goal: SecondCountableTopology α