mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -193,9 +193,9 @@ theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
   specialize h (· ∉ s) x
   by_cases hx : x ∈ s; · exact subset_seqClosure hx
   simp_rw [(· ∘ ·), ContinuousAt, hx, not_false_iff, nhds_true, tendsto_pure, eq_true_iff, ←
-    mem_compl_iff, eventually_mem_set, ← mem_interior_iff_mem_nhds, interior_compl] at h 
-  rw [mem_compl_iff, imp_not_comm] at h 
-  simp only [Classical.not_forall, not_eventually, mem_compl_iff, Classical.not_not] at h 
+    mem_compl_iff, eventually_mem_set, ← mem_interior_iff_mem_nhds, interior_compl] at h
+  rw [mem_compl_iff, imp_not_comm] at h
+  simp only [Classical.not_forall, not_eventually, mem_compl_iff, Classical.not_not] at h
   rcases h hcx with ⟨u, hux, hus⟩
   rcases extraction_of_frequently_at_top hus with ⟨φ, φ_mono, hφ⟩
   exact ⟨u ∘ φ, hφ, hux.comp φ_mono.tendsto_at_top⟩
@@ -415,11 +415,11 @@ theorem IsSeqCompact.exists_tendsto (hs : IsSeqCompact s) {u : ℕ → X} (hu :
 protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBounded s :=
   by
   intro V V_in
-  unfold IsSeqCompact at h 
+  unfold IsSeqCompact at h
   contrapose! h
   obtain ⟨u, u_in, hu⟩ : ∃ u : ℕ → X, (∀ n, u n ∈ s) ∧ ∀ n m, m < n → u m ∉ ball (u n) V :=
     by
-    simp only [not_subset, mem_Union₂, not_exists, exists_prop] at h 
+    simp only [not_subset, mem_Union₂, not_exists, exists_prop] at h
     simpa only [forall_and, ball_image_iff, not_and] using seq_of_forall_finite_exists h
   refine' ⟨u, u_in, fun x x_in φ hφ huφ => _⟩
   obtain ⟨N, hN⟩ : ∃ N, ∀ p q, p ≥ N → q ≥ N → (u (φ p), u (φ q)) ∈ V
@@ -449,7 +449,7 @@ protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s :
     by
     have : ∀ n, ∃ t ∈ l, t ×ˢ t ⊆ W n ∧ t ⊆ s :=
       by
-      rw [le_principal_iff] at hls 
+      rw [le_principal_iff] at hls
       have : ∀ n, W n ∩ s ×ˢ s ∈ l ×ᶠ l := fun n => inter_mem (hl.2 (hW n)) (prod_mem_prod hls hls)
       simpa only [l.basis_sets.prod_self.mem_iff, true_imp_iff, subset_inter_iff,
         prod_self_subset_prod_self, and_assoc] using this

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -202,13 +202,13 @@ theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
 #align frechet_urysohn_space.of_seq_tendsto_imp_tendsto FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
 -/
 
-#print TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace /-
+#print FirstCountableTopology.frechetUrysohnSpace /-
 -- see Note [lower instance priority]
 /-- Every first-countable space is a Fréchet-Urysohn space. -/
-instance (priority := 100) TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace
-    [FirstCountableTopology X] : FrechetUrysohnSpace X :=
+instance (priority := 100) FirstCountableTopology.frechetUrysohnSpace [FirstCountableTopology X] :
+    FrechetUrysohnSpace X :=
   FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto fun f a => tendsto_iff_seq_tendsto.2
-#align topological_space.first_countable_topology.frechet_urysohn_space TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace
+#align topological_space.first_countable_topology.frechet_urysohn_space FirstCountableTopology.frechetUrysohnSpace
 -/
 
 #print SequentialSpace /-
@@ -298,7 +298,7 @@ end TopologicalSpace
 
 section SeqCompact
 
-open TopologicalSpace TopologicalSpace.FirstCountableTopology
+open TopologicalSpace FirstCountableTopology
 
 variable [TopologicalSpace X]
 
@@ -343,7 +343,7 @@ section FirstCountableTopology
 
 variable [FirstCountableTopology X]
 
-open TopologicalSpace.FirstCountableTopology
+open FirstCountableTopology
 
 #print IsCompact.isSeqCompact /-
 protected theorem IsCompact.isSeqCompact {s : Set X} (hs : IsCompact s) : IsSeqCompact s :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/b1abe23ae96fef89ad30d9f4362c307f72a55010

@@ -195,7 +195,7 @@ theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
   simp_rw [(· ∘ ·), ContinuousAt, hx, not_false_iff, nhds_true, tendsto_pure, eq_true_iff, ←
     mem_compl_iff, eventually_mem_set, ← mem_interior_iff_mem_nhds, interior_compl] at h 
   rw [mem_compl_iff, imp_not_comm] at h 
-  simp only [not_forall, not_eventually, mem_compl_iff, Classical.not_not] at h 
+  simp only [Classical.not_forall, not_eventually, mem_compl_iff, Classical.not_not] at h 
   rcases h hcx with ⟨u, hux, hus⟩
   rcases extraction_of_frequently_at_top hus with ⟨φ, φ_mono, hφ⟩
   exact ⟨u ∘ φ, hφ, hux.comp φ_mono.tendsto_at_top⟩

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,8 +3,8 @@ Copyright (c) 2018 Jan-David Salchow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jan-David Salchow, Patrick Massot, Yury Kudryashov
 -/
-import Mathbin.Topology.SubsetProperties
-import Mathbin.Topology.MetricSpace.Basic
+import Topology.SubsetProperties
+import Topology.MetricSpace.Basic
 
 #align_import topology.sequences from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -516,7 +516,7 @@ variable [ProperSpace X] {s : Set X}
 /-- A version of **Bolzano-Weistrass**: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. This version assumes only
 that the sequence is frequently in some bounded set. -/
-theorem tendsto_subseq_of_frequently_bounded (hs : Bounded s) {x : ℕ → X}
+theorem tendsto_subseq_of_frequently_bounded (hs : IsBounded s) {x : ℕ → X}
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ closure s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   have hcs : IsSeqCompact (closure s) := hs.isCompact_closure.IsSeqCompact
@@ -528,7 +528,7 @@ theorem tendsto_subseq_of_frequently_bounded (hs : Bounded s) {x : ℕ → X}
 #print tendsto_subseq_of_bounded /-
 /-- A version of Bolzano-Weistrass: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. -/
-theorem tendsto_subseq_of_bounded (hs : Bounded s) {x : ℕ → X} (hx : ∀ n, x n ∈ s) :
+theorem tendsto_subseq_of_bounded (hs : IsBounded s) {x : ℕ → X} (hx : ∀ n, x n ∈ s) :
     ∃ a ∈ closure s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   tendsto_subseq_of_frequently_bounded hs <| frequently_of_forall hx
 #align tendsto_subseq_of_bounded tendsto_subseq_of_bounded

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Jan-David Salchow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jan-David Salchow, Patrick Massot, Yury Kudryashov
-
-! This file was ported from Lean 3 source module topology.sequences
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.SubsetProperties
 import Mathbin.Topology.MetricSpace.Basic
 
+#align_import topology.sequences from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # Sequences in topological spaces
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -163,6 +163,7 @@ theorem mem_closure_iff_seq_limit [FrechetUrysohnSpace X] {s : Set X} {a : X} :
 #align mem_closure_iff_seq_limit mem_closure_iff_seq_limit
 -/
 
+#print tendsto_nhds_iff_seq_tendsto /-
 /-- If the domain of a function `f : α → β` is a Fréchet-Urysohn space, then convergence
 is equivalent to sequential convergence. See also `filter.tendsto_iff_seq_tendsto` for a version
 that works for any pair of filters assuming that the filter in the domain is countably generated.
@@ -181,6 +182,7 @@ theorem tendsto_nhds_iff_seq_tendsto [FrechetUrysohnSpace X] {f : X → Y} {a :
   rintro ⟨u, hus, hu⟩
   exact hsc.mem_of_tendsto (h u hu) (eventually_of_forall hus)
 #align tendsto_nhds_iff_seq_tendsto tendsto_nhds_iff_seq_tendsto
+-/
 
 #print FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto /-
 /-- An alternative construction for `frechet_urysohn_space`: if sequential convergence implies
@@ -260,28 +262,36 @@ theorem IsSeqClosed.preimage {f : X → Y} {s : Set Y} (hs : IsSeqClosed s) (hf
 #align is_seq_closed.preimage IsSeqClosed.preimage
 -/
 
+#print Continuous.seqContinuous /-
 -- A continuous function is sequentially continuous.
 protected theorem Continuous.seqContinuous {f : X → Y} (hf : Continuous f) : SeqContinuous f :=
   fun x p hx => (hf.Tendsto p).comp hx
 #align continuous.seq_continuous Continuous.seqContinuous
+-/
 
+#print SeqContinuous.continuous /-
 /-- A sequentially continuous function defined on a sequential space is continuous. -/
 protected theorem SeqContinuous.continuous [SequentialSpace X] {f : X → Y} (hf : SeqContinuous f) :
     Continuous f :=
   continuous_iff_isClosed.mpr fun s hs => (hs.IsSeqClosed.Preimage hf).IsClosed
 #align seq_continuous.continuous SeqContinuous.continuous
+-/
 
+#print continuous_iff_seqContinuous /-
 /-- If the domain of a function is a sequential space, then continuity of this function is
 equivalent to its sequential continuity. -/
 theorem continuous_iff_seqContinuous [SequentialSpace X] {f : X → Y} :
     Continuous f ↔ SeqContinuous f :=
   ⟨Continuous.seqContinuous, SeqContinuous.continuous⟩
 #align continuous_iff_seq_continuous continuous_iff_seqContinuous
+-/
 
+#print QuotientMap.sequentialSpace /-
 theorem QuotientMap.sequentialSpace [SequentialSpace X] {f : X → Y} (hf : QuotientMap f) :
     SequentialSpace Y :=
   ⟨fun s hs => hf.isClosed_preimage.mp <| (hs.Preimage <| hf.Continuous.SeqContinuous).IsClosed⟩
 #align quotient_map.sequential_space QuotientMap.sequentialSpace
+-/
 
 /-- The quotient of a sequential space is a sequential space. -/
 instance [SequentialSpace X] {s : Setoid X} : SequentialSpace (Quotient s) :=
@@ -314,6 +324,7 @@ class SeqCompactSpace (X : Type _) [TopologicalSpace X] : Prop where
 
 export SeqCompactSpace (seq_compact_univ)
 
+#print IsSeqCompact.subseq_of_frequently_in /-
 theorem IsSeqCompact.subseq_of_frequently_in {s : Set X} (hs : IsSeqCompact s) {x : ℕ → X}
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
@@ -321,6 +332,7 @@ theorem IsSeqCompact.subseq_of_frequently_in {s : Set X} (hs : IsSeqCompact s) {
   let ⟨a, a_in, φ, hφ, h⟩ := hs huψ
   ⟨a, a_in, ψ ∘ φ, hψ.comp hφ, h⟩
 #align is_seq_compact.subseq_of_frequently_in IsSeqCompact.subseq_of_frequently_in
+-/
 
 #print SeqCompactSpace.tendsto_subseq /-
 theorem SeqCompactSpace.tendsto_subseq [SeqCompactSpace X] (x : ℕ → X) :
@@ -344,16 +356,20 @@ protected theorem IsCompact.isSeqCompact {s : Set X} (hs : IsCompact s) : IsSeqC
 #align is_compact.is_seq_compact IsCompact.isSeqCompact
 -/
 
+#print IsCompact.tendsto_subseq' /-
 theorem IsCompact.tendsto_subseq' {s : Set X} {x : ℕ → X} (hs : IsCompact s)
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   hs.IsSeqCompact.subseq_of_frequently_in hx
 #align is_compact.tendsto_subseq' IsCompact.tendsto_subseq'
+-/
 
+#print IsCompact.tendsto_subseq /-
 theorem IsCompact.tendsto_subseq {s : Set X} {x : ℕ → X} (hs : IsCompact s) (hx : ∀ n, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   hs.IsSeqCompact hx
 #align is_compact.tendsto_subseq IsCompact.tendsto_subseq
+-/
 
 #print FirstCountableTopology.seq_compact_of_compact /-
 -- see Note [lower instance priority]
@@ -382,16 +398,20 @@ open UniformSpace Prod
 
 variable [UniformSpace X] {s : Set X}
 
+#print IsSeqCompact.exists_tendsto_of_frequently_mem /-
 theorem IsSeqCompact.exists_tendsto_of_frequently_mem (hs : IsSeqCompact s) {u : ℕ → X}
     (hu : ∃ᶠ n in atTop, u n ∈ s) (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x) :=
   let ⟨x, hxs, φ, φ_mono, hx⟩ := hs.subseq_of_frequently_in hu
   ⟨x, hxs, tendsto_nhds_of_cauchySeq_of_subseq huc φ_mono.tendsto_atTop hx⟩
 #align is_seq_compact.exists_tendsto_of_frequently_mem IsSeqCompact.exists_tendsto_of_frequently_mem
+-/
 
+#print IsSeqCompact.exists_tendsto /-
 theorem IsSeqCompact.exists_tendsto (hs : IsSeqCompact s) {u : ℕ → X} (hu : ∀ n, u n ∈ s)
     (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x) :=
   hs.exists_tendsto_of_frequently_mem (frequently_of_forall hu) huc
 #align is_seq_compact.exists_tendsto IsSeqCompact.exists_tendsto
+-/
 
 #print IsSeqCompact.totallyBounded /-
 /-- A sequentially compact set in a uniform space is totally bounded. -/
@@ -485,14 +505,17 @@ variable [PseudoMetricSpace X]
 
 open Metric
 
+#print SeqCompact.lebesgue_number_lemma_of_metric /-
 theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort _} {c : ι → Set X} {s : Set X}
     (hs : IsSeqCompact s) (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i, c i) :
     ∃ δ > 0, ∀ a ∈ s, ∃ i, ball a δ ⊆ c i :=
   lebesgue_number_lemma_of_metric hs.IsCompact hc₁ hc₂
 #align seq_compact.lebesgue_number_lemma_of_metric SeqCompact.lebesgue_number_lemma_of_metric
+-/
 
 variable [ProperSpace X] {s : Set X}
 
+#print tendsto_subseq_of_frequently_bounded /-
 /-- A version of **Bolzano-Weistrass**: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. This version assumes only
 that the sequence is frequently in some bounded set. -/
@@ -503,13 +526,16 @@ theorem tendsto_subseq_of_frequently_bounded (hs : Bounded s) {x : ℕ → X}
   have hu' : ∃ᶠ n in atTop, x n ∈ closure s := hx.mono fun n hn => subset_closure hn
   hcs.subseq_of_frequently_in hu'
 #align tendsto_subseq_of_frequently_bounded tendsto_subseq_of_frequently_bounded
+-/
 
+#print tendsto_subseq_of_bounded /-
 /-- A version of Bolzano-Weistrass: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. -/
 theorem tendsto_subseq_of_bounded (hs : Bounded s) {x : ℕ → X} (hx : ∀ n, x n ∈ s) :
     ∃ a ∈ closure s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   tendsto_subseq_of_frequently_bounded hs <| frequently_of_forall hx
 #align tendsto_subseq_of_bounded tendsto_subseq_of_bounded
+-/
 
 end MetricSeqCompact
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -84,7 +84,7 @@ variable [TopologicalSpace X] [TopologicalSpace Y]
 which arise as limit of sequences in `s`. Note that the sequential closure of a set is not
 guaranteed to be sequentially closed. -/
 def seqClosure (s : Set X) : Set X :=
-  { a | ∃ x : ℕ → X, (∀ n : ℕ, x n ∈ s) ∧ Tendsto x atTop (𝓝 a) }
+  {a | ∃ x : ℕ → X, (∀ n : ℕ, x n ∈ s) ∧ Tendsto x atTop (𝓝 a)}
 #align seq_closure seqClosure
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -194,9 +194,9 @@ theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
   specialize h (· ∉ s) x
   by_cases hx : x ∈ s; · exact subset_seqClosure hx
   simp_rw [(· ∘ ·), ContinuousAt, hx, not_false_iff, nhds_true, tendsto_pure, eq_true_iff, ←
-    mem_compl_iff, eventually_mem_set, ← mem_interior_iff_mem_nhds, interior_compl] at h
-  rw [mem_compl_iff, imp_not_comm] at h
-  simp only [not_forall, not_eventually, mem_compl_iff, Classical.not_not] at h
+    mem_compl_iff, eventually_mem_set, ← mem_interior_iff_mem_nhds, interior_compl] at h 
+  rw [mem_compl_iff, imp_not_comm] at h 
+  simp only [not_forall, not_eventually, mem_compl_iff, Classical.not_not] at h 
   rcases h hcx with ⟨u, hux, hus⟩
   rcases extraction_of_frequently_at_top hus with ⟨φ, φ_mono, hφ⟩
   exact ⟨u ∘ φ, hφ, hux.comp φ_mono.tendsto_at_top⟩
@@ -324,7 +324,7 @@ theorem IsSeqCompact.subseq_of_frequently_in {s : Set X} (hs : IsSeqCompact s) {
 
 #print SeqCompactSpace.tendsto_subseq /-
 theorem SeqCompactSpace.tendsto_subseq [SeqCompactSpace X] (x : ℕ → X) :
-    ∃ (a : _)(φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
+    ∃ (a : _) (φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   let ⟨a, _, φ, mono, h⟩ := seq_compact_univ fun n => mem_univ (x n)
   ⟨a, φ, mono, h⟩
 #align seq_compact_space.tendsto_subseq SeqCompactSpace.tendsto_subseq
@@ -365,7 +365,7 @@ instance (priority := 100) FirstCountableTopology.seq_compact_of_compact [Compac
 
 #print CompactSpace.tendsto_subseq /-
 theorem CompactSpace.tendsto_subseq [CompactSpace X] (x : ℕ → X) :
-    ∃ (a : _)(φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
+    ∃ (a : _) (φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   SeqCompactSpace.tendsto_subseq x
 #align compact_space.tendsto_subseq CompactSpace.tendsto_subseq
 -/
@@ -398,11 +398,11 @@ theorem IsSeqCompact.exists_tendsto (hs : IsSeqCompact s) {u : ℕ → X} (hu :
 protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBounded s :=
   by
   intro V V_in
-  unfold IsSeqCompact at h
+  unfold IsSeqCompact at h 
   contrapose! h
   obtain ⟨u, u_in, hu⟩ : ∃ u : ℕ → X, (∀ n, u n ∈ s) ∧ ∀ n m, m < n → u m ∉ ball (u n) V :=
     by
-    simp only [not_subset, mem_Union₂, not_exists, exists_prop] at h
+    simp only [not_subset, mem_Union₂, not_exists, exists_prop] at h 
     simpa only [forall_and, ball_image_iff, not_and] using seq_of_forall_finite_exists h
   refine' ⟨u, u_in, fun x x_in φ hφ huφ => _⟩
   obtain ⟨N, hN⟩ : ∃ N, ∀ p q, p ≥ N → q ≥ N → (u (φ p), u (φ q)) ∈ V
@@ -432,7 +432,7 @@ protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s :
     by
     have : ∀ n, ∃ t ∈ l, t ×ˢ t ⊆ W n ∧ t ⊆ s :=
       by
-      rw [le_principal_iff] at hls
+      rw [le_principal_iff] at hls 
       have : ∀ n, W n ∩ s ×ˢ s ∈ l ×ᶠ l := fun n => inter_mem (hl.2 (hW n)) (prod_mem_prod hls hls)
       simpa only [l.basis_sets.prod_self.mem_iff, true_imp_iff, subset_inter_iff,
         prod_self_subset_prod_self, and_assoc] using this
@@ -452,7 +452,7 @@ protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s :
   obtain ⟨n, hNn, hn⟩ : ∃ n, N ≤ n ∧ u n ∈ ball x (W N)
   exact ((eventually_ge_at_top N).And (hx <| ball_mem_nhds x (hW N))).exists
   refine' mem_of_superset (htl n) fun y hy => hWV N ⟨u n, _, htW N ⟨_, _⟩⟩
-  exacts[hn, ht_anti hNn (hu n), ht_anti hNn hy]
+  exacts [hn, ht_anti hNn (hu n), ht_anti hNn hy]
 #align is_seq_compact.is_complete IsSeqCompact.isComplete
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -68,7 +68,7 @@ sequentially closed, sequentially compact, sequential space
 
 open Set Function Filter TopologicalSpace
 
-open Topology Filter
+open scoped Topology Filter
 
 variable {X Y : Type _}
 
@@ -376,7 +376,7 @@ end SeqCompact
 
 section UniformSpaceSeqCompact
 
-open uniformity
+open scoped uniformity
 
 open UniformSpace Prod
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -163,12 +163,6 @@ theorem mem_closure_iff_seq_limit [FrechetUrysohnSpace X] {s : Set X} {a : X} :
 #align mem_closure_iff_seq_limit mem_closure_iff_seq_limit
 -/
 
-/- warning: tendsto_nhds_iff_seq_tendsto -> tendsto_nhds_iff_seq_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : FrechetUrysohnSpace.{u1} X _inst_1] {f : X -> Y} {a : X} {b : Y}, Iff (Filter.Tendsto.{u1, u2} X Y f (nhds.{u1} X _inst_1 a) (nhds.{u2} Y _inst_2 b)) (forall (u : Nat -> X), (Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X _inst_1 a)) -> (Filter.Tendsto.{0, u2} Nat Y (Function.comp.{1, succ u1, succ u2} Nat X Y f u) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u2} Y _inst_2 b)))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] [_inst_3 : FrechetUrysohnSpace.{u2} X _inst_1] {f : X -> Y} {a : X} {b : Y}, Iff (Filter.Tendsto.{u2, u1} X Y f (nhds.{u2} X _inst_1 a) (nhds.{u1} Y _inst_2 b)) (forall (u : Nat -> X), (Filter.Tendsto.{0, u2} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u2} X _inst_1 a)) -> (Filter.Tendsto.{0, u1} Nat Y (Function.comp.{1, succ u2, succ u1} Nat X Y f u) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} Y _inst_2 b)))
-Case conversion may be inaccurate. Consider using '#align tendsto_nhds_iff_seq_tendsto tendsto_nhds_iff_seq_tendstoₓ'. -/
 /-- If the domain of a function `f : α → β` is a Fréchet-Urysohn space, then convergence
 is equivalent to sequential convergence. See also `filter.tendsto_iff_seq_tendsto` for a version
 that works for any pair of filters assuming that the filter in the domain is countably generated.
@@ -266,35 +260,17 @@ theorem IsSeqClosed.preimage {f : X → Y} {s : Set Y} (hs : IsSeqClosed s) (hf
 #align is_seq_closed.preimage IsSeqClosed.preimage
 -/
 
-/- warning: continuous.seq_continuous -> Continuous.seqContinuous is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] {f : X -> Y}, (Continuous.{u1, u2} X Y _inst_1 _inst_2 f) -> (SeqContinuous.{u1, u2} X Y _inst_1 _inst_2 f)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] {f : X -> Y}, (Continuous.{u2, u1} X Y _inst_1 _inst_2 f) -> (SeqContinuous.{u2, u1} X Y _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align continuous.seq_continuous Continuous.seqContinuousₓ'. -/
 -- A continuous function is sequentially continuous.
 protected theorem Continuous.seqContinuous {f : X → Y} (hf : Continuous f) : SeqContinuous f :=
   fun x p hx => (hf.Tendsto p).comp hx
 #align continuous.seq_continuous Continuous.seqContinuous
 
-/- warning: seq_continuous.continuous -> SeqContinuous.continuous is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : SequentialSpace.{u1} X _inst_1] {f : X -> Y}, (SeqContinuous.{u1, u2} X Y _inst_1 _inst_2 f) -> (Continuous.{u1, u2} X Y _inst_1 _inst_2 f)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] [_inst_3 : SequentialSpace.{u2} X _inst_1] {f : X -> Y}, (SeqContinuous.{u2, u1} X Y _inst_1 _inst_2 f) -> (Continuous.{u2, u1} X Y _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align seq_continuous.continuous SeqContinuous.continuousₓ'. -/
 /-- A sequentially continuous function defined on a sequential space is continuous. -/
 protected theorem SeqContinuous.continuous [SequentialSpace X] {f : X → Y} (hf : SeqContinuous f) :
     Continuous f :=
   continuous_iff_isClosed.mpr fun s hs => (hs.IsSeqClosed.Preimage hf).IsClosed
 #align seq_continuous.continuous SeqContinuous.continuous
 
-/- warning: continuous_iff_seq_continuous -> continuous_iff_seqContinuous is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : SequentialSpace.{u1} X _inst_1] {f : X -> Y}, Iff (Continuous.{u1, u2} X Y _inst_1 _inst_2 f) (SeqContinuous.{u1, u2} X Y _inst_1 _inst_2 f)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] [_inst_3 : SequentialSpace.{u2} X _inst_1] {f : X -> Y}, Iff (Continuous.{u2, u1} X Y _inst_1 _inst_2 f) (SeqContinuous.{u2, u1} X Y _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align continuous_iff_seq_continuous continuous_iff_seqContinuousₓ'. -/
 /-- If the domain of a function is a sequential space, then continuity of this function is
 equivalent to its sequential continuity. -/
 theorem continuous_iff_seqContinuous [SequentialSpace X] {f : X → Y} :
@@ -302,12 +278,6 @@ theorem continuous_iff_seqContinuous [SequentialSpace X] {f : X → Y} :
   ⟨Continuous.seqContinuous, SeqContinuous.continuous⟩
 #align continuous_iff_seq_continuous continuous_iff_seqContinuous
 
-/- warning: quotient_map.sequential_space -> QuotientMap.sequentialSpace is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : SequentialSpace.{u1} X _inst_1] {f : X -> Y}, (QuotientMap.{u1, u2} X Y _inst_1 _inst_2 f) -> (SequentialSpace.{u2} Y _inst_2)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] [_inst_3 : SequentialSpace.{u2} X _inst_1] {f : X -> Y}, (QuotientMap.{u2, u1} X Y _inst_1 _inst_2 f) -> (SequentialSpace.{u1} Y _inst_2)
-Case conversion may be inaccurate. Consider using '#align quotient_map.sequential_space QuotientMap.sequentialSpaceₓ'. -/
 theorem QuotientMap.sequentialSpace [SequentialSpace X] {f : X → Y} (hf : QuotientMap f) :
     SequentialSpace Y :=
   ⟨fun s hs => hf.isClosed_preimage.mp <| (hs.Preimage <| hf.Continuous.SeqContinuous).IsClosed⟩
@@ -344,12 +314,6 @@ class SeqCompactSpace (X : Type _) [TopologicalSpace X] : Prop where
 
 export SeqCompactSpace (seq_compact_univ)
 
-/- warning: is_seq_compact.subseq_of_frequently_in -> IsSeqCompact.subseq_of_frequently_in is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X _inst_1 a)))))))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X _inst_1 a)))))))
-Case conversion may be inaccurate. Consider using '#align is_seq_compact.subseq_of_frequently_in IsSeqCompact.subseq_of_frequently_inₓ'. -/
 theorem IsSeqCompact.subseq_of_frequently_in {s : Set X} (hs : IsSeqCompact s) {x : ℕ → X}
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
@@ -380,24 +344,12 @@ protected theorem IsCompact.isSeqCompact {s : Set X} (hs : IsCompact s) : IsSeqC
 #align is_compact.is_seq_compact IsCompact.isSeqCompact
 -/
 
-/- warning: is_compact.tendsto_subseq' -> IsCompact.tendsto_subseq' is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.FirstCountableTopology.{u1} X _inst_1] {s : Set.{u1} X} {x : Nat -> X}, (IsCompact.{u1} X _inst_1 s) -> (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X _inst_1 a))))))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.FirstCountableTopology.{u1} X _inst_1] {s : Set.{u1} X} {x : Nat -> X}, (IsCompact.{u1} X _inst_1 s) -> (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X _inst_1 a))))))
-Case conversion may be inaccurate. Consider using '#align is_compact.tendsto_subseq' IsCompact.tendsto_subseq'ₓ'. -/
 theorem IsCompact.tendsto_subseq' {s : Set X} {x : ℕ → X} (hs : IsCompact s)
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   hs.IsSeqCompact.subseq_of_frequently_in hx
 #align is_compact.tendsto_subseq' IsCompact.tendsto_subseq'
 
-/- warning: is_compact.tendsto_subseq -> IsCompact.tendsto_subseq is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.FirstCountableTopology.{u1} X _inst_1] {s : Set.{u1} X} {x : Nat -> X}, (IsCompact.{u1} X _inst_1 s) -> (forall (n : Nat), Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X _inst_1 a))))))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.FirstCountableTopology.{u1} X _inst_1] {s : Set.{u1} X} {x : Nat -> X}, (IsCompact.{u1} X _inst_1 s) -> (forall (n : Nat), Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X _inst_1 a))))))
-Case conversion may be inaccurate. Consider using '#align is_compact.tendsto_subseq IsCompact.tendsto_subseqₓ'. -/
 theorem IsCompact.tendsto_subseq {s : Set X} {x : ℕ → X} (hs : IsCompact s) (hx : ∀ n, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   hs.IsSeqCompact hx
@@ -430,24 +382,12 @@ open UniformSpace Prod
 
 variable [UniformSpace X] {s : Set X}
 
-/- warning: is_seq_compact.exists_tendsto_of_frequently_mem -> IsSeqCompact.exists_tendsto_of_frequently_mem is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : UniformSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) s) -> (forall {u : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (u n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) -> (CauchySeq.{u1, 0} X Nat _inst_1 (CanonicallyLinearOrderedAddMonoid.semilatticeSup.{0} Nat Nat.canonicallyLinearOrderedAddMonoid) u) -> (Exists.{succ u1} X (fun (x : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) => Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) x)))))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : UniformSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) s) -> (forall {u : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (u n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) -> (CauchySeq.{u1, 0} X Nat _inst_1 (Lattice.toSemilatticeSup.{0} Nat (DistribLattice.toLattice.{0} Nat instDistribLatticeNat)) u) -> (Exists.{succ u1} X (fun (x : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x s) (Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) x)))))
-Case conversion may be inaccurate. Consider using '#align is_seq_compact.exists_tendsto_of_frequently_mem IsSeqCompact.exists_tendsto_of_frequently_memₓ'. -/
 theorem IsSeqCompact.exists_tendsto_of_frequently_mem (hs : IsSeqCompact s) {u : ℕ → X}
     (hu : ∃ᶠ n in atTop, u n ∈ s) (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x) :=
   let ⟨x, hxs, φ, φ_mono, hx⟩ := hs.subseq_of_frequently_in hu
   ⟨x, hxs, tendsto_nhds_of_cauchySeq_of_subseq huc φ_mono.tendsto_atTop hx⟩
 #align is_seq_compact.exists_tendsto_of_frequently_mem IsSeqCompact.exists_tendsto_of_frequently_mem
 
-/- warning: is_seq_compact.exists_tendsto -> IsSeqCompact.exists_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : UniformSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) s) -> (forall {u : Nat -> X}, (forall (n : Nat), Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (u n) s) -> (CauchySeq.{u1, 0} X Nat _inst_1 (CanonicallyLinearOrderedAddMonoid.semilatticeSup.{0} Nat Nat.canonicallyLinearOrderedAddMonoid) u) -> (Exists.{succ u1} X (fun (x : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) => Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) x)))))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : UniformSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) s) -> (forall {u : Nat -> X}, (forall (n : Nat), Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (u n) s) -> (CauchySeq.{u1, 0} X Nat _inst_1 (Lattice.toSemilatticeSup.{0} Nat (DistribLattice.toLattice.{0} Nat instDistribLatticeNat)) u) -> (Exists.{succ u1} X (fun (x : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x s) (Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) x)))))
-Case conversion may be inaccurate. Consider using '#align is_seq_compact.exists_tendsto IsSeqCompact.exists_tendstoₓ'. -/
 theorem IsSeqCompact.exists_tendsto (hs : IsSeqCompact s) {u : ℕ → X} (hu : ∀ n, u n ∈ s)
     (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x) :=
   hs.exists_tendsto_of_frequently_mem (frequently_of_forall hu) huc
@@ -545,12 +485,6 @@ variable [PseudoMetricSpace X]
 
 open Metric
 
-/- warning: seq_compact.lebesgue_number_lemma_of_metric -> SeqCompact.lebesgue_number_lemma_of_metric is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] {ι : Sort.{u2}} {c : ι -> (Set.{u1} X)} {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s) -> (forall (i : ι), IsOpen.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) (c i)) -> (HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) s (Set.iUnion.{u1, u2} X ι (fun (i : ι) => c i))) -> (Exists.{1} Real (fun (δ : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall (a : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) -> (Exists.{u2} ι (fun (i : ι) => HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (Metric.ball.{u1} X _inst_1 a δ) (c i))))))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] {ι : Sort.{u2}} {c : ι -> (Set.{u1} X)} {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s) -> (forall (i : ι), IsOpen.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) (c i)) -> (HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) s (Set.iUnion.{u1, u2} X ι (fun (i : ι) => c i))) -> (Exists.{1} Real (fun (δ : Real) => And (GT.gt.{0} Real Real.instLTReal δ (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall (a : X), (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) -> (Exists.{u2} ι (fun (i : ι) => HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) (Metric.ball.{u1} X _inst_1 a δ) (c i))))))
-Case conversion may be inaccurate. Consider using '#align seq_compact.lebesgue_number_lemma_of_metric SeqCompact.lebesgue_number_lemma_of_metricₓ'. -/
 theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort _} {c : ι → Set X} {s : Set X}
     (hs : IsSeqCompact s) (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i, c i) :
     ∃ δ > 0, ∀ a ∈ s, ∃ i, ball a δ ⊆ c i :=
@@ -559,12 +493,6 @@ theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort _} {c : ι → Set
 
 variable [ProperSpace X] {s : Set X}
 
-/- warning: tendsto_subseq_of_frequently_bounded -> tendsto_subseq_of_frequently_bounded is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] [_inst_2 : ProperSpace.{u1} X _inst_1] {s : Set.{u1} X}, (Metric.Bounded.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) a)))))))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] [_inst_2 : ProperSpace.{u1} X _inst_1] {s : Set.{u1} X}, (Metric.Bounded.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) a)))))))
-Case conversion may be inaccurate. Consider using '#align tendsto_subseq_of_frequently_bounded tendsto_subseq_of_frequently_boundedₓ'. -/
 /-- A version of **Bolzano-Weistrass**: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. This version assumes only
 that the sequence is frequently in some bounded set. -/
@@ -576,12 +504,6 @@ theorem tendsto_subseq_of_frequently_bounded (hs : Bounded s) {x : ℕ → X}
   hcs.subseq_of_frequently_in hu'
 #align tendsto_subseq_of_frequently_bounded tendsto_subseq_of_frequently_bounded
 
-/- warning: tendsto_subseq_of_bounded -> tendsto_subseq_of_bounded is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] [_inst_2 : ProperSpace.{u1} X _inst_1] {s : Set.{u1} X}, (Metric.Bounded.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (forall (n : Nat), Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) a)))))))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] [_inst_2 : ProperSpace.{u1} X _inst_1] {s : Set.{u1} X}, (Metric.Bounded.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (forall (n : Nat), Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) a)))))))
-Case conversion may be inaccurate. Consider using '#align tendsto_subseq_of_bounded tendsto_subseq_of_boundedₓ'. -/
 /-- A version of Bolzano-Weistrass: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. -/
 theorem tendsto_subseq_of_bounded (hs : Bounded s) {x : ℕ → X} (hx : ∀ n, x n ∈ s) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -158,10 +158,8 @@ theorem seqClosure_eq_closure [FrechetUrysohnSpace X] (s : Set X) : seqClosure s
 /-- In a Fréchet-Urysohn space, a point belongs to the closure of a set iff it is a limit
 of a sequence taking values in this set. -/
 theorem mem_closure_iff_seq_limit [FrechetUrysohnSpace X] {s : Set X} {a : X} :
-    a ∈ closure s ↔ ∃ x : ℕ → X, (∀ n : ℕ, x n ∈ s) ∧ Tendsto x atTop (𝓝 a) :=
-  by
-  rw [← seqClosure_eq_closure]
-  rfl
+    a ∈ closure s ↔ ∃ x : ℕ → X, (∀ n : ℕ, x n ∈ s) ∧ Tendsto x atTop (𝓝 a) := by
+  rw [← seqClosure_eq_closure]; rfl
 #align mem_closure_iff_seq_limit mem_closure_iff_seq_limit
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -549,9 +549,9 @@ open Metric
 
 /- warning: seq_compact.lebesgue_number_lemma_of_metric -> SeqCompact.lebesgue_number_lemma_of_metric is a dubious translation:
 lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] {ι : Sort.{u2}} {c : ι -> (Set.{u1} X)} {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s) -> (forall (i : ι), IsOpen.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) (c i)) -> (HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) s (Set.unionᵢ.{u1, u2} X ι (fun (i : ι) => c i))) -> (Exists.{1} Real (fun (δ : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall (a : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) -> (Exists.{u2} ι (fun (i : ι) => HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (Metric.ball.{u1} X _inst_1 a δ) (c i))))))
+  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] {ι : Sort.{u2}} {c : ι -> (Set.{u1} X)} {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s) -> (forall (i : ι), IsOpen.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) (c i)) -> (HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) s (Set.iUnion.{u1, u2} X ι (fun (i : ι) => c i))) -> (Exists.{1} Real (fun (δ : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall (a : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) -> (Exists.{u2} ι (fun (i : ι) => HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (Metric.ball.{u1} X _inst_1 a δ) (c i))))))
 but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] {ι : Sort.{u2}} {c : ι -> (Set.{u1} X)} {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s) -> (forall (i : ι), IsOpen.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) (c i)) -> (HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) s (Set.unionᵢ.{u1, u2} X ι (fun (i : ι) => c i))) -> (Exists.{1} Real (fun (δ : Real) => And (GT.gt.{0} Real Real.instLTReal δ (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall (a : X), (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) -> (Exists.{u2} ι (fun (i : ι) => HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) (Metric.ball.{u1} X _inst_1 a δ) (c i))))))
+  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] {ι : Sort.{u2}} {c : ι -> (Set.{u1} X)} {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s) -> (forall (i : ι), IsOpen.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) (c i)) -> (HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) s (Set.iUnion.{u1, u2} X ι (fun (i : ι) => c i))) -> (Exists.{1} Real (fun (δ : Real) => And (GT.gt.{0} Real Real.instLTReal δ (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall (a : X), (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) -> (Exists.{u2} ι (fun (i : ι) => HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) (Metric.ball.{u1} X _inst_1 a δ) (c i))))))
 Case conversion may be inaccurate. Consider using '#align seq_compact.lebesgue_number_lemma_of_metric SeqCompact.lebesgue_number_lemma_of_metricₓ'. -/
 theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort _} {c : ι → Set X} {s : Set X}
     (hs : IsSeqCompact s) (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i, c i) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jan-David Salchow, Patrick Massot, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module topology.sequences
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Topology.MetricSpace.Basic
 /-!
 # Sequences in topological spaces
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we define sequences in topological spaces and show how they are related to
 filters and the topology.
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/62e8311c791f02c47451bf14aa2501048e7c2f33

@@ -76,61 +76,82 @@ section TopologicalSpace
 
 variable [TopologicalSpace X] [TopologicalSpace Y]
 
+#print seqClosure /-
 /-- The sequential closure of a set `s : set X` in a topological space `X` is the set of all `a : X`
 which arise as limit of sequences in `s`. Note that the sequential closure of a set is not
 guaranteed to be sequentially closed. -/
 def seqClosure (s : Set X) : Set X :=
   { a | ∃ x : ℕ → X, (∀ n : ℕ, x n ∈ s) ∧ Tendsto x atTop (𝓝 a) }
 #align seq_closure seqClosure
+-/
 
+#print subset_seqClosure /-
 theorem subset_seqClosure {s : Set X} : s ⊆ seqClosure s := fun p hp =>
   ⟨const ℕ p, fun _ => hp, tendsto_const_nhds⟩
 #align subset_seq_closure subset_seqClosure
+-/
 
+#print seqClosure_subset_closure /-
 /-- The sequential closure of a set is contained in the closure of that set.
 The converse is not true. -/
 theorem seqClosure_subset_closure {s : Set X} : seqClosure s ⊆ closure s := fun p ⟨x, xM, xp⟩ =>
   mem_closure_of_tendsto xp (univ_mem' xM)
 #align seq_closure_subset_closure seqClosure_subset_closure
+-/
 
+#print IsSeqClosed /-
 /-- A set `s` is sequentially closed if for any converging sequence `x n` of elements of `s`, the
 limit belongs to `s` as well. Note that the sequential closure of a set is not guaranteed to be
 sequentially closed. -/
 def IsSeqClosed (s : Set X) : Prop :=
   ∀ ⦃x : ℕ → X⦄ ⦃p : X⦄, (∀ n, x n ∈ s) → Tendsto x atTop (𝓝 p) → p ∈ s
 #align is_seq_closed IsSeqClosed
+-/
 
+#print IsSeqClosed.seqClosure_eq /-
 /-- The sequential closure of a sequentially closed set is the set itself. -/
 theorem IsSeqClosed.seqClosure_eq {s : Set X} (hs : IsSeqClosed s) : seqClosure s = s :=
   Subset.antisymm (fun p ⟨x, hx, hp⟩ => hs hx hp) subset_seqClosure
 #align is_seq_closed.seq_closure_eq IsSeqClosed.seqClosure_eq
+-/
 
+#print isSeqClosed_of_seqClosure_eq /-
 /-- If a set is equal to its sequential closure, then it is sequentially closed. -/
 theorem isSeqClosed_of_seqClosure_eq {s : Set X} (hs : seqClosure s = s) : IsSeqClosed s :=
   fun x p hxs hxp => hs ▸ ⟨x, hxs, hxp⟩
 #align is_seq_closed_of_seq_closure_eq isSeqClosed_of_seqClosure_eq
+-/
 
+#print isSeqClosed_iff /-
 /-- A set is sequentially closed iff it is equal to its sequential closure. -/
 theorem isSeqClosed_iff {s : Set X} : IsSeqClosed s ↔ seqClosure s = s :=
   ⟨IsSeqClosed.seqClosure_eq, isSeqClosed_of_seqClosure_eq⟩
 #align is_seq_closed_iff isSeqClosed_iff
+-/
 
+#print IsClosed.isSeqClosed /-
 /-- A set is sequentially closed if it is closed. -/
 protected theorem IsClosed.isSeqClosed {s : Set X} (hc : IsClosed s) : IsSeqClosed s :=
   fun u x hu hx => hc.mem_of_tendsto hx (eventually_of_forall hu)
 #align is_closed.is_seq_closed IsClosed.isSeqClosed
+-/
 
+#print FrechetUrysohnSpace /-
 /-- A topological space is called a *Fréchet-Urysohn space*, if the sequential closure of any set
 is equal to its closure. Since one of the inclusions is trivial, we require only the non-trivial one
 in the definition. -/
 class FrechetUrysohnSpace (X : Type _) [TopologicalSpace X] : Prop where
   closure_subset_seqClosure : ∀ s : Set X, closure s ⊆ seqClosure s
 #align frechet_urysohn_space FrechetUrysohnSpace
+-/
 
+#print seqClosure_eq_closure /-
 theorem seqClosure_eq_closure [FrechetUrysohnSpace X] (s : Set X) : seqClosure s = closure s :=
   seqClosure_subset_closure.antisymm <| FrechetUrysohnSpace.closure_subset_seqClosure s
 #align seq_closure_eq_closure seqClosure_eq_closure
+-/
 
+#print mem_closure_iff_seq_limit /-
 /-- In a Fréchet-Urysohn space, a point belongs to the closure of a set iff it is a limit
 of a sequence taking values in this set. -/
 theorem mem_closure_iff_seq_limit [FrechetUrysohnSpace X] {s : Set X} {a : X} :
@@ -139,7 +160,14 @@ theorem mem_closure_iff_seq_limit [FrechetUrysohnSpace X] {s : Set X} {a : X} :
   rw [← seqClosure_eq_closure]
   rfl
 #align mem_closure_iff_seq_limit mem_closure_iff_seq_limit
+-/
 
+/- warning: tendsto_nhds_iff_seq_tendsto -> tendsto_nhds_iff_seq_tendsto is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : FrechetUrysohnSpace.{u1} X _inst_1] {f : X -> Y} {a : X} {b : Y}, Iff (Filter.Tendsto.{u1, u2} X Y f (nhds.{u1} X _inst_1 a) (nhds.{u2} Y _inst_2 b)) (forall (u : Nat -> X), (Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X _inst_1 a)) -> (Filter.Tendsto.{0, u2} Nat Y (Function.comp.{1, succ u1, succ u2} Nat X Y f u) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u2} Y _inst_2 b)))
+but is expected to have type
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] [_inst_3 : FrechetUrysohnSpace.{u2} X _inst_1] {f : X -> Y} {a : X} {b : Y}, Iff (Filter.Tendsto.{u2, u1} X Y f (nhds.{u2} X _inst_1 a) (nhds.{u1} Y _inst_2 b)) (forall (u : Nat -> X), (Filter.Tendsto.{0, u2} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u2} X _inst_1 a)) -> (Filter.Tendsto.{0, u1} Nat Y (Function.comp.{1, succ u2, succ u1} Nat X Y f u) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} Y _inst_2 b)))
+Case conversion may be inaccurate. Consider using '#align tendsto_nhds_iff_seq_tendsto tendsto_nhds_iff_seq_tendstoₓ'. -/
 /-- If the domain of a function `f : α → β` is a Fréchet-Urysohn space, then convergence
 is equivalent to sequential convergence. See also `filter.tendsto_iff_seq_tendsto` for a version
 that works for any pair of filters assuming that the filter in the domain is countably generated.
@@ -159,6 +187,7 @@ theorem tendsto_nhds_iff_seq_tendsto [FrechetUrysohnSpace X] {f : X → Y} {a :
   exact hsc.mem_of_tendsto (h u hu) (eventually_of_forall hus)
 #align tendsto_nhds_iff_seq_tendsto tendsto_nhds_iff_seq_tendsto
 
+#print FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto /-
 /-- An alternative construction for `frechet_urysohn_space`: if sequential convergence implies
 convergence, then the space is a Fréchet-Urysohn space. -/
 theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
@@ -177,61 +206,94 @@ theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
   rcases extraction_of_frequently_at_top hus with ⟨φ, φ_mono, hφ⟩
   exact ⟨u ∘ φ, hφ, hux.comp φ_mono.tendsto_at_top⟩
 #align frechet_urysohn_space.of_seq_tendsto_imp_tendsto FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
+-/
 
+#print TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace /-
 -- see Note [lower instance priority]
 /-- Every first-countable space is a Fréchet-Urysohn space. -/
 instance (priority := 100) TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace
     [FirstCountableTopology X] : FrechetUrysohnSpace X :=
   FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto fun f a => tendsto_iff_seq_tendsto.2
 #align topological_space.first_countable_topology.frechet_urysohn_space TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace
+-/
 
+#print SequentialSpace /-
 /-- A topological space is said to be a *sequential space* if any sequentially closed set in this
 space is closed. This condition is weaker than being a Fréchet-Urysohn space. -/
 class SequentialSpace (X : Type _) [TopologicalSpace X] : Prop where
   isClosed_of_seq : ∀ s : Set X, IsSeqClosed s → IsClosed s
 #align sequential_space SequentialSpace
+-/
 
+#print FrechetUrysohnSpace.to_sequentialSpace /-
 -- see Note [lower instance priority]
 /-- Every Fréchet-Urysohn space is a sequential space. -/
 instance (priority := 100) FrechetUrysohnSpace.to_sequentialSpace [FrechetUrysohnSpace X] :
     SequentialSpace X :=
   ⟨fun s hs => by rw [← closure_eq_iff_isClosed, ← seqClosure_eq_closure, hs.seq_closure_eq]⟩
 #align frechet_urysohn_space.to_sequential_space FrechetUrysohnSpace.to_sequentialSpace
+-/
 
+#print IsSeqClosed.isClosed /-
 /-- In a sequential space, a sequentially closed set is closed. -/
 protected theorem IsSeqClosed.isClosed [SequentialSpace X] {s : Set X} (hs : IsSeqClosed s) :
     IsClosed s :=
   SequentialSpace.isClosed_of_seq s hs
 #align is_seq_closed.is_closed IsSeqClosed.isClosed
+-/
 
+#print isSeqClosed_iff_isClosed /-
 /-- In a sequential space, a set is closed iff it's sequentially closed. -/
 theorem isSeqClosed_iff_isClosed [SequentialSpace X] {M : Set X} : IsSeqClosed M ↔ IsClosed M :=
   ⟨IsSeqClosed.isClosed, IsClosed.isSeqClosed⟩
 #align is_seq_closed_iff_is_closed isSeqClosed_iff_isClosed
+-/
 
+#print SeqContinuous /-
 /-- A function between topological spaces is sequentially continuous if it commutes with limit of
  convergent sequences. -/
 def SeqContinuous (f : X → Y) : Prop :=
   ∀ ⦃x : ℕ → X⦄ ⦃p : X⦄, Tendsto x atTop (𝓝 p) → Tendsto (f ∘ x) atTop (𝓝 (f p))
 #align seq_continuous SeqContinuous
+-/
 
+#print IsSeqClosed.preimage /-
 /-- The preimage of a sequentially closed set under a sequentially continuous map is sequentially
 closed. -/
 theorem IsSeqClosed.preimage {f : X → Y} {s : Set Y} (hs : IsSeqClosed s) (hf : SeqContinuous f) :
     IsSeqClosed (f ⁻¹' s) := fun x p hx hp => hs hx (hf hp)
 #align is_seq_closed.preimage IsSeqClosed.preimage
+-/
 
+/- warning: continuous.seq_continuous -> Continuous.seqContinuous is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] {f : X -> Y}, (Continuous.{u1, u2} X Y _inst_1 _inst_2 f) -> (SeqContinuous.{u1, u2} X Y _inst_1 _inst_2 f)
+but is expected to have type
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] {f : X -> Y}, (Continuous.{u2, u1} X Y _inst_1 _inst_2 f) -> (SeqContinuous.{u2, u1} X Y _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align continuous.seq_continuous Continuous.seqContinuousₓ'. -/
 -- A continuous function is sequentially continuous.
 protected theorem Continuous.seqContinuous {f : X → Y} (hf : Continuous f) : SeqContinuous f :=
   fun x p hx => (hf.Tendsto p).comp hx
 #align continuous.seq_continuous Continuous.seqContinuous
 
+/- warning: seq_continuous.continuous -> SeqContinuous.continuous is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : SequentialSpace.{u1} X _inst_1] {f : X -> Y}, (SeqContinuous.{u1, u2} X Y _inst_1 _inst_2 f) -> (Continuous.{u1, u2} X Y _inst_1 _inst_2 f)
+but is expected to have type
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] [_inst_3 : SequentialSpace.{u2} X _inst_1] {f : X -> Y}, (SeqContinuous.{u2, u1} X Y _inst_1 _inst_2 f) -> (Continuous.{u2, u1} X Y _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align seq_continuous.continuous SeqContinuous.continuousₓ'. -/
 /-- A sequentially continuous function defined on a sequential space is continuous. -/
 protected theorem SeqContinuous.continuous [SequentialSpace X] {f : X → Y} (hf : SeqContinuous f) :
     Continuous f :=
   continuous_iff_isClosed.mpr fun s hs => (hs.IsSeqClosed.Preimage hf).IsClosed
 #align seq_continuous.continuous SeqContinuous.continuous
 
+/- warning: continuous_iff_seq_continuous -> continuous_iff_seqContinuous is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : SequentialSpace.{u1} X _inst_1] {f : X -> Y}, Iff (Continuous.{u1, u2} X Y _inst_1 _inst_2 f) (SeqContinuous.{u1, u2} X Y _inst_1 _inst_2 f)
+but is expected to have type
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] [_inst_3 : SequentialSpace.{u2} X _inst_1] {f : X -> Y}, Iff (Continuous.{u2, u1} X Y _inst_1 _inst_2 f) (SeqContinuous.{u2, u1} X Y _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align continuous_iff_seq_continuous continuous_iff_seqContinuousₓ'. -/
 /-- If the domain of a function is a sequential space, then continuity of this function is
 equivalent to its sequential continuity. -/
 theorem continuous_iff_seqContinuous [SequentialSpace X] {f : X → Y} :
@@ -239,6 +301,12 @@ theorem continuous_iff_seqContinuous [SequentialSpace X] {f : X → Y} :
   ⟨Continuous.seqContinuous, SeqContinuous.continuous⟩
 #align continuous_iff_seq_continuous continuous_iff_seqContinuous
 
+/- warning: quotient_map.sequential_space -> QuotientMap.sequentialSpace is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : SequentialSpace.{u1} X _inst_1] {f : X -> Y}, (QuotientMap.{u1, u2} X Y _inst_1 _inst_2 f) -> (SequentialSpace.{u2} Y _inst_2)
+but is expected to have type
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] [_inst_3 : SequentialSpace.{u2} X _inst_1] {f : X -> Y}, (QuotientMap.{u2, u1} X Y _inst_1 _inst_2 f) -> (SequentialSpace.{u1} Y _inst_2)
+Case conversion may be inaccurate. Consider using '#align quotient_map.sequential_space QuotientMap.sequentialSpaceₓ'. -/
 theorem QuotientMap.sequentialSpace [SequentialSpace X] {f : X → Y} (hf : QuotientMap f) :
     SequentialSpace Y :=
   ⟨fun s hs => hf.isClosed_preimage.mp <| (hs.Preimage <| hf.Continuous.SeqContinuous).IsClosed⟩
@@ -256,21 +324,31 @@ open TopologicalSpace TopologicalSpace.FirstCountableTopology
 
 variable [TopologicalSpace X]
 
+#print IsSeqCompact /-
 /-- A set `s` is sequentially compact if every sequence taking values in `s` has a
 converging subsequence. -/
 def IsSeqCompact (s : Set X) :=
   ∀ ⦃x : ℕ → X⦄, (∀ n, x n ∈ s) → ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a)
 #align is_seq_compact IsSeqCompact
+-/
 
+#print SeqCompactSpace /-
 /-- A space `X` is sequentially compact if every sequence in `X` has a
 converging subsequence. -/
 @[mk_iff]
 class SeqCompactSpace (X : Type _) [TopologicalSpace X] : Prop where
   seq_compact_univ : IsSeqCompact (univ : Set X)
 #align seq_compact_space SeqCompactSpace
+-/
 
 export SeqCompactSpace (seq_compact_univ)
 
+/- warning: is_seq_compact.subseq_of_frequently_in -> IsSeqCompact.subseq_of_frequently_in is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X _inst_1 a)))))))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X _inst_1 a)))))))
+Case conversion may be inaccurate. Consider using '#align is_seq_compact.subseq_of_frequently_in IsSeqCompact.subseq_of_frequently_inₓ'. -/
 theorem IsSeqCompact.subseq_of_frequently_in {s : Set X} (hs : IsSeqCompact s) {x : ℕ → X}
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
@@ -279,11 +357,13 @@ theorem IsSeqCompact.subseq_of_frequently_in {s : Set X} (hs : IsSeqCompact s) {
   ⟨a, a_in, ψ ∘ φ, hψ.comp hφ, h⟩
 #align is_seq_compact.subseq_of_frequently_in IsSeqCompact.subseq_of_frequently_in
 
+#print SeqCompactSpace.tendsto_subseq /-
 theorem SeqCompactSpace.tendsto_subseq [SeqCompactSpace X] (x : ℕ → X) :
     ∃ (a : _)(φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   let ⟨a, _, φ, mono, h⟩ := seq_compact_univ fun n => mem_univ (x n)
   ⟨a, φ, mono, h⟩
 #align seq_compact_space.tendsto_subseq SeqCompactSpace.tendsto_subseq
+-/
 
 section FirstCountableTopology
 
@@ -291,33 +371,51 @@ variable [FirstCountableTopology X]
 
 open TopologicalSpace.FirstCountableTopology
 
+#print IsCompact.isSeqCompact /-
 protected theorem IsCompact.isSeqCompact {s : Set X} (hs : IsCompact s) : IsSeqCompact s :=
   fun x x_in =>
   let ⟨a, a_in, ha⟩ := hs (tendsto_principal.mpr (eventually_of_forall x_in))
   ⟨a, a_in, tendsto_subseq ha⟩
 #align is_compact.is_seq_compact IsCompact.isSeqCompact
+-/
 
+/- warning: is_compact.tendsto_subseq' -> IsCompact.tendsto_subseq' is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.FirstCountableTopology.{u1} X _inst_1] {s : Set.{u1} X} {x : Nat -> X}, (IsCompact.{u1} X _inst_1 s) -> (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X _inst_1 a))))))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.FirstCountableTopology.{u1} X _inst_1] {s : Set.{u1} X} {x : Nat -> X}, (IsCompact.{u1} X _inst_1 s) -> (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X _inst_1 a))))))
+Case conversion may be inaccurate. Consider using '#align is_compact.tendsto_subseq' IsCompact.tendsto_subseq'ₓ'. -/
 theorem IsCompact.tendsto_subseq' {s : Set X} {x : ℕ → X} (hs : IsCompact s)
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   hs.IsSeqCompact.subseq_of_frequently_in hx
 #align is_compact.tendsto_subseq' IsCompact.tendsto_subseq'
 
+/- warning: is_compact.tendsto_subseq -> IsCompact.tendsto_subseq is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.FirstCountableTopology.{u1} X _inst_1] {s : Set.{u1} X} {x : Nat -> X}, (IsCompact.{u1} X _inst_1 s) -> (forall (n : Nat), Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X _inst_1 a))))))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.FirstCountableTopology.{u1} X _inst_1] {s : Set.{u1} X} {x : Nat -> X}, (IsCompact.{u1} X _inst_1 s) -> (forall (n : Nat), Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X _inst_1 a))))))
+Case conversion may be inaccurate. Consider using '#align is_compact.tendsto_subseq IsCompact.tendsto_subseqₓ'. -/
 theorem IsCompact.tendsto_subseq {s : Set X} {x : ℕ → X} (hs : IsCompact s) (hx : ∀ n, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   hs.IsSeqCompact hx
 #align is_compact.tendsto_subseq IsCompact.tendsto_subseq
 
+#print FirstCountableTopology.seq_compact_of_compact /-
 -- see Note [lower instance priority]
 instance (priority := 100) FirstCountableTopology.seq_compact_of_compact [CompactSpace X] :
     SeqCompactSpace X :=
   ⟨isCompact_univ.IsSeqCompact⟩
 #align first_countable_topology.seq_compact_of_compact FirstCountableTopology.seq_compact_of_compact
+-/
 
+#print CompactSpace.tendsto_subseq /-
 theorem CompactSpace.tendsto_subseq [CompactSpace X] (x : ℕ → X) :
     ∃ (a : _)(φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   SeqCompactSpace.tendsto_subseq x
 #align compact_space.tendsto_subseq CompactSpace.tendsto_subseq
+-/
 
 end FirstCountableTopology
 
@@ -331,17 +429,30 @@ open UniformSpace Prod
 
 variable [UniformSpace X] {s : Set X}
 
+/- warning: is_seq_compact.exists_tendsto_of_frequently_mem -> IsSeqCompact.exists_tendsto_of_frequently_mem is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : UniformSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) s) -> (forall {u : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (u n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) -> (CauchySeq.{u1, 0} X Nat _inst_1 (CanonicallyLinearOrderedAddMonoid.semilatticeSup.{0} Nat Nat.canonicallyLinearOrderedAddMonoid) u) -> (Exists.{succ u1} X (fun (x : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) => Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) x)))))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : UniformSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) s) -> (forall {u : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (u n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) -> (CauchySeq.{u1, 0} X Nat _inst_1 (Lattice.toSemilatticeSup.{0} Nat (DistribLattice.toLattice.{0} Nat instDistribLatticeNat)) u) -> (Exists.{succ u1} X (fun (x : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x s) (Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) x)))))
+Case conversion may be inaccurate. Consider using '#align is_seq_compact.exists_tendsto_of_frequently_mem IsSeqCompact.exists_tendsto_of_frequently_memₓ'. -/
 theorem IsSeqCompact.exists_tendsto_of_frequently_mem (hs : IsSeqCompact s) {u : ℕ → X}
     (hu : ∃ᶠ n in atTop, u n ∈ s) (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x) :=
   let ⟨x, hxs, φ, φ_mono, hx⟩ := hs.subseq_of_frequently_in hu
   ⟨x, hxs, tendsto_nhds_of_cauchySeq_of_subseq huc φ_mono.tendsto_atTop hx⟩
 #align is_seq_compact.exists_tendsto_of_frequently_mem IsSeqCompact.exists_tendsto_of_frequently_mem
 
+/- warning: is_seq_compact.exists_tendsto -> IsSeqCompact.exists_tendsto is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : UniformSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) s) -> (forall {u : Nat -> X}, (forall (n : Nat), Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (u n) s) -> (CauchySeq.{u1, 0} X Nat _inst_1 (CanonicallyLinearOrderedAddMonoid.semilatticeSup.{0} Nat Nat.canonicallyLinearOrderedAddMonoid) u) -> (Exists.{succ u1} X (fun (x : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) => Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) x)))))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : UniformSpace.{u1} X] {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) s) -> (forall {u : Nat -> X}, (forall (n : Nat), Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (u n) s) -> (CauchySeq.{u1, 0} X Nat _inst_1 (Lattice.toSemilatticeSup.{0} Nat (DistribLattice.toLattice.{0} Nat instDistribLatticeNat)) u) -> (Exists.{succ u1} X (fun (x : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x s) (Filter.Tendsto.{0, u1} Nat X u (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X _inst_1) x)))))
+Case conversion may be inaccurate. Consider using '#align is_seq_compact.exists_tendsto IsSeqCompact.exists_tendstoₓ'. -/
 theorem IsSeqCompact.exists_tendsto (hs : IsSeqCompact s) {u : ℕ → X} (hu : ∀ n, u n ∈ s)
     (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x) :=
   hs.exists_tendsto_of_frequently_mem (frequently_of_forall hu) huc
 #align is_seq_compact.exists_tendsto IsSeqCompact.exists_tendsto
 
+#print IsSeqCompact.totallyBounded /-
 /-- A sequentially compact set in a uniform space is totally bounded. -/
 protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBounded s :=
   by
@@ -357,12 +468,14 @@ protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBoun
   exact huφ.cauchy_seq.mem_entourage V_in
   exact hu (φ <| N + 1) (φ N) (hφ <| lt_add_one N) (hN (N + 1) N N.le_succ le_rfl)
 #align is_seq_compact.totally_bounded IsSeqCompact.totallyBounded
+-/
 
 variable [IsCountablyGenerated (𝓤 X)]
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print IsSeqCompact.isComplete /-
 /-- A sequentially compact set in a uniform set with countably generated uniformity filter
 is complete. -/
 protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s :=
@@ -400,21 +513,28 @@ protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s :
   refine' mem_of_superset (htl n) fun y hy => hWV N ⟨u n, _, htW N ⟨_, _⟩⟩
   exacts[hn, ht_anti hNn (hu n), ht_anti hNn hy]
 #align is_seq_compact.is_complete IsSeqCompact.isComplete
+-/
 
+#print IsSeqCompact.isCompact /-
 /-- If `𝓤 β` is countably generated, then any sequentially compact set is compact. -/
 protected theorem IsSeqCompact.isCompact (hs : IsSeqCompact s) : IsCompact s :=
   isCompact_iff_totallyBounded_isComplete.2 ⟨hs.TotallyBounded, hs.IsComplete⟩
 #align is_seq_compact.is_compact IsSeqCompact.isCompact
+-/
 
+#print UniformSpace.isCompact_iff_isSeqCompact /-
 /-- A version of Bolzano-Weistrass: in a uniform space with countably generated uniformity filter
 (e.g., in a metric space), a set is compact if and only if it is sequentially compact. -/
 protected theorem UniformSpace.isCompact_iff_isSeqCompact : IsCompact s ↔ IsSeqCompact s :=
   ⟨fun H => H.IsSeqCompact, fun H => H.IsCompact⟩
 #align uniform_space.is_compact_iff_is_seq_compact UniformSpace.isCompact_iff_isSeqCompact
+-/
 
+#print UniformSpace.compactSpace_iff_seqCompactSpace /-
 theorem UniformSpace.compactSpace_iff_seqCompactSpace : CompactSpace X ↔ SeqCompactSpace X := by
   simp only [← isCompact_univ_iff, seqCompactSpace_iff, UniformSpace.isCompact_iff_isSeqCompact]
 #align uniform_space.compact_space_iff_seq_compact_space UniformSpace.compactSpace_iff_seqCompactSpace
+-/
 
 end UniformSpaceSeqCompact
 
@@ -424,6 +544,12 @@ variable [PseudoMetricSpace X]
 
 open Metric
 
+/- warning: seq_compact.lebesgue_number_lemma_of_metric -> SeqCompact.lebesgue_number_lemma_of_metric is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] {ι : Sort.{u2}} {c : ι -> (Set.{u1} X)} {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s) -> (forall (i : ι), IsOpen.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) (c i)) -> (HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) s (Set.unionᵢ.{u1, u2} X ι (fun (i : ι) => c i))) -> (Exists.{1} Real (fun (δ : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall (a : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a s) -> (Exists.{u2} ι (fun (i : ι) => HasSubset.Subset.{u1} (Set.{u1} X) (Set.hasSubset.{u1} X) (Metric.ball.{u1} X _inst_1 a δ) (c i))))))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] {ι : Sort.{u2}} {c : ι -> (Set.{u1} X)} {s : Set.{u1} X}, (IsSeqCompact.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s) -> (forall (i : ι), IsOpen.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) (c i)) -> (HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) s (Set.unionᵢ.{u1, u2} X ι (fun (i : ι) => c i))) -> (Exists.{1} Real (fun (δ : Real) => And (GT.gt.{0} Real Real.instLTReal δ (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall (a : X), (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a s) -> (Exists.{u2} ι (fun (i : ι) => HasSubset.Subset.{u1} (Set.{u1} X) (Set.instHasSubsetSet.{u1} X) (Metric.ball.{u1} X _inst_1 a δ) (c i))))))
+Case conversion may be inaccurate. Consider using '#align seq_compact.lebesgue_number_lemma_of_metric SeqCompact.lebesgue_number_lemma_of_metricₓ'. -/
 theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort _} {c : ι → Set X} {s : Set X}
     (hs : IsSeqCompact s) (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i, c i) :
     ∃ δ > 0, ∀ a ∈ s, ∃ i, ball a δ ⊆ c i :=
@@ -432,6 +558,12 @@ theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort _} {c : ι → Set
 
 variable [ProperSpace X] {s : Set X}
 
+/- warning: tendsto_subseq_of_frequently_bounded -> tendsto_subseq_of_frequently_bounded is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] [_inst_2 : ProperSpace.{u1} X _inst_1] {s : Set.{u1} X}, (Metric.Bounded.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) a)))))))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] [_inst_2 : ProperSpace.{u1} X _inst_1] {s : Set.{u1} X}, (Metric.Bounded.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (Filter.Frequently.{0} Nat (fun (n : Nat) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) a)))))))
+Case conversion may be inaccurate. Consider using '#align tendsto_subseq_of_frequently_bounded tendsto_subseq_of_frequently_boundedₓ'. -/
 /-- A version of **Bolzano-Weistrass**: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. This version assumes only
 that the sequence is frequently in some bounded set. -/
@@ -443,6 +575,12 @@ theorem tendsto_subseq_of_frequently_bounded (hs : Bounded s) {x : ℕ → X}
   hcs.subseq_of_frequently_in hu'
 #align tendsto_subseq_of_frequently_bounded tendsto_subseq_of_frequently_bounded
 
+/- warning: tendsto_subseq_of_bounded -> tendsto_subseq_of_bounded is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] [_inst_2 : ProperSpace.{u1} X _inst_1] {s : Set.{u1} X}, (Metric.Bounded.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (forall (n : Nat), Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) (x n) s) -> (Exists.{succ u1} X (fun (a : X) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) (fun (H : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) => Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) a)))))))
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} X] [_inst_2 : ProperSpace.{u1} X _inst_1] {s : Set.{u1} X}, (Metric.Bounded.{u1} X _inst_1 s) -> (forall {x : Nat -> X}, (forall (n : Nat), Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (x n) s) -> (Exists.{succ u1} X (fun (a : X) => And (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) a (closure.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) s)) (Exists.{1} (Nat -> Nat) (fun (φ : Nat -> Nat) => And (StrictMono.{0, 0} Nat Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) φ) (Filter.Tendsto.{0, u1} Nat X (Function.comp.{1, 1, succ u1} Nat Nat X x φ) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} X (UniformSpace.toTopologicalSpace.{u1} X (PseudoMetricSpace.toUniformSpace.{u1} X _inst_1)) a)))))))
+Case conversion may be inaccurate. Consider using '#align tendsto_subseq_of_bounded tendsto_subseq_of_boundedₓ'. -/
 /-- A version of Bolzano-Weistrass: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. -/
 theorem tendsto_subseq_of_bounded (hs : Bounded s) {x : ℕ → X} (hx : ∀ n, x n ∈ s) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

A PR analogous to #12338 and #12361: reformatting proofs following the multiple goals linter of #12339.

@@ -292,8 +292,8 @@ protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBoun
     simpa only [forall_and, forall_mem_image, not_and] using seq_of_forall_finite_exists h
   refine' ⟨u, u_in, fun x _ φ hφ huφ => _⟩
   obtain ⟨N, hN⟩ : ∃ N, ∀ p q, p ≥ N → q ≥ N → (u (φ p), u (φ q)) ∈ V
-  exact huφ.cauchySeq.mem_entourage V_in
-  exact hu (φ <| N + 1) (φ N) (hφ <| lt_add_one N) (hN (N + 1) N N.le_succ le_rfl)
+  · exact huφ.cauchySeq.mem_entourage V_in
+  · exact hu (φ <| N + 1) (φ N) (hφ <| lt_add_one N) (hN (N + 1) N N.le_succ le_rfl)
 #align is_seq_compact.totally_bounded IsSeqCompact.totallyBounded
 
 variable [IsCountablyGenerated (𝓤 X)]

ball for "bounded forall" and bex for "bounded exists" are from experience very confusing abbreviations. This PR renames them to forall_mem and exists_mem in the few Set lemma names that mention them.

Also deprecate ball_image_of_ball, mem_image_elim, mem_image_elim_on since those lemmas are duplicates of the renamed lemmas (apart from argument order and implicitness, which I am also fixing by making the binder in the RHS of forall_mem_image semi-implicit), have obscure names and are completely unused.

@@ -289,7 +289,7 @@ protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBoun
   contrapose! h
   obtain ⟨u, u_in, hu⟩ : ∃ u : ℕ → X, (∀ n, u n ∈ s) ∧ ∀ n m, m < n → u m ∉ ball (u n) V := by
     simp only [not_subset, mem_iUnion₂, not_exists, exists_prop] at h
-    simpa only [forall_and, ball_image_iff, not_and] using seq_of_forall_finite_exists h
+    simpa only [forall_and, forall_mem_image, not_and] using seq_of_forall_finite_exists h
   refine' ⟨u, u_in, fun x _ φ hφ huφ => _⟩
   obtain ⟨N, hN⟩ : ∃ N, ∀ p q, p ≥ N → q ≥ N → (u (φ p), u (φ q)) ∈ V
   exact huφ.cauchySeq.mem_entourage V_in

I want to have access to the definitions much earlier. Also, most of the file doesn't need metric spaces at all.

@@ -3,18 +3,22 @@ Copyright (c) 2018 Jan-David Salchow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jan-David Salchow, Patrick Massot, Yury Kudryashov
 -/
-import Mathlib.Topology.MetricSpace.Bounded
+import Mathlib.Topology.Defs.Sequences
+import Mathlib.Topology.UniformSpace.Cauchy
 
 #align_import topology.sequences from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
 
 /-!
 # Sequences in topological spaces
 
-In this file we define sequences in topological spaces and show how they are related to
-filters and the topology.
+In this file we prove theorems about relations
+between closure/compactness/continuity etc and their sequential counterparts.
 
 ## Main definitions
 
+The following notions are defined in `Topology/Defs/Sequences`.
+We build theory about these definitions here, so we remind the definitions.
+
 ### Set operation
 * `seqClosure s`: sequential closure of a set, the set of limits of sequences of points of `s`;
 
@@ -66,18 +70,10 @@ variable {X Y : Type*}
 
 /-! ### Sequential closures, sequential continuity, and sequential spaces. -/
 
-
 section TopologicalSpace
 
 variable [TopologicalSpace X] [TopologicalSpace Y]
 
-/-- The sequential closure of a set `s : Set X` in a topological space `X` is the set of all `a : X`
-which arise as limit of sequences in `s`. Note that the sequential closure of a set is not
-guaranteed to be sequentially closed. -/
-def seqClosure (s : Set X) : Set X :=
-  { a | ∃ x : ℕ → X, (∀ n : ℕ, x n ∈ s) ∧ Tendsto x atTop (𝓝 a) }
-#align seq_closure seqClosure
-
 theorem subset_seqClosure {s : Set X} : s ⊆ seqClosure s := fun p hp =>
   ⟨const ℕ p, fun _ => hp, tendsto_const_nhds⟩
 #align subset_seq_closure subset_seqClosure
@@ -88,13 +84,6 @@ theorem seqClosure_subset_closure {s : Set X} : seqClosure s ⊆ closure s := fu
   mem_closure_of_tendsto xp (univ_mem' xM)
 #align seq_closure_subset_closure seqClosure_subset_closure
 
-/-- A set `s` is sequentially closed if for any converging sequence `x n` of elements of `s`, the
-limit belongs to `s` as well. Note that the sequential closure of a set is not guaranteed to be
-sequentially closed. -/
-def IsSeqClosed (s : Set X) : Prop :=
-  ∀ ⦃x : ℕ → X⦄ ⦃p : X⦄, (∀ n, x n ∈ s) → Tendsto x atTop (𝓝 p) → p ∈ s
-#align is_seq_closed IsSeqClosed
-
 /-- The sequential closure of a sequentially closed set is the set itself. -/
 theorem IsSeqClosed.seqClosure_eq {s : Set X} (hs : IsSeqClosed s) : seqClosure s = s :=
   Subset.antisymm (fun _p ⟨_x, hx, hp⟩ => hs hx hp) subset_seqClosure
@@ -115,13 +104,6 @@ protected theorem IsClosed.isSeqClosed {s : Set X} (hc : IsClosed s) : IsSeqClos
   fun _u _x hu hx => hc.mem_of_tendsto hx (eventually_of_forall hu)
 #align is_closed.is_seq_closed IsClosed.isSeqClosed
 
-/-- A topological space is called a *Fréchet-Urysohn space*, if the sequential closure of any set
-is equal to its closure. Since one of the inclusions is trivial, we require only the non-trivial one
-in the definition. -/
-class FrechetUrysohnSpace (X : Type*) [TopologicalSpace X] : Prop where
-  closure_subset_seqClosure : ∀ s : Set X, closure s ⊆ seqClosure s
-#align frechet_urysohn_space FrechetUrysohnSpace
-
 theorem seqClosure_eq_closure [FrechetUrysohnSpace X] (s : Set X) : seqClosure s = closure s :=
   seqClosure_subset_closure.antisymm <| FrechetUrysohnSpace.closure_subset_seqClosure s
 #align seq_closure_eq_closure seqClosure_eq_closure
@@ -176,12 +158,6 @@ instance (priority := 100) FirstCountableTopology.frechetUrysohnSpace
   FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto fun _ _ => tendsto_iff_seq_tendsto.2
 #align topological_space.first_countable_topology.frechet_urysohn_space FirstCountableTopology.frechetUrysohnSpace
 
-/-- A topological space is said to be a *sequential space* if any sequentially closed set in this
-space is closed. This condition is weaker than being a Fréchet-Urysohn space. -/
-class SequentialSpace (X : Type*) [TopologicalSpace X] : Prop where
-  isClosed_of_seq : ∀ s : Set X, IsSeqClosed s → IsClosed s
-#align sequential_space SequentialSpace
-
 -- see Note [lower instance priority]
 /-- Every Fréchet-Urysohn space is a sequential space. -/
 instance (priority := 100) FrechetUrysohnSpace.to_sequentialSpace [FrechetUrysohnSpace X] :
@@ -189,23 +165,11 @@ instance (priority := 100) FrechetUrysohnSpace.to_sequentialSpace [FrechetUrysoh
   ⟨fun s hs => by rw [← closure_eq_iff_isClosed, ← seqClosure_eq_closure, hs.seqClosure_eq]⟩
 #align frechet_urysohn_space.to_sequential_space FrechetUrysohnSpace.to_sequentialSpace
 
-/-- In a sequential space, a sequentially closed set is closed. -/
-protected theorem IsSeqClosed.isClosed [SequentialSpace X] {s : Set X} (hs : IsSeqClosed s) :
-    IsClosed s :=
-  SequentialSpace.isClosed_of_seq s hs
-#align is_seq_closed.is_closed IsSeqClosed.isClosed
-
 /-- In a sequential space, a set is closed iff it's sequentially closed. -/
 theorem isSeqClosed_iff_isClosed [SequentialSpace X] {M : Set X} : IsSeqClosed M ↔ IsClosed M :=
   ⟨IsSeqClosed.isClosed, IsClosed.isSeqClosed⟩
 #align is_seq_closed_iff_is_closed isSeqClosed_iff_isClosed
 
-/-- A function between topological spaces is sequentially continuous if it commutes with limit of
- convergent sequences. -/
-def SeqContinuous (f : X → Y) : Prop :=
-  ∀ ⦃x : ℕ → X⦄ ⦃p : X⦄, Tendsto x atTop (𝓝 p) → Tendsto (f ∘ x) atTop (𝓝 (f p))
-#align seq_continuous SeqContinuous
-
 /-- The preimage of a sequentially closed set under a sequentially continuous map is sequentially
 closed. -/
 theorem IsSeqClosed.preimage {f : X → Y} {s : Set Y} (hs : IsSeqClosed s) (hf : SeqContinuous f) :
@@ -247,22 +211,6 @@ open TopologicalSpace FirstCountableTopology
 
 variable [TopologicalSpace X]
 
-/-- A set `s` is sequentially compact if every sequence taking values in `s` has a
-converging subsequence. -/
-def IsSeqCompact (s : Set X) :=
-  ∀ ⦃x : ℕ → X⦄, (∀ n, x n ∈ s) → ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a)
-#align is_seq_compact IsSeqCompact
-
-/-- A space `X` is sequentially compact if every sequence in `X` has a
-converging subsequence. -/
-@[mk_iff]
-class SeqCompactSpace (X : Type*) [TopologicalSpace X] : Prop where
-  seq_compact_univ : IsSeqCompact (univ : Set X)
-#align seq_compact_space SeqCompactSpace
-#align seq_compact_space_iff seqCompactSpace_iff
-
-export SeqCompactSpace (seq_compact_univ)
-
 theorem IsSeqCompact.subseq_of_frequently_in {s : Set X} (hs : IsSeqCompact s) {x : ℕ → X}
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
@@ -398,37 +346,3 @@ theorem UniformSpace.compactSpace_iff_seqCompactSpace : CompactSpace X ↔ SeqCo
 #align uniform_space.compact_space_iff_seq_compact_space UniformSpace.compactSpace_iff_seqCompactSpace
 
 end UniformSpaceSeqCompact
-
-section MetricSeqCompact
-
-variable [PseudoMetricSpace X]
-
-open Metric
-
-nonrec theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort*} {c : ι → Set X} {s : Set X}
-    (hs : IsSeqCompact s) (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i, c i) :
-    ∃ δ > 0, ∀ a ∈ s, ∃ i, ball a δ ⊆ c i :=
-  lebesgue_number_lemma_of_metric hs.isCompact hc₁ hc₂
-#align seq_compact.lebesgue_number_lemma_of_metric SeqCompact.lebesgue_number_lemma_of_metric
-
-variable [ProperSpace X] {s : Set X}
-
-/-- A version of **Bolzano-Weistrass**: in a proper metric space (eg. $ℝ^n$),
-every bounded sequence has a converging subsequence. This version assumes only
-that the sequence is frequently in some bounded set. -/
-theorem tendsto_subseq_of_frequently_bounded (hs : IsBounded s) {x : ℕ → X}
-    (hx : ∃ᶠ n in atTop, x n ∈ s) :
-    ∃ a ∈ closure s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
-  have hcs : IsSeqCompact (closure s) := hs.isCompact_closure.isSeqCompact
-  have hu' : ∃ᶠ n in atTop, x n ∈ closure s := hx.mono fun _n hn => subset_closure hn
-  hcs.subseq_of_frequently_in hu'
-#align tendsto_subseq_of_frequently_bounded tendsto_subseq_of_frequently_bounded
-
-/-- A version of Bolzano-Weistrass: in a proper metric space (eg. $ℝ^n$),
-every bounded sequence has a converging subsequence. -/
-theorem tendsto_subseq_of_bounded (hs : IsBounded s) {x : ℕ → X} (hx : ∀ n, x n ∈ s) :
-    ∃ a ∈ closure s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
-  tendsto_subseq_of_frequently_bounded hs <| frequently_of_forall hx
-#align tendsto_subseq_of_bounded tendsto_subseq_of_bounded
-
-end MetricSeqCompact

• @[mk_iff] class MyPred now generates myPred_iff, not MyPred_iff
• add Lean.Name.decapitalize
• fix indentation and a few typos in the docs/comments.

Partially addresses issue #9129

@@ -255,7 +255,7 @@ def IsSeqCompact (s : Set X) :=
 
 /-- A space `X` is sequentially compact if every sequence in `X` has a
 converging subsequence. -/
-@[mk_iff seqCompactSpace_iff]
+@[mk_iff]
 class SeqCompactSpace (X : Type*) [TopologicalSpace X] : Prop where
   seq_compact_univ : IsSeqCompact (univ : Set X)
 #align seq_compact_space SeqCompactSpace

PR contents

This is the supremum of

• #8284
• #8056
• #8023
• #8332
• #8226 (already approved)
• #7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

• leanprover/lean4#2778
• leanprover/lean4#2790
• leanprover/lean4#2783
• leanprover/lean4#2825
• leanprover/lean4#2722

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

• switching to using explicit lemmas that have the intended level of application
• (config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
• Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

@@ -163,7 +163,8 @@ theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
   · exact subset_seqClosure hx
   · obtain ⟨u, hux, hus⟩ : ∃ u : ℕ → X, Tendsto u atTop (𝓝 x) ∧ ∃ᶠ x in atTop, u x ∈ s
     · simpa only [ContinuousAt, hx, tendsto_nhds_true, (· ∘ ·), ← not_frequently, exists_prop,
-        ← mem_closure_iff_frequently, hcx, imp_false, not_forall, not_not] using h (· ∉ s) x
+        ← mem_closure_iff_frequently, hcx, imp_false, not_forall, not_not, not_false_eq_true,
+        not_true_eq_false] using h (· ∉ s) x
     rcases extraction_of_frequently_atTop hus with ⟨φ, φ_mono, hφ⟩
     exact ⟨u ∘ φ, hφ, hux.comp φ_mono.tendsto_atTop⟩
 #align frechet_urysohn_space.of_seq_tendsto_imp_tendsto FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto

All the other properties of topological spaces like T0Space or RegularSpace are in the root namespace. Many files were opening TopologicalSpace just for the sake of shortening TopologicalSpace.SecondCountableTopology...

@@ -47,7 +47,7 @@ filters and the topology.
   its closure;
 * `tendsto_nhds_iff_seq_tendsto`, `FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto`: a topological
   space is a Fréchet-Urysohn space if and only if sequential convergence implies convergence;
-* `TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace`: every topological space with
+* `FirstCountableTopology.frechetUrysohnSpace`: every topological space with
   first countable topology is a Fréchet-Urysohn space;
 * `FrechetUrysohnSpace.to_sequentialSpace`: every Fréchet-Urysohn space is a sequential space;
 * `IsSeqCompact.isCompact`: a sequentially compact set in a uniform space with countably
@@ -170,10 +170,10 @@ theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
 
 -- see Note [lower instance priority]
 /-- Every first-countable space is a Fréchet-Urysohn space. -/
-instance (priority := 100) TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace
+instance (priority := 100) FirstCountableTopology.frechetUrysohnSpace
     [FirstCountableTopology X] : FrechetUrysohnSpace X :=
   FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto fun _ _ => tendsto_iff_seq_tendsto.2
-#align topological_space.first_countable_topology.frechet_urysohn_space TopologicalSpace.FirstCountableTopology.frechetUrysohnSpace
+#align topological_space.first_countable_topology.frechet_urysohn_space FirstCountableTopology.frechetUrysohnSpace
 
 /-- A topological space is said to be a *sequential space* if any sequentially closed set in this
 space is closed. This condition is weaker than being a Fréchet-Urysohn space. -/
@@ -242,7 +242,7 @@ end TopologicalSpace
 
 section SeqCompact
 
-open TopologicalSpace TopologicalSpace.FirstCountableTopology
+open TopologicalSpace FirstCountableTopology
 
 variable [TopologicalSpace X]
 
@@ -280,7 +280,7 @@ section FirstCountableTopology
 
 variable [FirstCountableTopology X]
 
-open TopologicalSpace.FirstCountableTopology
+open FirstCountableTopology
 
 protected theorem IsCompact.isSeqCompact {s : Set X} (hs : IsCompact s) : IsSeqCompact s :=
   fun _x x_in =>

This reduces the main file from 3340 to 2220 lines. The remaining file is somewhat entangled, so splitting is less obvious. Help is welcome, though a follow-up PR is probably better :-)

I've kept copyright and authors as they were originally.

@@ -3,7 +3,7 @@ Copyright (c) 2018 Jan-David Salchow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jan-David Salchow, Patrick Massot, Yury Kudryashov
 -/
-import Mathlib.Topology.MetricSpace.Basic
+import Mathlib.Topology.MetricSpace.Bounded
 
 #align_import topology.sequences from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
 

Split up the 2000-line Topology/SubsetProperties.lean into several smaller files. Not only is it too huge, but the name is very unhelpful, since actually about 90% of the file is about compactness; I've moved this material into various files inside a new subdirectory Topology/Compactness/.

@@ -3,7 +3,6 @@ Copyright (c) 2018 Jan-David Salchow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jan-David Salchow, Patrick Massot, Yury Kudryashov
 -/
-import Mathlib.Topology.SubsetProperties
 import Mathlib.Topology.MetricSpace.Basic
 
 #align_import topology.sequences from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"

Use Bornology.IsBounded instead.

@@ -60,7 +60,8 @@ sequentially closed, sequentially compact, sequential space
 -/
 
 
-open Set Function Filter TopologicalSpace Topology Uniformity
+open Set Function Filter TopologicalSpace Bornology
+open scoped Topology Uniformity
 
 variable {X Y : Type*}
 
@@ -415,7 +416,7 @@ variable [ProperSpace X] {s : Set X}
 /-- A version of **Bolzano-Weistrass**: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. This version assumes only
 that the sequence is frequently in some bounded set. -/
-theorem tendsto_subseq_of_frequently_bounded (hs : Bounded s) {x : ℕ → X}
+theorem tendsto_subseq_of_frequently_bounded (hs : IsBounded s) {x : ℕ → X}
     (hx : ∃ᶠ n in atTop, x n ∈ s) :
     ∃ a ∈ closure s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   have hcs : IsSeqCompact (closure s) := hs.isCompact_closure.isSeqCompact
@@ -425,7 +426,7 @@ theorem tendsto_subseq_of_frequently_bounded (hs : Bounded s) {x : ℕ → X}
 
 /-- A version of Bolzano-Weistrass: in a proper metric space (eg. $ℝ^n$),
 every bounded sequence has a converging subsequence. -/
-theorem tendsto_subseq_of_bounded (hs : Bounded s) {x : ℕ → X} (hx : ∀ n, x n ∈ s) :
+theorem tendsto_subseq_of_bounded (hs : IsBounded s) {x : ℕ → X} (hx : ∀ n, x n ∈ s) :
     ∃ a ∈ closure s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   tendsto_subseq_of_frequently_bounded hs <| frequently_of_forall hx
 #align tendsto_subseq_of_bounded tendsto_subseq_of_bounded

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -62,7 +62,7 @@ sequentially closed, sequentially compact, sequential space
 
 open Set Function Filter TopologicalSpace Topology Uniformity
 
-variable {X Y : Type _}
+variable {X Y : Type*}
 
 /-! ### Sequential closures, sequential continuity, and sequential spaces. -/
 
@@ -118,7 +118,7 @@ protected theorem IsClosed.isSeqClosed {s : Set X} (hc : IsClosed s) : IsSeqClos
 /-- A topological space is called a *Fréchet-Urysohn space*, if the sequential closure of any set
 is equal to its closure. Since one of the inclusions is trivial, we require only the non-trivial one
 in the definition. -/
-class FrechetUrysohnSpace (X : Type _) [TopologicalSpace X] : Prop where
+class FrechetUrysohnSpace (X : Type*) [TopologicalSpace X] : Prop where
   closure_subset_seqClosure : ∀ s : Set X, closure s ⊆ seqClosure s
 #align frechet_urysohn_space FrechetUrysohnSpace
 
@@ -177,7 +177,7 @@ instance (priority := 100) TopologicalSpace.FirstCountableTopology.frechetUrysoh
 
 /-- A topological space is said to be a *sequential space* if any sequentially closed set in this
 space is closed. This condition is weaker than being a Fréchet-Urysohn space. -/
-class SequentialSpace (X : Type _) [TopologicalSpace X] : Prop where
+class SequentialSpace (X : Type*) [TopologicalSpace X] : Prop where
   isClosed_of_seq : ∀ s : Set X, IsSeqClosed s → IsClosed s
 #align sequential_space SequentialSpace
 
@@ -255,7 +255,7 @@ def IsSeqCompact (s : Set X) :=
 /-- A space `X` is sequentially compact if every sequence in `X` has a
 converging subsequence. -/
 @[mk_iff seqCompactSpace_iff]
-class SeqCompactSpace (X : Type _) [TopologicalSpace X] : Prop where
+class SeqCompactSpace (X : Type*) [TopologicalSpace X] : Prop where
   seq_compact_univ : IsSeqCompact (univ : Set X)
 #align seq_compact_space SeqCompactSpace
 #align seq_compact_space_iff seqCompactSpace_iff
@@ -404,7 +404,7 @@ variable [PseudoMetricSpace X]
 
 open Metric
 
-nonrec theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort _} {c : ι → Set X} {s : Set X}
+nonrec theorem SeqCompact.lebesgue_number_lemma_of_metric {ι : Sort*} {c : ι → Set X} {s : Set X}
     (hs : IsSeqCompact s) (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i, c i) :
     ∃ δ > 0, ∀ a ∈ s, ∃ i, ball a δ ⊆ c i :=
   lebesgue_number_lemma_of_metric hs.isCompact hc₁ hc₂

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Jan-David Salchow. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jan-David Salchow, Patrick Massot, Yury Kudryashov
-
-! This file was ported from Lean 3 source module topology.sequences
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.SubsetProperties
 import Mathlib.Topology.MetricSpace.Basic
 
+#align_import topology.sequences from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+
 /-!
 # Sequences in topological spaces
 

• depends on: https://github.com/leanprover/std4/pull/163
• depends on: #5584
• depends on: #5715
• depends on: #5729
• depends on: https://github.com/leanprover/std4/pull/173

Co-authored-by: Komyyy <pol_tta@outlook.jp> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -164,7 +164,7 @@ theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
   refine ⟨fun s x hcx => ?_⟩
   by_cases hx : x ∈ s;
   · exact subset_seqClosure hx
-  · obtain ⟨u, hux, hus⟩ : ∃ u, Tendsto u atTop (𝓝 x) ∧ ∃ᶠ x in atTop, u x ∈ s
+  · obtain ⟨u, hux, hus⟩ : ∃ u : ℕ → X, Tendsto u atTop (𝓝 x) ∧ ∃ᶠ x in atTop, u x ∈ s
     · simpa only [ContinuousAt, hx, tendsto_nhds_true, (· ∘ ·), ← not_frequently, exists_prop,
         ← mem_closure_iff_frequently, hcx, imp_false, not_forall, not_not] using h (· ∉ s) x
     rcases extraction_of_frequently_atTop hus with ⟨φ, φ_mono, hφ⟩

@@ -368,7 +368,7 @@ protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s :
       simpa only [l.basis_sets.prod_self.mem_iff, true_imp_iff, subset_inter_iff,
         prod_self_subset_prod_self, and_assoc] using this
     choose t htl htW hts using this
-    have : ∀ n : ℕ, (⋂ k ≤ n, t k) ⊆ t n := fun n => by apply iInter₂_subset; rfl
+    have : ∀ n : ℕ, ⋂ k ≤ n, t k ⊆ t n := fun n => by apply iInter₂_subset; rfl
     exact ⟨fun n => ⋂ k ≤ n, t k, fun m n h =>
       biInter_subset_biInter_left fun k (hk : k ≤ m) => hk.trans h, fun n =>
       (biInter_mem (finite_le_nat n)).2 fun k _ => htl k, fun n =>

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -309,7 +309,7 @@ instance (priority := 100) FirstCountableTopology.seq_compact_of_compact [Compac
 #align first_countable_topology.seq_compact_of_compact FirstCountableTopology.seq_compact_of_compact
 
 theorem CompactSpace.tendsto_subseq [CompactSpace X] (x : ℕ → X) :
-    ∃ (a : _)(φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
+    ∃ (a : _) (φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) :=
   SeqCompactSpace.tendsto_subseq x
 #align compact_space.tendsto_subseq CompactSpace.tendsto_subseq
 

Currently, the following notations are changed from · ×ˢ · because Lean 4 can't deal with ambiguous notations. | Definition | Notation | | :

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

@@ -364,7 +364,7 @@ protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s :
       ∃ t : ℕ → Set X, Antitone t ∧ (∀ n, t n ∈ l) ∧ (∀ n, t n ×ˢ t n ⊆ W n) ∧ ∀ n, t n ⊆ s := by
     have : ∀ n, ∃ t ∈ l, t ×ˢ t ⊆ W n ∧ t ⊆ s := by
       rw [le_principal_iff] at hls
-      have : ∀ n, W n ∩ s ×ˢ s ∈ l ×ᶠ l := fun n => inter_mem (hl.2 (hW n)) (prod_mem_prod hls hls)
+      have : ∀ n, W n ∩ s ×ˢ s ∈ l ×ˢ l := fun n => inter_mem (hl.2 (hW n)) (prod_mem_prod hls hls)
       simpa only [l.basis_sets.prod_self.mem_iff, true_imp_iff, subset_inter_iff,
         prod_self_subset_prod_self, and_assoc] using this
     choose t htl htW hts using this

As discussed on Zulip

Renames

• supₛ → sSup
• infₛ → sInf
• supᵢ → iSup
• infᵢ → iInf
• bsupₛ → bsSup
• binfₛ → bsInf
• bsupᵢ → biSup
• binfᵢ → biInf
• csupₛ → csSup
• cinfₛ → csInf
• csupᵢ → ciSup
• cinfᵢ → ciInf
• unionₛ → sUnion
• interₛ → sInter
• unionᵢ → iUnion
• interᵢ → iInter
• bunionₛ → bsUnion
• binterₛ → bsInter
• bunionᵢ → biUnion
• binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -342,7 +342,7 @@ protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBoun
   unfold IsSeqCompact at h
   contrapose! h
   obtain ⟨u, u_in, hu⟩ : ∃ u : ℕ → X, (∀ n, u n ∈ s) ∧ ∀ n m, m < n → u m ∉ ball (u n) V := by
-    simp only [not_subset, mem_unionᵢ₂, not_exists, exists_prop] at h
+    simp only [not_subset, mem_iUnion₂, not_exists, exists_prop] at h
     simpa only [forall_and, ball_image_iff, not_and] using seq_of_forall_finite_exists h
   refine' ⟨u, u_in, fun x _ φ hφ huφ => _⟩
   obtain ⟨N, hN⟩ : ∃ N, ∀ p q, p ≥ N → q ≥ N → (u (φ p), u (φ q)) ∈ V
@@ -368,10 +368,10 @@ protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s :
       simpa only [l.basis_sets.prod_self.mem_iff, true_imp_iff, subset_inter_iff,
         prod_self_subset_prod_self, and_assoc] using this
     choose t htl htW hts using this
-    have : ∀ n : ℕ, (⋂ k ≤ n, t k) ⊆ t n := fun n => by apply interᵢ₂_subset; rfl
+    have : ∀ n : ℕ, (⋂ k ≤ n, t k) ⊆ t n := fun n => by apply iInter₂_subset; rfl
     exact ⟨fun n => ⋂ k ≤ n, t k, fun m n h =>
-      binterᵢ_subset_binterᵢ_left fun k (hk : k ≤ m) => hk.trans h, fun n =>
-      (binterᵢ_mem (finite_le_nat n)).2 fun k _ => htl k, fun n =>
+      biInter_subset_biInter_left fun k (hk : k ≤ m) => hk.trans h, fun n =>
+      (biInter_mem (finite_le_nat n)).2 fun k _ => htl k, fun n =>
       (prod_mono (this n) (this n)).trans (htW n), fun n => (this n).trans (hts n)⟩
   choose u hu using fun n => Filter.nonempty_of_mem (htl n)
   have huc : CauchySeq u := hV.toHasBasis.cauchySeq_iff.2 fun N _ =>