topology.list ⟷ Mathlib.Topology.List

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

@@ -220,7 +220,7 @@ theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
   · simp (config := { contextual := true }) [nhds_nil, mem_of_mem_nhds, tendsto_pure_left]
   simp_rw [tendsto_cons_iff, prod_cons]
   have := continuous_iff_continuous_at.mp continuous_mul (x, l.prod)
-  rw [ContinuousAt, nhds_prod_eq] at this 
+  rw [ContinuousAt, nhds_prod_eq] at this
   exact this.comp (tendsto_id.prod_map ih)
 #align list.tendsto_prod List.tendsto_prod
 #align list.tendsto_sum List.tendsto_sum

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

@@ -3,8 +3,8 @@ Copyright (c) 2019 Reid Barton. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
 -/
-import Mathbin.Topology.Constructions
-import Mathbin.Topology.Algebra.Monoid
+import Topology.Constructions
+import Topology.Algebra.Monoid
 
 #align_import topology.list from "leanprover-community/mathlib"@"e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2019 Reid Barton. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
-
-! This file was ported from Lean 3 source module topology.list
-! leanprover-community/mathlib commit e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Constructions
 import Mathbin.Topology.Algebra.Monoid
 
+#align_import topology.list from "leanprover-community/mathlib"@"e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b"
+
 /-!
 # Topology on lists and vectors
 

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

@@ -30,6 +30,7 @@ instance : TopologicalSpace (List α) :=
   TopologicalSpace.mkOfNhds (traverse nhds)
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print nhds_list /-
 theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
   by
   refine' nhds_mk_of_nhds _ _ _ _
@@ -67,29 +68,38 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
       refine' mem_of_superset _ hvs
       exact mem_traverse _ _ (this.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha)
 #align nhds_list nhds_list
+-/
 
+#print nhds_nil /-
 @[simp]
 theorem nhds_nil : 𝓝 ([] : List α) = pure [] := by
   rw [nhds_list, List.traverse_nil _] <;> infer_instance
 #align nhds_nil nhds_nil
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print nhds_cons /-
 theorem nhds_cons (a : α) (l : List α) : 𝓝 (a::l) = List.cons <$> 𝓝 a <*> 𝓝 l := by
   rw [nhds_list, List.traverse_cons _, ← nhds_list] <;> infer_instance
 #align nhds_cons nhds_cons
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print List.tendsto_cons /-
 theorem List.tendsto_cons {a : α} {l : List α} :
     Tendsto (fun p : α × List α => List.cons p.1 p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (a::l)) := by
   rw [nhds_cons, tendsto, Filter.map_prod] <;> exact le_rfl
 #align list.tendsto_cons List.tendsto_cons
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Filter.Tendsto.cons /-
 theorem Filter.Tendsto.cons {α : Type _} {f : α → β} {g : α → List β} {a : Filter α} {b : β}
     {l : List β} (hf : Tendsto f a (𝓝 b)) (hg : Tendsto g a (𝓝 l)) :
     Tendsto (fun a => List.cons (f a) (g a)) a (𝓝 (b::l)) :=
   List.tendsto_cons.comp (Tendsto.prod_mk hf hg)
 #align filter.tendsto.cons Filter.Tendsto.cons
+-/
 
 namespace List
 
@@ -97,6 +107,7 @@ namespace List
 /- ./././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 List.tendsto_cons_iff /-
 theorem tendsto_cons_iff {β : Type _} {f : List α → β} {b : Filter β} {a : α} {l : List α} :
     Tendsto f (𝓝 (a::l)) b ↔ Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ᶠ 𝓝 l) b :=
   by
@@ -107,15 +118,19 @@ theorem tendsto_cons_iff {β : Type _} {f : List α → β} {b : Filter β} {a :
     simp [-Filter.seq_eq_filter_seq, -Filter.map_def, (· ∘ ·), functor_norm]
   rw [this, Filter.tendsto_map'_iff]
 #align list.tendsto_cons_iff List.tendsto_cons_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print List.continuous_cons /-
 theorem continuous_cons : Continuous fun x : α × List α => (x.1::x.2 : List α) :=
   continuous_iff_continuousAt.mpr fun ⟨x, y⟩ => continuousAt_fst.cons continuousAt_snd
 #align list.continuous_cons List.continuous_cons
+-/
 
 /- ./././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 List.tendsto_nhds /-
 theorem tendsto_nhds {β : Type _} {f : List α → β} {r : List α → Filter β}
     (h_nil : Tendsto f (pure []) (r []))
     (h_cons :
@@ -126,7 +141,9 @@ theorem tendsto_nhds {β : Type _} {f : List α → β} {r : List α → Filter
   | [] => by rwa [nhds_nil]
   | a::l => by rw [tendsto_cons_iff] <;> exact h_cons l a (tendsto_nhds l)
 #align list.tendsto_nhds List.tendsto_nhds
+-/
 
+#print List.continuousAt_length /-
 theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l :=
   by
   simp only [ContinuousAt, nhds_discrete]
@@ -137,10 +154,12 @@ theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l :=
     refine' tendsto.comp (tendsto_pure_pure (fun x => x + 1) _) _
     refine' tendsto.comp ih tendsto_snd
 #align list.continuous_at_length List.continuousAt_length
+-/
 
 /- ./././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 List.tendsto_insertNth' /-
 theorem tendsto_insertNth' {a : α} :
     ∀ {n : ℕ} {l : List α},
       Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (insertNth n a l))
@@ -158,20 +177,26 @@ theorem tendsto_insertNth' {a : α} :
       (tendsto_fst.comp tendsto_snd).cons
         ((@tendsto_insert_nth' n l).comp <| tendsto_fst.prod_mk <| tendsto_snd.comp tendsto_snd)
 #align list.tendsto_insert_nth' List.tendsto_insertNth'
+-/
 
+#print List.tendsto_insertNth /-
 theorem tendsto_insertNth {β} {n : ℕ} {a : α} {l : List α} {f : β → α} {g : β → List α}
     {b : Filter β} (hf : Tendsto f b (𝓝 a)) (hg : Tendsto g b (𝓝 l)) :
     Tendsto (fun b : β => insertNth n (f b) (g b)) b (𝓝 (insertNth n a l)) :=
   tendsto_insertNth'.comp (Tendsto.prod_mk hf hg)
 #align list.tendsto_insert_nth List.tendsto_insertNth
+-/
 
+#print List.continuous_insertNth /-
 theorem continuous_insertNth {n : ℕ} : Continuous fun p : α × List α => insertNth n p.1 p.2 :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => by
     rw [ContinuousAt, nhds_prod_eq] <;> exact tendsto_insert_nth'
 #align list.continuous_insert_nth List.continuous_insertNth
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print List.tendsto_removeNth /-
 theorem tendsto_removeNth :
     ∀ {n : ℕ} {l : List α}, Tendsto (fun l => removeNth l n) (𝓝 l) (𝓝 (removeNth l n))
   | _, [] => by rw [nhds_nil] <;> exact tendsto_pure_nhds _ _
@@ -181,11 +206,15 @@ theorem tendsto_removeNth :
     dsimp [remove_nth]
     exact tendsto_fst.cons ((@tendsto_remove_nth n l).comp tendsto_snd)
 #align list.tendsto_remove_nth List.tendsto_removeNth
+-/
 
+#print List.continuous_removeNth /-
 theorem continuous_removeNth {n : ℕ} : Continuous fun l : List α => removeNth l n :=
   continuous_iff_continuousAt.mpr fun a => tendsto_removeNth
 #align list.continuous_remove_nth List.continuous_removeNth
+-/
 
+#print List.tendsto_prod /-
 @[to_additive]
 theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
     Tendsto List.prod (𝓝 l) (𝓝 l.Prod) :=
@@ -198,12 +227,15 @@ theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
   exact this.comp (tendsto_id.prod_map ih)
 #align list.tendsto_prod List.tendsto_prod
 #align list.tendsto_sum List.tendsto_sum
+-/
 
+#print List.continuous_prod /-
 @[to_additive]
 theorem continuous_prod [Monoid α] [ContinuousMul α] : Continuous (prod : List α → α) :=
   continuous_iff_continuousAt.mpr fun l => tendsto_prod
 #align list.continuous_prod List.continuous_prod
 #align list.continuous_sum List.continuous_sum
+-/
 
 end List
 
@@ -213,13 +245,16 @@ open List
 
 instance (n : ℕ) : TopologicalSpace (Vector α n) := by unfold Vector <;> infer_instance
 
+#print Vector.tendsto_cons /-
 theorem tendsto_cons {n : ℕ} {a : α} {l : Vector α n} :
     Tendsto (fun p : α × Vector α n => p.1 ::ᵥ p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (a ::ᵥ l)) :=
   by
   simp [tendsto_subtype_rng, ← Subtype.val_eq_coe, cons_val]
   exact tendsto_fst.cons (tendsto.comp continuousAt_subtype_val tendsto_snd)
 #align vector.tendsto_cons Vector.tendsto_cons
+-/
 
+#print Vector.tendsto_insertNth /-
 theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
     ∀ {l : Vector α n},
       Tendsto (fun p : α × Vector α n => insertNth p.1 i p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (insertNth a i l))
@@ -228,18 +263,24 @@ theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
     simp [insert_nth_val]
     exact List.tendsto_insertNth tendsto_fst (tendsto.comp continuousAt_subtype_val tendsto_snd : _)
 #align vector.tendsto_insert_nth Vector.tendsto_insertNth
+-/
 
+#print Vector.continuous_insertNth' /-
 theorem continuous_insertNth' {n : ℕ} {i : Fin (n + 1)} :
     Continuous fun p : α × Vector α n => insertNth p.1 i p.2 :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => by
     rw [ContinuousAt, nhds_prod_eq] <;> exact tendsto_insert_nth
 #align vector.continuous_insert_nth' Vector.continuous_insertNth'
+-/
 
+#print Vector.continuous_insertNth /-
 theorem continuous_insertNth {n : ℕ} {i : Fin (n + 1)} {f : β → α} {g : β → Vector α n}
     (hf : Continuous f) (hg : Continuous g) : Continuous fun b => insertNth (f b) i (g b) :=
   continuous_insertNth'.comp (hf.prod_mk hg : _)
 #align vector.continuous_insert_nth Vector.continuous_insertNth
+-/
 
+#print Vector.continuousAt_removeNth /-
 theorem continuousAt_removeNth {n : ℕ} {i : Fin (n + 1)} :
     ∀ {l : Vector α (n + 1)}, ContinuousAt (removeNth i) l
   | ⟨l, hl⟩ =>--  ∀{l:vector α (n+1)}, tendsto (remove_nth i) (𝓝 l) (𝓝 (remove_nth i l))
@@ -249,11 +290,14 @@ theorem continuousAt_removeNth {n : ℕ} {i : Fin (n + 1)} :
     simp only [← Subtype.val_eq_coe, Vector.removeNth_val]
     exact tendsto.comp List.tendsto_removeNth continuousAt_subtype_val
 #align vector.continuous_at_remove_nth Vector.continuousAt_removeNth
+-/
 
+#print Vector.continuous_removeNth /-
 theorem continuous_removeNth {n : ℕ} {i : Fin (n + 1)} :
     Continuous (removeNth i : Vector α (n + 1) → Vector α n) :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => continuousAt_removeNth
 #align vector.continuous_remove_nth Vector.continuous_removeNth
+-/
 
 end Vector
 

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

@@ -35,8 +35,8 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
   refine' nhds_mk_of_nhds _ _ _ _
   · intro l; induction l
     case nil => exact le_rfl
-    case
-      cons a l ih =>
+    case cons a l
+      ih =>
       suffices List.cons <$> pure a <*> pure l ≤ List.cons <$> 𝓝 a <*> traverse 𝓝 l by
         simpa only [functor_norm] using this
       exact Filter.seq_mono (Filter.map_mono <| pure_le_nhds a) ih
@@ -46,8 +46,8 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
       by
       induction hu generalizing s
       case nil hs this => exists ; simpa only [List.forall₂_nil_left_iff, exists_eq_left]
-      case
-        cons a s as ss ht h ih t hts =>
+      case cons a s as ss ht h ih t
+        hts =>
         rcases mem_nhds_iff.1 ht with ⟨u, hut, hu⟩
         rcases ih _ subset.rfl with ⟨v, hv, hvss⟩
         exact
@@ -62,7 +62,7 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
         by
         refine' List.Forall₂.flip _
         replace hv := hv.flip
-        simp only [List.forall₂_and_left, flip] at hv⊢
+        simp only [List.forall₂_and_left, flip] at hv ⊢
         exact ⟨hv.1, hu.flip⟩
       refine' mem_of_superset _ hvs
       exact mem_traverse _ _ (this.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha)
@@ -194,7 +194,7 @@ theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
   · simp (config := { contextual := true }) [nhds_nil, mem_of_mem_nhds, tendsto_pure_left]
   simp_rw [tendsto_cons_iff, prod_cons]
   have := continuous_iff_continuous_at.mp continuous_mul (x, l.prod)
-  rw [ContinuousAt, nhds_prod_eq] at this
+  rw [ContinuousAt, nhds_prod_eq] at this 
   exact this.comp (tendsto_id.prod_map ih)
 #align list.tendsto_prod List.tendsto_prod
 #align list.tendsto_sum List.tendsto_sum

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

@@ -22,7 +22,7 @@ import Mathbin.Topology.Algebra.Monoid
 
 open TopologicalSpace Set Filter
 
-open Topology Filter
+open scoped Topology Filter
 
 variable {α : Type _} {β : Type _} [TopologicalSpace α] [TopologicalSpace β]
 

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

@@ -29,12 +29,6 @@ variable {α : Type _} {β : Type _} [TopologicalSpace α] [TopologicalSpace β]
 instance : TopologicalSpace (List α) :=
   TopologicalSpace.mkOfNhds (traverse nhds)
 
-/- warning: nhds_list -> nhds_list is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (as : List.{u1} α), Eq.{succ u1} (Filter.{u1} (List.{u1} α)) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) as) (Traversable.traverse.{u1} List.{u1} List.traversable.{u1} Filter.{u1} Filter.applicative.{u1} α α (nhds.{u1} α _inst_1) as)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (as : List.{u1} α), Eq.{succ u1} (Filter.{u1} (List.{u1} α)) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) as) (Traversable.traverse.{u1} List.{u1} instTraversableList.{u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) α α (nhds.{u1} α _inst_1) as)
-Case conversion may be inaccurate. Consider using '#align nhds_list nhds_listₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
   by
@@ -74,46 +68,22 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
       exact mem_traverse _ _ (this.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha)
 #align nhds_list nhds_list
 
-/- warning: nhds_nil -> nhds_nil is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (List.{u1} α)) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.nil.{u1} α)) (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} (List.{u1} α) (List.nil.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (List.{u1} α)) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (List.nil.{u1} α)) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} (List.{u1} α) (List.nil.{u1} α))
-Case conversion may be inaccurate. Consider using '#align nhds_nil nhds_nilₓ'. -/
 @[simp]
 theorem nhds_nil : 𝓝 ([] : List α) = pure [] := by
   rw [nhds_list, List.traverse_nil _] <;> infer_instance
 #align nhds_nil nhds_nil
 
-/- warning: nhds_cons -> nhds_cons is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (a : α) (l : List.{u1} α), Eq.{succ u1} (Filter.{u1} (List.{u1} α)) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.cons.{u1} α a l)) (Seq.seq.{u1, u1} Filter.{u1} Filter.hasSeq.{u1} (List.{u1} α) (List.{u1} α) (Functor.map.{u1, u1} Filter.{u1} Filter.functor.{u1} α ((List.{u1} α) -> (List.{u1} α)) (List.cons.{u1} α) (nhds.{u1} α _inst_1 a)) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (a : α) (l : List.{u1} α), Eq.{succ u1} (Filter.{u1} (List.{u1} α)) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (List.cons.{u1} α a l)) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) (List.{u1} α) (List.{u1} α) (Functor.map.{u1, u1} Filter.{u1} Filter.instFunctorFilter.{u1} α ((List.{u1} α) -> (List.{u1} α)) (List.cons.{u1} α) (nhds.{u1} α _inst_1 a)) (fun (x._@.Mathlib.Topology.List._hyg.621 : Unit) => nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l))
-Case conversion may be inaccurate. Consider using '#align nhds_cons nhds_consₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem nhds_cons (a : α) (l : List α) : 𝓝 (a::l) = List.cons <$> 𝓝 a <*> 𝓝 l := by
   rw [nhds_list, List.traverse_cons _, ← nhds_list] <;> infer_instance
 #align nhds_cons nhds_cons
 
-/- warning: list.tendsto_cons -> List.tendsto_cons is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {a : α} {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (fun (p : Prod.{u1, u1} α (List.{u1} α)) => List.cons.{u1} α (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p)) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l)) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.cons.{u1} α a l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {a : α} {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (fun (p : Prod.{u1, u1} α (List.{u1} α)) => List.cons.{u1} α (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p)) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l)) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (List.cons.{u1} α a l))
-Case conversion may be inaccurate. Consider using '#align list.tendsto_cons List.tendsto_consₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem List.tendsto_cons {a : α} {l : List α} :
     Tendsto (fun p : α × List α => List.cons p.1 p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (a::l)) := by
   rw [nhds_cons, tendsto, Filter.map_prod] <;> exact le_rfl
 #align list.tendsto_cons List.tendsto_cons
 
-/- warning: filter.tendsto.cons -> Filter.Tendsto.cons is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} β] {α : Type.{u2}} {f : α -> β} {g : α -> (List.{u1} β)} {a : Filter.{u2} α} {b : β} {l : List.{u1} β}, (Filter.Tendsto.{u2, u1} α β f a (nhds.{u1} β _inst_2 b)) -> (Filter.Tendsto.{u2, u1} α (List.{u1} β) g a (nhds.{u1} (List.{u1} β) (List.topologicalSpace.{u1} β _inst_2) l)) -> (Filter.Tendsto.{u2, u1} α (List.{u1} β) (fun (a : α) => List.cons.{u1} β (f a) (g a)) a (nhds.{u1} (List.{u1} β) (List.topologicalSpace.{u1} β _inst_2) (List.cons.{u1} β b l)))
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} β] {α : Type.{u2}} {f : α -> β} {g : α -> (List.{u1} β)} {a : Filter.{u2} α} {b : β} {l : List.{u1} β}, (Filter.Tendsto.{u2, u1} α β f a (nhds.{u1} β _inst_2 b)) -> (Filter.Tendsto.{u2, u1} α (List.{u1} β) g a (nhds.{u1} (List.{u1} β) (instTopologicalSpaceList.{u1} β _inst_2) l)) -> (Filter.Tendsto.{u2, u1} α (List.{u1} β) (fun (a : α) => List.cons.{u1} β (f a) (g a)) a (nhds.{u1} (List.{u1} β) (instTopologicalSpaceList.{u1} β _inst_2) (List.cons.{u1} β b l)))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.cons Filter.Tendsto.consₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Filter.Tendsto.cons {α : Type _} {f : α → β} {g : α → List β} {a : Filter α} {b : β}
     {l : List β} (hf : Tendsto f a (𝓝 b)) (hg : Tendsto g a (𝓝 l)) :
@@ -123,12 +93,6 @@ theorem Filter.Tendsto.cons {α : Type _} {f : α → β} {g : α → List β} {
 
 namespace List
 
-/- warning: list.tendsto_cons_iff -> List.tendsto_cons_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {β : Type.{u2}} {f : (List.{u1} α) -> β} {b : Filter.{u2} β} {a : α} {l : List.{u1} α}, Iff (Filter.Tendsto.{u1, u2} (List.{u1} α) β f (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.cons.{u1} α a l)) b) (Filter.Tendsto.{u1, u2} (Prod.{u1, u1} α (List.{u1} α)) β (fun (p : Prod.{u1, u1} α (List.{u1} α)) => f (List.cons.{u1} α (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p))) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {β : Type.{u2}} {f : (List.{u1} α) -> β} {b : Filter.{u2} β} {a : α} {l : List.{u1} α}, Iff (Filter.Tendsto.{u1, u2} (List.{u1} α) β f (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (List.cons.{u1} α a l)) b) (Filter.Tendsto.{u1, u2} (Prod.{u1, u1} α (List.{u1} α)) β (fun (p : Prod.{u1, u1} α (List.{u1} α)) => f (List.cons.{u1} α (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p))) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l)) b)
-Case conversion may be inaccurate. Consider using '#align list.tendsto_cons_iff List.tendsto_cons_iffₓ'. -/
 /- ./././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 -/
@@ -144,23 +108,11 @@ theorem tendsto_cons_iff {β : Type _} {f : List α → β} {b : Filter β} {a :
   rw [this, Filter.tendsto_map'_iff]
 #align list.tendsto_cons_iff List.tendsto_cons_iff
 
-/- warning: list.continuous_cons -> List.continuous_cons is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α], Continuous.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (Prod.topologicalSpace.{u1, u1} α (List.{u1} α) _inst_1 (List.topologicalSpace.{u1} α _inst_1)) (List.topologicalSpace.{u1} α _inst_1) (fun (x : Prod.{u1, u1} α (List.{u1} α)) => List.cons.{u1} α (Prod.fst.{u1, u1} α (List.{u1} α) x) (Prod.snd.{u1, u1} α (List.{u1} α) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α], Continuous.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (instTopologicalSpaceProd.{u1, u1} α (List.{u1} α) _inst_1 (instTopologicalSpaceList.{u1} α _inst_1)) (instTopologicalSpaceList.{u1} α _inst_1) (fun (x : Prod.{u1, u1} α (List.{u1} α)) => List.cons.{u1} α (Prod.fst.{u1, u1} α (List.{u1} α) x) (Prod.snd.{u1, u1} α (List.{u1} α) x))
-Case conversion may be inaccurate. Consider using '#align list.continuous_cons List.continuous_consₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem continuous_cons : Continuous fun x : α × List α => (x.1::x.2 : List α) :=
   continuous_iff_continuousAt.mpr fun ⟨x, y⟩ => continuousAt_fst.cons continuousAt_snd
 #align list.continuous_cons List.continuous_cons
 
-/- warning: list.tendsto_nhds -> List.tendsto_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {β : Type.{u2}} {f : (List.{u1} α) -> β} {r : (List.{u1} α) -> (Filter.{u2} β)}, (Filter.Tendsto.{u1, u2} (List.{u1} α) β f (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} (List.{u1} α) (List.nil.{u1} α)) (r (List.nil.{u1} α))) -> (forall (l : List.{u1} α) (a : α), (Filter.Tendsto.{u1, u2} (List.{u1} α) β f (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l) (r l)) -> (Filter.Tendsto.{u1, u2} (Prod.{u1, u1} α (List.{u1} α)) β (fun (p : Prod.{u1, u1} α (List.{u1} α)) => f (List.cons.{u1} α (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p))) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l)) (r (List.cons.{u1} α a l)))) -> (forall (l : List.{u1} α), Filter.Tendsto.{u1, u2} (List.{u1} α) β f (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l) (r l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {β : Type.{u2}} {f : (List.{u1} α) -> β} {r : (List.{u1} α) -> (Filter.{u2} β)}, (Filter.Tendsto.{u1, u2} (List.{u1} α) β f (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} (List.{u1} α) (List.nil.{u1} α)) (r (List.nil.{u1} α))) -> (forall (l : List.{u1} α) (a : α), (Filter.Tendsto.{u1, u2} (List.{u1} α) β f (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l) (r l)) -> (Filter.Tendsto.{u1, u2} (Prod.{u1, u1} α (List.{u1} α)) β (fun (p : Prod.{u1, u1} α (List.{u1} α)) => f (List.cons.{u1} α (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p))) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l)) (r (List.cons.{u1} α a l)))) -> (forall (l : List.{u1} α), Filter.Tendsto.{u1, u2} (List.{u1} α) β f (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l) (r l))
-Case conversion may be inaccurate. Consider using '#align list.tendsto_nhds List.tendsto_nhdsₓ'. -/
 /- ./././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 -/
@@ -175,12 +127,6 @@ theorem tendsto_nhds {β : Type _} {f : List α → β} {r : List α → Filter
   | a::l => by rw [tendsto_cons_iff] <;> exact h_cons l a (tendsto_nhds l)
 #align list.tendsto_nhds List.tendsto_nhds
 
-/- warning: list.continuous_at_length -> List.continuousAt_length is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (l : List.{u1} α), ContinuousAt.{u1, 0} (List.{u1} α) Nat (List.topologicalSpace.{u1} α _inst_1) Nat.topologicalSpace (List.length.{u1} α) l
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (l : List.{u1} α), ContinuousAt.{u1, 0} (List.{u1} α) Nat (instTopologicalSpaceList.{u1} α _inst_1) instTopologicalSpaceNat (List.length.{u1} α) l
-Case conversion may be inaccurate. Consider using '#align list.continuous_at_length List.continuousAt_lengthₓ'. -/
 theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l :=
   by
   simp only [ContinuousAt, nhds_discrete]
@@ -192,12 +138,6 @@ theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l :=
     refine' tendsto.comp ih tendsto_snd
 #align list.continuous_at_length List.continuousAt_length
 
-/- warning: list.tendsto_insert_nth' -> List.tendsto_insertNth' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {a : α} {n : Nat} {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (fun (p : Prod.{u1, u1} α (List.{u1} α)) => List.insertNth.{u1} α n (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p)) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l)) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.insertNth.{u1} α n a l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {a : α} {n : Nat} {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (fun (p : Prod.{u1, u1} α (List.{u1} α)) => List.insertNth.{u1} α n (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p)) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l)) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (List.insertNth.{u1} α n a l))
-Case conversion may be inaccurate. Consider using '#align list.tendsto_insert_nth' List.tendsto_insertNth'ₓ'. -/
 /- ./././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 -/
@@ -219,35 +159,17 @@ theorem tendsto_insertNth' {a : α} :
         ((@tendsto_insert_nth' n l).comp <| tendsto_fst.prod_mk <| tendsto_snd.comp tendsto_snd)
 #align list.tendsto_insert_nth' List.tendsto_insertNth'
 
-/- warning: list.tendsto_insert_nth -> List.tendsto_insertNth is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {β : Type.{u2}} {n : Nat} {a : α} {l : List.{u1} α} {f : β -> α} {g : β -> (List.{u1} α)} {b : Filter.{u2} β}, (Filter.Tendsto.{u2, u1} β α f b (nhds.{u1} α _inst_1 a)) -> (Filter.Tendsto.{u2, u1} β (List.{u1} α) g b (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l)) -> (Filter.Tendsto.{u2, u1} β (List.{u1} α) (fun (b : β) => List.insertNth.{u1} α n (f b) (g b)) b (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.insertNth.{u1} α n a l)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {β : Type.{u2}} {n : Nat} {a : α} {l : List.{u1} α} {f : β -> α} {g : β -> (List.{u1} α)} {b : Filter.{u2} β}, (Filter.Tendsto.{u2, u1} β α f b (nhds.{u1} α _inst_1 a)) -> (Filter.Tendsto.{u2, u1} β (List.{u1} α) g b (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l)) -> (Filter.Tendsto.{u2, u1} β (List.{u1} α) (fun (b : β) => List.insertNth.{u1} α n (f b) (g b)) b (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (List.insertNth.{u1} α n a l)))
-Case conversion may be inaccurate. Consider using '#align list.tendsto_insert_nth List.tendsto_insertNthₓ'. -/
 theorem tendsto_insertNth {β} {n : ℕ} {a : α} {l : List α} {f : β → α} {g : β → List α}
     {b : Filter β} (hf : Tendsto f b (𝓝 a)) (hg : Tendsto g b (𝓝 l)) :
     Tendsto (fun b : β => insertNth n (f b) (g b)) b (𝓝 (insertNth n a l)) :=
   tendsto_insertNth'.comp (Tendsto.prod_mk hf hg)
 #align list.tendsto_insert_nth List.tendsto_insertNth
 
-/- warning: list.continuous_insert_nth -> List.continuous_insertNth is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat}, Continuous.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (Prod.topologicalSpace.{u1, u1} α (List.{u1} α) _inst_1 (List.topologicalSpace.{u1} α _inst_1)) (List.topologicalSpace.{u1} α _inst_1) (fun (p : Prod.{u1, u1} α (List.{u1} α)) => List.insertNth.{u1} α n (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat}, Continuous.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (instTopologicalSpaceProd.{u1, u1} α (List.{u1} α) _inst_1 (instTopologicalSpaceList.{u1} α _inst_1)) (instTopologicalSpaceList.{u1} α _inst_1) (fun (p : Prod.{u1, u1} α (List.{u1} α)) => List.insertNth.{u1} α n (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p))
-Case conversion may be inaccurate. Consider using '#align list.continuous_insert_nth List.continuous_insertNthₓ'. -/
 theorem continuous_insertNth {n : ℕ} : Continuous fun p : α × List α => insertNth n p.1 p.2 :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => by
     rw [ContinuousAt, nhds_prod_eq] <;> exact tendsto_insert_nth'
 #align list.continuous_insert_nth List.continuous_insertNth
 
-/- warning: list.tendsto_remove_nth -> List.tendsto_removeNth is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (List.{u1} α) (List.{u1} α) (fun (l : List.{u1} α) => List.removeNth.{u1} α l n) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.removeNth.{u1} α l n))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (List.{u1} α) (List.{u1} α) (fun (l : List.{u1} α) => List.removeNth.{u1} α l n) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (List.removeNth.{u1} α l n))
-Case conversion may be inaccurate. Consider using '#align list.tendsto_remove_nth List.tendsto_removeNthₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem tendsto_removeNth :
@@ -260,22 +182,10 @@ theorem tendsto_removeNth :
     exact tendsto_fst.cons ((@tendsto_remove_nth n l).comp tendsto_snd)
 #align list.tendsto_remove_nth List.tendsto_removeNth
 
-/- warning: list.continuous_remove_nth -> List.continuous_removeNth is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat}, Continuous.{u1, u1} (List.{u1} α) (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.topologicalSpace.{u1} α _inst_1) (fun (l : List.{u1} α) => List.removeNth.{u1} α l n)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat}, Continuous.{u1, u1} (List.{u1} α) (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (instTopologicalSpaceList.{u1} α _inst_1) (fun (l : List.{u1} α) => List.removeNth.{u1} α l n)
-Case conversion may be inaccurate. Consider using '#align list.continuous_remove_nth List.continuous_removeNthₓ'. -/
 theorem continuous_removeNth {n : ℕ} : Continuous fun l : List α => removeNth l n :=
   continuous_iff_continuousAt.mpr fun a => tendsto_removeNth
 #align list.continuous_remove_nth List.continuous_removeNth
 
-/- warning: list.tendsto_prod -> List.tendsto_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : Monoid.{u1} α] [_inst_4 : ContinuousMul.{u1} α _inst_1 (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3))] {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (List.{u1} α) α (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3))) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l) (nhds.{u1} α _inst_1 (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3)) l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : Monoid.{u1} α] [_inst_4 : ContinuousMul.{u1} α _inst_1 (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3))] {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (List.{u1} α) α (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3)) (Monoid.toOne.{u1} α _inst_3)) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l) (nhds.{u1} α _inst_1 (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3)) (Monoid.toOne.{u1} α _inst_3) l))
-Case conversion may be inaccurate. Consider using '#align list.tendsto_prod List.tendsto_prodₓ'. -/
 @[to_additive]
 theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
     Tendsto List.prod (𝓝 l) (𝓝 l.Prod) :=
@@ -289,12 +199,6 @@ theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
 #align list.tendsto_prod List.tendsto_prod
 #align list.tendsto_sum List.tendsto_sum
 
-/- warning: list.continuous_prod -> List.continuous_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : Monoid.{u1} α] [_inst_4 : ContinuousMul.{u1} α _inst_1 (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3))], Continuous.{u1, u1} (List.{u1} α) α (List.topologicalSpace.{u1} α _inst_1) _inst_1 (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : Monoid.{u1} α] [_inst_4 : ContinuousMul.{u1} α _inst_1 (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3))], Continuous.{u1, u1} (List.{u1} α) α (instTopologicalSpaceList.{u1} α _inst_1) _inst_1 (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_3)) (Monoid.toOne.{u1} α _inst_3))
-Case conversion may be inaccurate. Consider using '#align list.continuous_prod List.continuous_prodₓ'. -/
 @[to_additive]
 theorem continuous_prod [Monoid α] [ContinuousMul α] : Continuous (prod : List α → α) :=
   continuous_iff_continuousAt.mpr fun l => tendsto_prod
@@ -309,12 +213,6 @@ open List
 
 instance (n : ℕ) : TopologicalSpace (Vector α n) := by unfold Vector <;> infer_instance
 
-/- warning: vector.tendsto_cons -> Vector.tendsto_cons is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {a : α} {l : Vector.{u1} α n}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (Vector.{u1} α n)) (Vector.{u1} α (Nat.succ n)) (fun (p : Prod.{u1, u1} α (Vector.{u1} α n)) => Vector.cons.{u1} α n (Prod.fst.{u1, u1} α (Vector.{u1} α n) p) (Prod.snd.{u1, u1} α (Vector.{u1} α n) p)) (Filter.prod.{u1, u1} α (Vector.{u1} α n) (nhds.{u1} α _inst_1 a) (nhds.{u1} (Vector.{u1} α n) (Vector.topologicalSpace.{u1} α _inst_1 n) l)) (nhds.{u1} (Vector.{u1} α (Nat.succ n)) (Vector.topologicalSpace.{u1} α _inst_1 (Nat.succ n)) (Vector.cons.{u1} α n a l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {a : α} {l : Vector.{u1} α n}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (Vector.{u1} α n)) (Vector.{u1} α (Nat.succ n)) (fun (p : Prod.{u1, u1} α (Vector.{u1} α n)) => Vector.cons.{u1} α n (Prod.fst.{u1, u1} α (Vector.{u1} α n) p) (Prod.snd.{u1, u1} α (Vector.{u1} α n) p)) (Filter.prod.{u1, u1} α (Vector.{u1} α n) (nhds.{u1} α _inst_1 a) (nhds.{u1} (Vector.{u1} α n) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 n) l)) (nhds.{u1} (Vector.{u1} α (Nat.succ n)) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 (Nat.succ n)) (Vector.cons.{u1} α n a l))
-Case conversion may be inaccurate. Consider using '#align vector.tendsto_cons Vector.tendsto_consₓ'. -/
 theorem tendsto_cons {n : ℕ} {a : α} {l : Vector α n} :
     Tendsto (fun p : α × Vector α n => p.1 ::ᵥ p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (a ::ᵥ l)) :=
   by
@@ -322,12 +220,6 @@ theorem tendsto_cons {n : ℕ} {a : α} {l : Vector α n} :
   exact tendsto_fst.cons (tendsto.comp continuousAt_subtype_val tendsto_snd)
 #align vector.tendsto_cons Vector.tendsto_cons
 
-/- warning: vector.tendsto_insert_nth -> Vector.tendsto_insertNth is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {a : α} {l : Vector.{u1} α n}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (Vector.{u1} α n)) (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (p : Prod.{u1, u1} α (Vector.{u1} α n)) => Vector.insertNth.{u1} n α (Prod.fst.{u1, u1} α (Vector.{u1} α n) p) i (Prod.snd.{u1, u1} α (Vector.{u1} α n) p)) (Filter.prod.{u1, u1} α (Vector.{u1} α n) (nhds.{u1} α _inst_1 a) (nhds.{u1} (Vector.{u1} α n) (Vector.topologicalSpace.{u1} α _inst_1 n) l)) (nhds.{u1} (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.topologicalSpace.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.insertNth.{u1} n α a i l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {a : α} {l : Vector.{u1} α n}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (Vector.{u1} α n)) (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (p : Prod.{u1, u1} α (Vector.{u1} α n)) => Vector.insertNth.{u1} n α (Prod.fst.{u1, u1} α (Vector.{u1} α n) p) i (Prod.snd.{u1, u1} α (Vector.{u1} α n) p)) (Filter.prod.{u1, u1} α (Vector.{u1} α n) (nhds.{u1} α _inst_1 a) (nhds.{u1} (Vector.{u1} α n) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 n) l)) (nhds.{u1} (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.insertNth.{u1} n α a i l))
-Case conversion may be inaccurate. Consider using '#align vector.tendsto_insert_nth Vector.tendsto_insertNthₓ'. -/
 theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
     ∀ {l : Vector α n},
       Tendsto (fun p : α × Vector α n => insertNth p.1 i p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (insertNth a i l))
@@ -337,35 +229,17 @@ theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
     exact List.tendsto_insertNth tendsto_fst (tendsto.comp continuousAt_subtype_val tendsto_snd : _)
 #align vector.tendsto_insert_nth Vector.tendsto_insertNth
 
-/- warning: vector.continuous_insert_nth' -> Vector.continuous_insertNth' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))}, Continuous.{u1, u1} (Prod.{u1, u1} α (Vector.{u1} α n)) (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Prod.topologicalSpace.{u1, u1} α (Vector.{u1} α n) _inst_1 (Vector.topologicalSpace.{u1} α _inst_1 n)) (Vector.topologicalSpace.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (p : Prod.{u1, u1} α (Vector.{u1} α n)) => Vector.insertNth.{u1} n α (Prod.fst.{u1, u1} α (Vector.{u1} α n) p) i (Prod.snd.{u1, u1} α (Vector.{u1} α n) p))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))}, Continuous.{u1, u1} (Prod.{u1, u1} α (Vector.{u1} α n)) (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (instTopologicalSpaceProd.{u1, u1} α (Vector.{u1} α n) _inst_1 (Vector.instTopologicalSpaceVector.{u1} α _inst_1 n)) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (p : Prod.{u1, u1} α (Vector.{u1} α n)) => Vector.insertNth.{u1} n α (Prod.fst.{u1, u1} α (Vector.{u1} α n) p) i (Prod.snd.{u1, u1} α (Vector.{u1} α n) p))
-Case conversion may be inaccurate. Consider using '#align vector.continuous_insert_nth' Vector.continuous_insertNth'ₓ'. -/
 theorem continuous_insertNth' {n : ℕ} {i : Fin (n + 1)} :
     Continuous fun p : α × Vector α n => insertNth p.1 i p.2 :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => by
     rw [ContinuousAt, nhds_prod_eq] <;> exact tendsto_insert_nth
 #align vector.continuous_insert_nth' Vector.continuous_insertNth'
 
-/- warning: vector.continuous_insert_nth -> Vector.continuous_insertNth is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : TopologicalSpace.{u2} β] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {f : β -> α} {g : β -> (Vector.{u1} α n)}, (Continuous.{u2, u1} β α _inst_2 _inst_1 f) -> (Continuous.{u2, u1} β (Vector.{u1} α n) _inst_2 (Vector.topologicalSpace.{u1} α _inst_1 n) g) -> (Continuous.{u2, u1} β (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) _inst_2 (Vector.topologicalSpace.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (b : β) => Vector.insertNth.{u1} n α (f b) i (g b)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_2 : TopologicalSpace.{u1} β] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {f : β -> α} {g : β -> (Vector.{u2} α n)}, (Continuous.{u1, u2} β α _inst_2 _inst_1 f) -> (Continuous.{u1, u2} β (Vector.{u2} α n) _inst_2 (Vector.instTopologicalSpaceVector.{u2} α _inst_1 n) g) -> (Continuous.{u1, u2} β (Vector.{u2} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) _inst_2 (Vector.instTopologicalSpaceVector.{u2} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (b : β) => Vector.insertNth.{u2} n α (f b) i (g b)))
-Case conversion may be inaccurate. Consider using '#align vector.continuous_insert_nth Vector.continuous_insertNthₓ'. -/
 theorem continuous_insertNth {n : ℕ} {i : Fin (n + 1)} {f : β → α} {g : β → Vector α n}
     (hf : Continuous f) (hg : Continuous g) : Continuous fun b => insertNth (f b) i (g b) :=
   continuous_insertNth'.comp (hf.prod_mk hg : _)
 #align vector.continuous_insert_nth Vector.continuous_insertNth
 
-/- warning: vector.continuous_at_remove_nth -> Vector.continuousAt_removeNth is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {l : Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))}, ContinuousAt.{u1, u1} (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.{u1} α (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.topologicalSpace.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.topologicalSpace.{u1} α _inst_1 (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.removeNth.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) i) l
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {l : Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))}, ContinuousAt.{u1, u1} (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.{u1} α (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.removeNth.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) i) l
-Case conversion may be inaccurate. Consider using '#align vector.continuous_at_remove_nth Vector.continuousAt_removeNthₓ'. -/
 theorem continuousAt_removeNth {n : ℕ} {i : Fin (n + 1)} :
     ∀ {l : Vector α (n + 1)}, ContinuousAt (removeNth i) l
   | ⟨l, hl⟩ =>--  ∀{l:vector α (n+1)}, tendsto (remove_nth i) (𝓝 l) (𝓝 (remove_nth i l))
@@ -376,12 +250,6 @@ theorem continuousAt_removeNth {n : ℕ} {i : Fin (n + 1)} :
     exact tendsto.comp List.tendsto_removeNth continuousAt_subtype_val
 #align vector.continuous_at_remove_nth Vector.continuousAt_removeNth
 
-/- warning: vector.continuous_remove_nth -> Vector.continuous_removeNth is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))}, Continuous.{u1, u1} (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.{u1} α (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.topologicalSpace.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.topologicalSpace.{u1} α _inst_1 (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Vector.removeNth.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) i)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))}, Continuous.{u1, u1} (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.{u1} α (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (Vector.removeNth.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) i)
-Case conversion may be inaccurate. Consider using '#align vector.continuous_remove_nth Vector.continuous_removeNthₓ'. -/
 theorem continuous_removeNth {n : ℕ} {i : Fin (n + 1)} :
     Continuous (removeNth i : Vector α (n + 1) → Vector α n) :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => continuousAt_removeNth

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

@@ -39,8 +39,7 @@ Case conversion may be inaccurate. Consider using '#align nhds_list nhds_listₓ
 theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
   by
   refine' nhds_mk_of_nhds _ _ _ _
-  · intro l
-    induction l
+  · intro l; induction l
     case nil => exact le_rfl
     case
       cons a l ih =>
@@ -48,8 +47,7 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as :=
         simpa only [functor_norm] using this
       exact Filter.seq_mono (Filter.map_mono <| pure_le_nhds a) ih
   · intro l s hs
-    rcases(mem_traverse_iff _ _).1 hs with ⟨u, hu, hus⟩
-    clear as hs
+    rcases(mem_traverse_iff _ _).1 hs with ⟨u, hu, hus⟩; clear as hs
     have : ∃ v : List (Set α), l.forall₂ (fun a s => IsOpen s ∧ a ∈ s) v ∧ sequence v ⊆ s :=
       by
       induction hu generalizing s

mathlib commit https://github.com/leanprover-community/mathlib/commit/17ad94b4953419f3e3ce3e77da3239c62d1d09f0

@@ -194,16 +194,16 @@ theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l :=
     refine' tendsto.comp ih tendsto_snd
 #align list.continuous_at_length List.continuousAt_length
 
-/- warning: list.tendsto_insert_nth' -> List.tendsto_insert_nth' is a dubious translation:
+/- warning: list.tendsto_insert_nth' -> List.tendsto_insertNth' is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {a : α} {n : Nat} {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (fun (p : Prod.{u1, u1} α (List.{u1} α)) => List.insertNth.{u1} α n (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p)) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) l)) (nhds.{u1} (List.{u1} α) (List.topologicalSpace.{u1} α _inst_1) (List.insertNth.{u1} α n a l))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {a : α} {n : Nat} {l : List.{u1} α}, Filter.Tendsto.{u1, u1} (Prod.{u1, u1} α (List.{u1} α)) (List.{u1} α) (fun (p : Prod.{u1, u1} α (List.{u1} α)) => List.insertNth.{u1} α n (Prod.fst.{u1, u1} α (List.{u1} α) p) (Prod.snd.{u1, u1} α (List.{u1} α) p)) (Filter.prod.{u1, u1} α (List.{u1} α) (nhds.{u1} α _inst_1 a) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) l)) (nhds.{u1} (List.{u1} α) (instTopologicalSpaceList.{u1} α _inst_1) (List.insertNth.{u1} α n a l))
-Case conversion may be inaccurate. Consider using '#align list.tendsto_insert_nth' List.tendsto_insert_nth'ₓ'. -/
+Case conversion may be inaccurate. Consider using '#align list.tendsto_insert_nth' List.tendsto_insertNth'ₓ'. -/
 /- ./././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 -/
-theorem tendsto_insert_nth' {a : α} :
+theorem tendsto_insertNth' {a : α} :
     ∀ {n : ℕ} {l : List α},
       Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (insertNth n a l))
   | 0, l => tendsto_cons
@@ -219,7 +219,7 @@ theorem tendsto_insert_nth' {a : α} :
     exact
       (tendsto_fst.comp tendsto_snd).cons
         ((@tendsto_insert_nth' n l).comp <| tendsto_fst.prod_mk <| tendsto_snd.comp tendsto_snd)
-#align list.tendsto_insert_nth' List.tendsto_insert_nth'
+#align list.tendsto_insert_nth' List.tendsto_insertNth'
 
 /- warning: list.tendsto_insert_nth -> List.tendsto_insertNth is a dubious translation:
 lean 3 declaration is
@@ -230,7 +230,7 @@ Case conversion may be inaccurate. Consider using '#align list.tendsto_insert_nt
 theorem tendsto_insertNth {β} {n : ℕ} {a : α} {l : List α} {f : β → α} {g : β → List α}
     {b : Filter β} (hf : Tendsto f b (𝓝 a)) (hg : Tendsto g b (𝓝 l)) :
     Tendsto (fun b : β => insertNth n (f b) (g b)) b (𝓝 (insertNth n a l)) :=
-  tendsto_insert_nth'.comp (Tendsto.prod_mk hf hg)
+  tendsto_insertNth'.comp (Tendsto.prod_mk hf hg)
 #align list.tendsto_insert_nth List.tendsto_insertNth
 
 /- warning: list.continuous_insert_nth -> List.continuous_insertNth is a dubious translation:
@@ -339,17 +339,17 @@ theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
     exact List.tendsto_insertNth tendsto_fst (tendsto.comp continuousAt_subtype_val tendsto_snd : _)
 #align vector.tendsto_insert_nth Vector.tendsto_insertNth
 
-/- warning: vector.continuous_insert_nth' -> Vector.continuous_insert_nth' is a dubious translation:
+/- warning: vector.continuous_insert_nth' -> Vector.continuous_insertNth' is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))}, Continuous.{u1, u1} (Prod.{u1, u1} α (Vector.{u1} α n)) (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (Prod.topologicalSpace.{u1, u1} α (Vector.{u1} α n) _inst_1 (Vector.topologicalSpace.{u1} α _inst_1 n)) (Vector.topologicalSpace.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (p : Prod.{u1, u1} α (Vector.{u1} α n)) => Vector.insertNth.{u1} n α (Prod.fst.{u1, u1} α (Vector.{u1} α n) p) i (Prod.snd.{u1, u1} α (Vector.{u1} α n) p))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {n : Nat} {i : Fin (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))}, Continuous.{u1, u1} (Prod.{u1, u1} α (Vector.{u1} α n)) (Vector.{u1} α (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (instTopologicalSpaceProd.{u1, u1} α (Vector.{u1} α n) _inst_1 (Vector.instTopologicalSpaceVector.{u1} α _inst_1 n)) (Vector.instTopologicalSpaceVector.{u1} α _inst_1 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (p : Prod.{u1, u1} α (Vector.{u1} α n)) => Vector.insertNth.{u1} n α (Prod.fst.{u1, u1} α (Vector.{u1} α n) p) i (Prod.snd.{u1, u1} α (Vector.{u1} α n) p))
-Case conversion may be inaccurate. Consider using '#align vector.continuous_insert_nth' Vector.continuous_insert_nth'ₓ'. -/
-theorem continuous_insert_nth' {n : ℕ} {i : Fin (n + 1)} :
+Case conversion may be inaccurate. Consider using '#align vector.continuous_insert_nth' Vector.continuous_insertNth'ₓ'. -/
+theorem continuous_insertNth' {n : ℕ} {i : Fin (n + 1)} :
     Continuous fun p : α × Vector α n => insertNth p.1 i p.2 :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => by
     rw [ContinuousAt, nhds_prod_eq] <;> exact tendsto_insert_nth
-#align vector.continuous_insert_nth' Vector.continuous_insert_nth'
+#align vector.continuous_insert_nth' Vector.continuous_insertNth'
 
 /- warning: vector.continuous_insert_nth -> Vector.continuous_insertNth is a dubious translation:
 lean 3 declaration is
@@ -359,7 +359,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align vector.continuous_insert_nth Vector.continuous_insertNthₓ'. -/
 theorem continuous_insertNth {n : ℕ} {i : Fin (n + 1)} {f : β → α} {g : β → Vector α n}
     (hf : Continuous f) (hg : Continuous g) : Continuous fun b => insertNth (f b) i (g b) :=
-  continuous_insert_nth'.comp (hf.prod_mk hg : _)
+  continuous_insertNth'.comp (hf.prod_mk hg : _)
 #align vector.continuous_insert_nth Vector.continuous_insertNth
 
 /- warning: vector.continuous_at_remove_nth -> Vector.continuousAt_removeNth is a dubious translation:

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

@@ -57,7 +57,9 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
     have : List.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) u v := by
       refine' List.Forall₂.flip _
       replace hv := hv.flip
-      simp only [List.forall₂_and_left, flip] at hv ⊢
+      -- Adaptation note: nightly-2024-03-16: simp was
+      -- simp only [List.forall₂_and_left, flip] at hv ⊢
+      simp only [List.forall₂_and_left, Function.flip_def] at hv ⊢
       exact ⟨hv.1, hu.flip⟩
     refine' mem_of_superset _ hvs
     exact mem_traverse _ _ (this.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha)

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

@@ -117,7 +117,7 @@ theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l := by
   · intro l a ih
     dsimp only [List.length]
     refine' Tendsto.comp (tendsto_pure_pure (fun x => x + 1) _) _
-    refine' Tendsto.comp ih tendsto_snd
+    exact Tendsto.comp ih tendsto_snd
 #align list.continuous_at_length List.continuousAt_length
 
 theorem tendsto_insertNth' {a : α} :

No changes to tactic file, it's just boring fixes throughout the library.

This follows on from #6964.

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -36,19 +36,19 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
   · intro l s hs
     rcases (mem_traverse_iff _ _).1 hs with ⟨u, hu, hus⟩
     clear as hs
-    have : ∃ v : List (Set α), l.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) v ∧ sequence v ⊆ s
-    induction hu generalizing s with
-    | nil =>
-      exists []
-      simp only [List.forall₂_nil_left_iff, exists_eq_left]
-      exact ⟨trivial, hus⟩
-    -- porting note -- renamed reordered variables based on previous types
-    | cons ht _ ih =>
-      rcases mem_nhds_iff.1 ht with ⟨u, hut, hu⟩
-      rcases ih _ Subset.rfl with ⟨v, hv, hvss⟩
-      exact
-        ⟨u::v, List.Forall₂.cons hu hv,
-          Subset.trans (Set.seq_mono (Set.image_subset _ hut) hvss) hus⟩
+    have : ∃ v : List (Set α), l.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) v ∧ sequence v ⊆ s := by
+      induction hu generalizing s with
+      | nil =>
+        exists []
+        simp only [List.forall₂_nil_left_iff, exists_eq_left]
+        exact ⟨trivial, hus⟩
+      -- porting note -- renamed reordered variables based on previous types
+      | cons ht _ ih =>
+        rcases mem_nhds_iff.1 ht with ⟨u, hut, hu⟩
+        rcases ih _ Subset.rfl with ⟨v, hv, hvss⟩
+        exact
+          ⟨u::v, List.Forall₂.cons hu hv,
+            Subset.trans (Set.seq_mono (Set.image_subset _ hut) hvss) hus⟩
     rcases this with ⟨v, hv, hvs⟩
     have : sequence v ∈ traverse 𝓝 l :=
       mem_traverse _ _ <| hv.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha

• add TopologicalSpace.nhds_mkOfNhds_of_hasBasis
• add Trans instance for Filter.mem_of_superset
• change assumptions of TopologicalSpace.nhds_mkOfNhds, golf
  • the new assumption is equivalent to the old one with t ⊆ s removed
  • but is formulated in terms of Filter.Eventually

@@ -50,17 +50,17 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
         ⟨u::v, List.Forall₂.cons hu hv,
           Subset.trans (Set.seq_mono (Set.image_subset _ hut) hvss) hus⟩
     rcases this with ⟨v, hv, hvs⟩
-    refine' ⟨sequence v, mem_traverse _ _ _, hvs, _⟩
-    · exact hv.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha
-    · intro u hu
-      have hu := (List.mem_traverse _ _).1 hu
-      have : List.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) u v := by
-        refine' List.Forall₂.flip _
-        replace hv := hv.flip
-        simp only [List.forall₂_and_left, flip] at hv ⊢
-        exact ⟨hv.1, hu.flip⟩
-      refine' mem_of_superset _ hvs
-      exact mem_traverse _ _ (this.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha)
+    have : sequence v ∈ traverse 𝓝 l :=
+      mem_traverse _ _ <| hv.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha
+    refine mem_of_superset this fun u hu ↦ ?_
+    have hu := (List.mem_traverse _ _).1 hu
+    have : List.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) u v := by
+      refine' List.Forall₂.flip _
+      replace hv := hv.flip
+      simp only [List.forall₂_and_left, flip] at hv ⊢
+      exact ⟨hv.1, hu.flip⟩
+    refine' mem_of_superset _ hvs
+    exact mem_traverse _ _ (this.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha)
 #align nhds_list nhds_list
 
 @[simp]

@@ -5,6 +5,7 @@ Authors: Johannes Hölzl
 -/
 import Mathlib.Topology.Constructions
 import Mathlib.Topology.Algebra.Monoid
+import Mathlib.Order.Filter.ListTraverse
 
 #align_import topology.list from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
 

This converts usages of the pattern

cases h
case inl h' => ...
case inr h' => ...

which derive from mathported code, to the "structured cases" syntax:

cases h with
| inl h' => ...
| inr h' => ...

The case where the subgoals are handled with · instead of case is more contentious (and much more numerous) so I left those alone. This pattern also appears with cases', induction, induction', and rcases. Furthermore, there is a similar transformation for by_cases:

by_cases h : cond
case pos => ...
case neg => ...

is replaced by:

if h : cond then
  ...
else
  ...

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -26,9 +26,9 @@ instance : TopologicalSpace (List α) :=
 theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
   refine' nhds_mkOfNhds _ _ _ _
   · intro l
-    induction l
-    case nil => exact le_rfl
-    case cons a l ih =>
+    induction l with
+    | nil => exact le_rfl
+    | cons a l ih =>
       suffices List.cons <$> pure a <*> pure l ≤ List.cons <$> 𝓝 a <*> traverse 𝓝 l by
         simpa only [functor_norm] using this
       exact Filter.seq_mono (Filter.map_mono <| pure_le_nhds a) ih
@@ -36,13 +36,13 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
     rcases (mem_traverse_iff _ _).1 hs with ⟨u, hu, hus⟩
     clear as hs
     have : ∃ v : List (Set α), l.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) v ∧ sequence v ⊆ s
-    induction hu generalizing s
-    case nil _hs =>
+    induction hu generalizing s with
+    | nil =>
       exists []
       simp only [List.forall₂_nil_left_iff, exists_eq_left]
       exact ⟨trivial, hus⟩
     -- porting note -- renamed reordered variables based on previous types
-    case cons a s as ss hts h ht _ ih =>
+    | cons ht _ ih =>
       rcases mem_nhds_iff.1 ht with ⟨u, hut, hu⟩
       rcases ih _ Subset.rfl with ⟨v, hv, hvss⟩
       exact

Removes nonterminal simps on lines looking like simp [...]

@@ -197,7 +197,7 @@ theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
       Tendsto (fun p : α × Vector α n => insertNth p.1 i p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth a i l))
   | ⟨l, hl⟩ => by
     rw [insertNth, tendsto_subtype_rng]
-    simp [insertNth_val]
+    simp only [insertNth_val]
     exact List.tendsto_insertNth tendsto_fst (Tendsto.comp continuousAt_subtype_val tendsto_snd : _)
 #align vector.tendsto_insert_nth Vector.tendsto_insertNth
 

Replace rcases( with rcases (. Same thing for convert( and congrm(. No other change.

@@ -33,7 +33,7 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
         simpa only [functor_norm] using this
       exact Filter.seq_mono (Filter.map_mono <| pure_le_nhds a) ih
   · intro l s hs
-    rcases(mem_traverse_iff _ _).1 hs with ⟨u, hu, hus⟩
+    rcases (mem_traverse_iff _ _).1 hs with ⟨u, hu, hus⟩
     clear as hs
     have : ∃ v : List (Set α), l.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) v ∧ sequence v ⊆ s
     induction hu generalizing s

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -90,7 +90,7 @@ theorem tendsto_cons_iff {β : Type*} {f : List α → β} {b : Filter β} {a :
     simp only [nhds_cons, Filter.prod_eq, (Filter.map_def _ _).symm,
       (Filter.seq_eq_filter_seq _ _).symm]
     simp [-Filter.map_def, (· ∘ ·), functor_norm]
-  rw [this, Filter.tendsto_map'_iff]; dsimp; rfl
+  rw [this, Filter.tendsto_map'_iff]; rfl
 #align list.tendsto_cons_iff List.tendsto_cons_iff
 
 theorem continuous_cons : Continuous fun x : α × List α => (x.1::x.2 : List α) :=

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

This has nice performance benefits.

@@ -18,7 +18,7 @@ open TopologicalSpace Set Filter
 
 open Topology Filter
 
-variable {α : Type _} {β : Type _} [TopologicalSpace α] [TopologicalSpace β]
+variable {α : Type*} {β : Type*} [TopologicalSpace α] [TopologicalSpace β]
 
 instance : TopologicalSpace (List α) :=
   TopologicalSpace.mkOfNhds (traverse nhds)
@@ -76,7 +76,7 @@ theorem List.tendsto_cons {a : α} {l : List α} :
   rw [nhds_cons, Tendsto, Filter.map_prod]; exact le_rfl
 #align list.tendsto_cons List.tendsto_cons
 
-theorem Filter.Tendsto.cons {α : Type _} {f : α → β} {g : α → List β} {a : Filter α} {b : β}
+theorem Filter.Tendsto.cons {α : Type*} {f : α → β} {g : α → List β} {a : Filter α} {b : β}
     {l : List β} (hf : Tendsto f a (𝓝 b)) (hg : Tendsto g a (𝓝 l)) :
     Tendsto (fun a => List.cons (f a) (g a)) a (𝓝 (b::l)) :=
   List.tendsto_cons.comp (Tendsto.prod_mk hf hg)
@@ -84,7 +84,7 @@ theorem Filter.Tendsto.cons {α : Type _} {f : α → β} {g : α → List β} {
 
 namespace List
 
-theorem tendsto_cons_iff {β : Type _} {f : List α → β} {b : Filter β} {a : α} {l : List α} :
+theorem tendsto_cons_iff {β : Type*} {f : List α → β} {b : Filter β} {a : α} {l : List α} :
     Tendsto f (𝓝 (a::l)) b ↔ Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ˢ 𝓝 l) b := by
   have : 𝓝 (a::l) = (𝓝 a ×ˢ 𝓝 l).map fun p : α × List α => p.1::p.2 := by
     simp only [nhds_cons, Filter.prod_eq, (Filter.map_def _ _).symm,
@@ -97,7 +97,7 @@ theorem continuous_cons : Continuous fun x : α × List α => (x.1::x.2 : List 
   continuous_iff_continuousAt.mpr fun ⟨_x, _y⟩ => continuousAt_fst.cons continuousAt_snd
 #align list.continuous_cons List.continuous_cons
 
-theorem tendsto_nhds {β : Type _} {f : List α → β} {r : List α → Filter β}
+theorem tendsto_nhds {β : Type*} {f : List α → β} {r : List α → Filter β}
     (h_nil : Tendsto f (pure []) (r []))
     (h_cons :
       ∀ l a,

• 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) 2019 Reid Barton. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
-
-! This file was ported from Lean 3 source module topology.list
-! leanprover-community/mathlib commit 48085f140e684306f9e7da907cd5932056d1aded
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.Constructions
 import Mathlib.Topology.Algebra.Monoid
 
+#align_import topology.list from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
+
 /-!
 # Topology on lists and vectors
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -40,7 +40,7 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
     clear as hs
     have : ∃ v : List (Set α), l.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) v ∧ sequence v ⊆ s
     induction hu generalizing s
-    case nil _hs  =>
+    case nil _hs =>
       exists []
       simp only [List.forall₂_nil_left_iff, exists_eq_left]
       exact ⟨trivial, hus⟩
@@ -109,7 +109,7 @@ theorem tendsto_nhds {β : Type _} {f : List α → β} {r : List α → Filter
     ∀ l, Tendsto f (𝓝 l) (r l)
   | [] => by rwa [nhds_nil]
   | a::l => by
-    rw [tendsto_cons_iff];  exact h_cons l a (@tendsto_nhds _ _ _ h_nil h_cons l)
+    rw [tendsto_cons_iff]; exact h_cons l a (@tendsto_nhds _ _ _ h_nil h_cons l)
 #align list.tendsto_nhds List.tendsto_nhds
 
 theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l := by

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

@@ -93,7 +93,7 @@ theorem tendsto_cons_iff {β : Type _} {f : List α → β} {b : Filter β} {a :
     simp only [nhds_cons, Filter.prod_eq, (Filter.map_def _ _).symm,
       (Filter.seq_eq_filter_seq _ _).symm]
     simp [-Filter.map_def, (· ∘ ·), functor_norm]
-  rw [this, Filter.tendsto_map'_iff] ; dsimp; rfl
+  rw [this, Filter.tendsto_map'_iff]; dsimp; rfl
 #align list.tendsto_cons_iff List.tendsto_cons_iff
 
 theorem continuous_cons : Continuous fun x : α × List α => (x.1::x.2 : List α) :=

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -59,7 +59,7 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
       have : List.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) u v := by
         refine' List.Forall₂.flip _
         replace hv := hv.flip
-        simp only [List.forall₂_and_left, flip] at hv⊢
+        simp only [List.forall₂_and_left, flip] at hv ⊢
         exact ⟨hv.1, hu.flip⟩
       refine' mem_of_superset _ hvs
       exact mem_traverse _ _ (this.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha)

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>

@@ -75,7 +75,7 @@ theorem nhds_cons (a : α) (l : List α) : 𝓝 (a::l) = List.cons <$> 𝓝 a <*
 #align nhds_cons nhds_cons
 
 theorem List.tendsto_cons {a : α} {l : List α} :
-    Tendsto (fun p : α × List α => List.cons p.1 p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (a::l)) := by
+    Tendsto (fun p : α × List α => List.cons p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a::l)) := by
   rw [nhds_cons, Tendsto, Filter.map_prod]; exact le_rfl
 #align list.tendsto_cons List.tendsto_cons
 
@@ -88,8 +88,8 @@ theorem Filter.Tendsto.cons {α : Type _} {f : α → β} {g : α → List β} {
 namespace List
 
 theorem tendsto_cons_iff {β : Type _} {f : List α → β} {b : Filter β} {a : α} {l : List α} :
-    Tendsto f (𝓝 (a::l)) b ↔ Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ᶠ 𝓝 l) b := by
-  have : 𝓝 (a::l) = (𝓝 a ×ᶠ 𝓝 l).map fun p : α × List α => p.1::p.2 := by
+    Tendsto f (𝓝 (a::l)) b ↔ Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ˢ 𝓝 l) b := by
+  have : 𝓝 (a::l) = (𝓝 a ×ˢ 𝓝 l).map fun p : α × List α => p.1::p.2 := by
     simp only [nhds_cons, Filter.prod_eq, (Filter.map_def _ _).symm,
       (Filter.seq_eq_filter_seq _ _).symm]
     simp [-Filter.map_def, (· ∘ ·), functor_norm]
@@ -105,7 +105,7 @@ theorem tendsto_nhds {β : Type _} {f : List α → β} {r : List α → Filter
     (h_cons :
       ∀ l a,
         Tendsto f (𝓝 l) (r l) →
-          Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ᶠ 𝓝 l) (r (a::l))) :
+          Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ˢ 𝓝 l) (r (a::l))) :
     ∀ l, Tendsto f (𝓝 l) (r l)
   | [] => by rwa [nhds_nil]
   | a::l => by
@@ -124,12 +124,12 @@ theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l := by
 
 theorem tendsto_insertNth' {a : α} :
     ∀ {n : ℕ} {l : List α},
-      Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (insertNth n a l))
+      Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n a l))
   | 0, l => tendsto_cons
   | n + 1, [] => by simp
   | n + 1, a'::l => by
-    have : 𝓝 a ×ᶠ 𝓝 (a'::l) =
-        (𝓝 a ×ᶠ (𝓝 a' ×ᶠ 𝓝 l)).map fun p : α × α × List α => (p.1, p.2.1::p.2.2) := by
+    have : 𝓝 a ×ˢ 𝓝 (a'::l) =
+        (𝓝 a ×ˢ (𝓝 a' ×ˢ 𝓝 l)).map fun p : α × α × List α => (p.1, p.2.1::p.2.2) := by
       simp only [nhds_cons, Filter.prod_eq, ← Filter.map_def, ← Filter.seq_eq_filter_seq]
       simp [-Filter.map_def, (· ∘ ·), functor_norm]
     rw [this, tendsto_map'_iff]
@@ -190,14 +190,14 @@ open List
 instance (n : ℕ) : TopologicalSpace (Vector α n) := by unfold Vector; infer_instance
 
 theorem tendsto_cons {n : ℕ} {a : α} {l : Vector α n} :
-    Tendsto (fun p : α × Vector α n => p.1 ::ᵥ p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (a ::ᵥ l)) := by
+    Tendsto (fun p : α × Vector α n => p.1 ::ᵥ p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a ::ᵥ l)) := by
   rw [tendsto_subtype_rng, cons_val]
   exact tendsto_fst.cons (Tendsto.comp continuousAt_subtype_val tendsto_snd)
 #align vector.tendsto_cons Vector.tendsto_cons
 
 theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
     ∀ {l : Vector α n},
-      Tendsto (fun p : α × Vector α n => insertNth p.1 i p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (insertNth a i l))
+      Tendsto (fun p : α × Vector α n => insertNth p.1 i p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth a i l))
   | ⟨l, hl⟩ => by
     rw [insertNth, tendsto_subtype_rng]
     simp [insertNth_val]

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -56,8 +56,7 @@ theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as := by
     · exact hv.imp fun a s ⟨hs, ha⟩ => IsOpen.mem_nhds hs ha
     · intro u hu
       have hu := (List.mem_traverse _ _).1 hu
-      have : List.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) u v :=
-        by
+      have : List.Forall₂ (fun a s => IsOpen s ∧ a ∈ s) u v := by
         refine' List.Forall₂.flip _
         replace hv := hv.flip
         simp only [List.forall₂_and_left, flip] at hv⊢
@@ -90,8 +89,7 @@ namespace List
 
 theorem tendsto_cons_iff {β : Type _} {f : List α → β} {b : Filter β} {a : α} {l : List α} :
     Tendsto f (𝓝 (a::l)) b ↔ Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ᶠ 𝓝 l) b := by
-  have : 𝓝 (a::l) = (𝓝 a ×ᶠ 𝓝 l).map fun p : α × List α => p.1::p.2 :=
-    by
+  have : 𝓝 (a::l) = (𝓝 a ×ᶠ 𝓝 l).map fun p : α × List α => p.1::p.2 := by
     simp only [nhds_cons, Filter.prod_eq, (Filter.map_def _ _).symm,
       (Filter.seq_eq_filter_seq _ _).symm]
     simp [-Filter.map_def, (· ∘ ·), functor_norm]
@@ -129,11 +127,9 @@ theorem tendsto_insertNth' {a : α} :
       Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (insertNth n a l))
   | 0, l => tendsto_cons
   | n + 1, [] => by simp
-  | n + 1, a'::l =>
-    by
-    have :
-      𝓝 a ×ᶠ 𝓝 (a'::l) = (𝓝 a ×ᶠ (𝓝 a' ×ᶠ 𝓝 l)).map fun p : α × α × List α => (p.1, p.2.1::p.2.2) :=
-      by
+  | n + 1, a'::l => by
+    have : 𝓝 a ×ᶠ 𝓝 (a'::l) =
+        (𝓝 a ×ᶠ (𝓝 a' ×ᶠ 𝓝 l)).map fun p : α × α × List α => (p.1, p.2.1::p.2.2) := by
       simp only [nhds_cons, Filter.prod_eq, ← Filter.map_def, ← Filter.seq_eq_filter_seq]
       simp [-Filter.map_def, (· ∘ ·), functor_norm]
     rw [this, tendsto_map'_iff]

This PR fixes two things:

• Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
• All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

@@ -112,7 +112,6 @@ theorem tendsto_nhds {β : Type _} {f : List α → β} {r : List α → Filter
   | [] => by rwa [nhds_nil]
   | a::l => by
     rw [tendsto_cons_iff];  exact h_cons l a (@tendsto_nhds _ _ _ h_nil h_cons l)
-
 #align list.tendsto_nhds List.tendsto_nhds
 
 theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l := by

@@ -125,7 +125,7 @@ theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l := by
     refine' Tendsto.comp ih tendsto_snd
 #align list.continuous_at_length List.continuousAt_length
 
-theorem tendsto_insert_nth' {a : α} :
+theorem tendsto_insertNth' {a : α} :
     ∀ {n : ℕ} {l : List α},
       Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ᶠ 𝓝 l) (𝓝 (insertNth n a l))
   | 0, l => tendsto_cons
@@ -140,18 +140,18 @@ theorem tendsto_insert_nth' {a : α} :
     rw [this, tendsto_map'_iff]
     exact
       (tendsto_fst.comp tendsto_snd).cons
-        ((@tendsto_insert_nth' _ n l).comp <| tendsto_fst.prod_mk <| tendsto_snd.comp tendsto_snd)
-#align list.tendsto_insert_nth' List.tendsto_insert_nth'
+        ((@tendsto_insertNth' _ n l).comp <| tendsto_fst.prod_mk <| tendsto_snd.comp tendsto_snd)
+#align list.tendsto_insert_nth' List.tendsto_insertNth'
 
 theorem tendsto_insertNth {β} {n : ℕ} {a : α} {l : List α} {f : β → α} {g : β → List α}
     {b : Filter β} (hf : Tendsto f b (𝓝 a)) (hg : Tendsto g b (𝓝 l)) :
     Tendsto (fun b : β => insertNth n (f b) (g b)) b (𝓝 (insertNth n a l)) :=
-  tendsto_insert_nth'.comp (Tendsto.prod_mk hf hg)
+  tendsto_insertNth'.comp (Tendsto.prod_mk hf hg)
 #align list.tendsto_insert_nth List.tendsto_insertNth
 
 theorem continuous_insertNth {n : ℕ} : Continuous fun p : α × List α => insertNth n p.1 p.2 :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => by
-    rw [ContinuousAt, nhds_prod_eq]; exact tendsto_insert_nth'
+    rw [ContinuousAt, nhds_prod_eq]; exact tendsto_insertNth'
 #align list.continuous_insert_nth List.continuous_insertNth
 
 theorem tendsto_removeNth :
@@ -209,22 +209,20 @@ theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
     exact List.tendsto_insertNth tendsto_fst (Tendsto.comp continuousAt_subtype_val tendsto_snd : _)
 #align vector.tendsto_insert_nth Vector.tendsto_insertNth
 
-theorem continuous_insert_nth' {n : ℕ} {i : Fin (n + 1)} :
+theorem continuous_insertNth' {n : ℕ} {i : Fin (n + 1)} :
     Continuous fun p : α × Vector α n => insertNth p.1 i p.2 :=
   continuous_iff_continuousAt.mpr fun ⟨a, l⟩ => by
     rw [ContinuousAt, nhds_prod_eq]; exact tendsto_insertNth
-#align vector.continuous_insert_nth' Vector.continuous_insert_nth'
+#align vector.continuous_insert_nth' Vector.continuous_insertNth'
 
 theorem continuous_insertNth {n : ℕ} {i : Fin (n + 1)} {f : β → α} {g : β → Vector α n}
     (hf : Continuous f) (hg : Continuous g) : Continuous fun b => insertNth (f b) i (g b) :=
-  continuous_insert_nth'.comp (hf.prod_mk hg : _)
+  continuous_insertNth'.comp (hf.prod_mk hg : _)
 #align vector.continuous_insert_nth Vector.continuous_insertNth
 
 theorem continuousAt_removeNth {n : ℕ} {i : Fin (n + 1)} :
     ∀ {l : Vector α (n + 1)}, ContinuousAt (removeNth i) l
-  | ⟨l, hl⟩ =>--  ∀{l:vector α (n+1)}, tendsto (remove_nth i) (𝓝 l) (𝓝 (remove_nth i l))
-  --| ⟨l, hl⟩ :=
-  by
+  | ⟨l, hl⟩ => by
     rw [ContinuousAt, removeNth, tendsto_subtype_rng]
     simp only [Vector.removeNth_val]
     exact Tendsto.comp List.tendsto_removeNth continuousAt_subtype_val

port of topology.list