analysis.normed.field.infinite_sum ⟷ Mathlib.Analysis.Normed.Field.InfiniteSum

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

@@ -59,7 +59,7 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
 #print Summable.mul_norm /-
 theorem Summable.mul_norm {f : ι → α} {g : ι' → α} (hf : Summable fun x => ‖f x‖)
     (hg : Summable fun x => ‖g x‖) : Summable fun x : ι × ι' => ‖f x.1 * g x.2‖ :=
-  summable_of_nonneg_of_le (fun x => norm_nonneg (f x.1 * g x.2))
+  Summable.of_nonneg_of_le (fun x => norm_nonneg (f x.1 * g x.2))
     (fun x => norm_mul_le (f x.1) (g x.2))
     (hf.mul_of_nonneg hg (fun x => norm_nonneg <| f x) fun x => norm_nonneg <| g x : _)
 #align summable.mul_norm Summable.mul_norm
@@ -69,7 +69,7 @@ theorem Summable.mul_norm {f : ι → α} {g : ι' → α} (hf : Summable fun x
 theorem summable_mul_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     Summable fun x : ι × ι' => f x.1 * g x.2 :=
-  summable_of_summable_norm (hf.mul_norm hg)
+  Summable.of_norm (hf.mul_norm hg)
 #align summable_mul_of_summable_norm summable_mul_of_summable_norm
 -/
 
@@ -79,8 +79,7 @@ theorem summable_mul_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι
 theorem tsum_mul_tsum_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     (∑' x, f x) * ∑' y, g y = ∑' z : ι × ι', f z.1 * g z.2 :=
-  tsum_mul_tsum (summable_of_summable_norm hf) (summable_of_summable_norm hg)
-    (summable_mul_of_summable_norm hf hg)
+  tsum_mul_tsum (Summable.of_norm hf) (Summable.of_norm hg) (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_of_summable_norm tsum_mul_tsum_of_summable_norm
 -/
 
@@ -107,7 +106,7 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → α}
   have :=
     summable_sum_mul_antidiagonal_of_summable_mul
       (Summable.mul_of_nonneg hf hg (fun _ => norm_nonneg _) fun _ => norm_nonneg _)
-  refine' summable_of_nonneg_of_le (fun _ => norm_nonneg _) _ this
+  refine' Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ this
   intro n
   calc
     ‖∑ kl in antidiagonal n, f kl.1 * g kl.2‖ ≤ ∑ kl in antidiagonal n, ‖f kl.1 * g kl.2‖ :=
@@ -124,8 +123,8 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → α}
 theorem tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm [CompleteSpace α] {f g : ℕ → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     (∑' n, f n) * ∑' n, g n = ∑' n, ∑ kl in antidiagonal n, f kl.1 * g kl.2 :=
-  tsum_mul_tsum_eq_tsum_sum_antidiagonal (summable_of_summable_norm hf)
-    (summable_of_summable_norm hg) (summable_mul_of_summable_norm hf hg)
+  tsum_mul_tsum_eq_tsum_sum_antidiagonal (Summable.of_norm hf) (Summable.of_norm hg)
+    (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm
 -/
 

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

@@ -3,8 +3,8 @@ Copyright (c) 2021 Anatole Dedecker. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anatole Dedecker
 -/
-import Mathbin.Analysis.Normed.Field.Basic
-import Mathbin.Analysis.Normed.Group.InfiniteSum
+import Analysis.Normed.Field.Basic
+import Analysis.Normed.Group.InfiniteSum
 
 #align_import analysis.normed.field.infinite_sum from "leanprover-community/mathlib"@"10bf4f825ad729c5653adc039dafa3622e7f93c9"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Anatole Dedecker. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anatole Dedecker
-
-! This file was ported from Lean 3 source module analysis.normed.field.infinite_sum
-! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.Normed.Field.Basic
 import Mathbin.Analysis.Normed.Group.InfiniteSum
 
+#align_import analysis.normed.field.infinite_sum from "leanprover-community/mathlib"@"10bf4f825ad729c5653adc039dafa3622e7f93c9"
+
 /-! # Multiplying two infinite sums in a normed ring
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.

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

@@ -36,6 +36,7 @@ open Finset
 
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Summable.mul_of_nonneg /-
 theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable f) (hg : Summable g)
     (hf' : 0 ≤ f) (hg' : 0 ≤ g) : Summable fun x : ι × ι' => f x.1 * g x.2 :=
   let ⟨s, hf⟩ := hf
@@ -56,20 +57,26 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
     _ ≤ s * t :=
       mul_le_mul_of_nonneg_right (sum_le_hasSum _ (fun _ _ => hf' _) hf) (hg.NonNeg fun _ => hg' _)
 #align summable.mul_of_nonneg Summable.mul_of_nonneg
+-/
 
+#print Summable.mul_norm /-
 theorem Summable.mul_norm {f : ι → α} {g : ι' → α} (hf : Summable fun x => ‖f x‖)
     (hg : Summable fun x => ‖g x‖) : Summable fun x : ι × ι' => ‖f x.1 * g x.2‖ :=
   summable_of_nonneg_of_le (fun x => norm_nonneg (f x.1 * g x.2))
     (fun x => norm_mul_le (f x.1) (g x.2))
     (hf.mul_of_nonneg hg (fun x => norm_nonneg <| f x) fun x => norm_nonneg <| g x : _)
 #align summable.mul_norm Summable.mul_norm
+-/
 
+#print summable_mul_of_summable_norm /-
 theorem summable_mul_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     Summable fun x : ι × ι' => f x.1 * g x.2 :=
   summable_of_summable_norm (hf.mul_norm hg)
 #align summable_mul_of_summable_norm summable_mul_of_summable_norm
+-/
 
+#print tsum_mul_tsum_of_summable_norm /-
 /-- Product of two infinites sums indexed by arbitrary types.
     See also `tsum_mul_tsum` if `f` and `g` are *not* absolutely summable. -/
 theorem tsum_mul_tsum_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
@@ -78,6 +85,7 @@ theorem tsum_mul_tsum_of_summable_norm [CompleteSpace α] {f : ι → α} {g : 
   tsum_mul_tsum (summable_of_summable_norm hf) (summable_of_summable_norm hg)
     (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_of_summable_norm tsum_mul_tsum_of_summable_norm
+-/
 
 /-! ### `ℕ`-indexed families (Cauchy product)
 
@@ -111,6 +119,7 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → α}
 #align summable_norm_sum_mul_antidiagonal_of_summable_norm summable_norm_sum_mul_antidiagonal_of_summable_norm
 -/
 
+#print tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm /-
 /-- The Cauchy product formula for the product of two infinite sums indexed by `ℕ`,
     expressed by summing on `finset.nat.antidiagonal`.
     See also `tsum_mul_tsum_eq_tsum_sum_antidiagonal` if `f` and `g` are
@@ -121,14 +130,18 @@ theorem tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm [CompleteSpace 
   tsum_mul_tsum_eq_tsum_sum_antidiagonal (summable_of_summable_norm hf)
     (summable_of_summable_norm hg) (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm
+-/
 
+#print summable_norm_sum_mul_range_of_summable_norm /-
 theorem summable_norm_sum_mul_range_of_summable_norm {f g : ℕ → α} (hf : Summable fun x => ‖f x‖)
     (hg : Summable fun x => ‖g x‖) : Summable fun n => ‖∑ k in range (n + 1), f k * g (n - k)‖ :=
   by
   simp_rw [← sum_antidiagonal_eq_sum_range_succ fun k l => f k * g l]
   exact summable_norm_sum_mul_antidiagonal_of_summable_norm hf hg
 #align summable_norm_sum_mul_range_of_summable_norm summable_norm_sum_mul_range_of_summable_norm
+-/
 
+#print tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm /-
 /-- The Cauchy product formula for the product of two infinite sums indexed by `ℕ`,
     expressed by summing on `finset.range`.
     See also `tsum_mul_tsum_eq_tsum_sum_range` if `f` and `g` are
@@ -140,6 +153,7 @@ theorem tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm [CompleteSpace α] {f g
   simp_rw [← sum_antidiagonal_eq_sum_range_succ fun k l => f k * g l]
   exact tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm hf hg
 #align tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm
+-/
 
 end Nat
 

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

@@ -40,11 +40,11 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
     (hf' : 0 ≤ f) (hg' : 0 ≤ g) : Summable fun x : ι × ι' => f x.1 * g x.2 :=
   let ⟨s, hf⟩ := hf
   let ⟨t, hg⟩ := hg
-  suffices this (∀ u : Finset (ι × ι'), (∑ x in u, f x.1 * g x.2) ≤ s * t) from
+  suffices this (∀ u : Finset (ι × ι'), ∑ x in u, f x.1 * g x.2 ≤ s * t) from
     summable_of_sum_le (fun x => mul_nonneg (hf' _) (hg' _)) this
   fun u =>
   calc
-    (∑ x in u, f x.1 * g x.2) ≤ ∑ x in u.image Prod.fst ×ˢ u.image Prod.snd, f x.1 * g x.2 :=
+    ∑ x in u, f x.1 * g x.2 ≤ ∑ x in u.image Prod.fst ×ˢ u.image Prod.snd, f x.1 * g x.2 :=
       sum_mono_set_of_nonneg (fun x => mul_nonneg (hf' _) (hg' _)) subset_product
     _ = ∑ x in u.image Prod.fst, ∑ y in u.image Prod.snd, f x * g y := sum_product
     _ = ∑ x in u.image Prod.fst, f x * ∑ y in u.image Prod.snd, g y :=
@@ -74,7 +74,7 @@ theorem summable_mul_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι
     See also `tsum_mul_tsum` if `f` and `g` are *not* absolutely summable. -/
 theorem tsum_mul_tsum_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
-    ((∑' x, f x) * ∑' y, g y) = ∑' z : ι × ι', f z.1 * g z.2 :=
+    (∑' x, f x) * ∑' y, g y = ∑' z : ι × ι', f z.1 * g z.2 :=
   tsum_mul_tsum (summable_of_summable_norm hf) (summable_of_summable_norm hg)
     (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_of_summable_norm tsum_mul_tsum_of_summable_norm
@@ -117,7 +117,7 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → α}
     *not* absolutely summable. -/
 theorem tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm [CompleteSpace α] {f g : ℕ → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
-    ((∑' n, f n) * ∑' n, g n) = ∑' n, ∑ kl in antidiagonal n, f kl.1 * g kl.2 :=
+    (∑' n, f n) * ∑' n, g n = ∑' n, ∑ kl in antidiagonal n, f kl.1 * g kl.2 :=
   tsum_mul_tsum_eq_tsum_sum_antidiagonal (summable_of_summable_norm hf)
     (summable_of_summable_norm hg) (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm
@@ -135,7 +135,7 @@ theorem summable_norm_sum_mul_range_of_summable_norm {f g : ℕ → α} (hf : Su
     *not* absolutely summable. -/
 theorem tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm [CompleteSpace α] {f g : ℕ → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
-    ((∑' n, f n) * ∑' n, g n) = ∑' n, ∑ k in range (n + 1), f k * g (n - k) :=
+    (∑' n, f n) * ∑' n, g n = ∑' n, ∑ k in range (n + 1), f k * g (n - k) :=
   by
   simp_rw [← sum_antidiagonal_eq_sum_range_succ fun k l => f k * g l]
   exact tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm hf hg

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -40,7 +40,7 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
     (hf' : 0 ≤ f) (hg' : 0 ≤ g) : Summable fun x : ι × ι' => f x.1 * g x.2 :=
   let ⟨s, hf⟩ := hf
   let ⟨t, hg⟩ := hg
-  suffices this : ∀ u : Finset (ι × ι'), (∑ x in u, f x.1 * g x.2) ≤ s * t from
+  suffices this (∀ u : Finset (ι × ι'), (∑ x in u, f x.1 * g x.2) ≤ s * t) from
     summable_of_sum_le (fun x => mul_nonneg (hf' _) (hg' _)) this
   fun u =>
   calc
@@ -55,7 +55,6 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
     _ = (∑ x in u.image Prod.fst, f x) * t := sum_mul.symm
     _ ≤ s * t :=
       mul_le_mul_of_nonneg_right (sum_le_hasSum _ (fun _ _ => hf' _) hf) (hg.NonNeg fun _ => hg' _)
-    
 #align summable.mul_of_nonneg Summable.mul_of_nonneg
 
 theorem Summable.mul_norm {f : ι → α} {g : ι' → α} (hf : Summable fun x => ‖f x‖)
@@ -109,7 +108,6 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → α}
     ‖∑ kl in antidiagonal n, f kl.1 * g kl.2‖ ≤ ∑ kl in antidiagonal n, ‖f kl.1 * g kl.2‖ :=
       norm_sum_le _ _
     _ ≤ ∑ kl in antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖ := sum_le_sum fun i _ => norm_mul_le _ _
-    
 #align summable_norm_sum_mul_antidiagonal_of_summable_norm summable_norm_sum_mul_antidiagonal_of_summable_norm
 -/
 

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

@@ -28,7 +28,7 @@ We first establish results about arbitrary index types, `β` and `γ`, and then
 
 variable {α : Type _} {ι : Type _} {ι' : Type _} [NormedRing α]
 
-open BigOperators Classical
+open scoped BigOperators Classical
 
 open Finset
 

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

@@ -35,12 +35,6 @@ open Finset
 /-! ### Arbitrary index types -/
 
 
-/- warning: summable.mul_of_nonneg -> Summable.mul_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {ι' : Type.{u2}} {f : ι -> Real} {g : ι' -> Real}, (Summable.{0, u1} Real ι Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) f) -> (Summable.{0, u2} Real ι' Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) g) -> (LE.le.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) (OfNat.ofNat.{u1} (ι -> Real) 0 (OfNat.mk.{u1} (ι -> Real) 0 (Zero.zero.{u1} (ι -> Real) (Pi.instZero.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasZero))))) f) -> (LE.le.{u2} (ι' -> Real) (Pi.hasLe.{u2, 0} ι' (fun (ᾰ : ι') => Real) (fun (i : ι') => Real.hasLe)) (OfNat.ofNat.{u2} (ι' -> Real) 0 (OfNat.mk.{u2} (ι' -> Real) 0 (Zero.zero.{u2} (ι' -> Real) (Pi.instZero.{u2, 0} ι' (fun (ᾰ : ι') => Real) (fun (i : ι') => Real.hasZero))))) g) -> (Summable.{0, max u1 u2} Real (Prod.{u1, u2} ι ι') Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Prod.{u1, u2} ι ι') => HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (f (Prod.fst.{u1, u2} ι ι' x)) (g (Prod.snd.{u1, u2} ι ι' x))))
-but is expected to have type
-  forall {ι : Type.{u2}} {ι' : Type.{u1}} {f : ι -> Real} {g : ι' -> Real}, (Summable.{0, u2} Real ι Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) f) -> (Summable.{0, u1} Real ι' Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) g) -> (LE.le.{u2} (ι -> Real) (Pi.hasLe.{u2, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) (OfNat.ofNat.{u2} (ι -> Real) 0 (Zero.toOfNat0.{u2} (ι -> Real) (Pi.instZero.{u2, 0} ι (fun (a._@.Mathlib.Analysis.Normed.Field.InfiniteSum._hyg.27 : ι) => Real) (fun (i : ι) => Real.instZeroReal)))) f) -> (LE.le.{u1} (ι' -> Real) (Pi.hasLe.{u1, 0} ι' (fun (ᾰ : ι') => Real) (fun (i : ι') => Real.instLEReal)) (OfNat.ofNat.{u1} (ι' -> Real) 0 (Zero.toOfNat0.{u1} (ι' -> Real) (Pi.instZero.{u1, 0} ι' (fun (a._@.Mathlib.Analysis.Normed.Field.InfiniteSum._hyg.32 : ι') => Real) (fun (i : ι') => Real.instZeroReal)))) g) -> (Summable.{0, max u2 u1} Real (Prod.{u2, u1} ι ι') Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Prod.{u2, u1} ι ι') => HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (f (Prod.fst.{u2, u1} ι ι' x)) (g (Prod.snd.{u2, u1} ι ι' x))))
-Case conversion may be inaccurate. Consider using '#align summable.mul_of_nonneg Summable.mul_of_nonnegₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable f) (hg : Summable g)
     (hf' : 0 ≤ f) (hg' : 0 ≤ g) : Summable fun x : ι × ι' => f x.1 * g x.2 :=
@@ -64,12 +58,6 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
     
 #align summable.mul_of_nonneg Summable.mul_of_nonneg
 
-/- warning: summable.mul_norm -> Summable.mul_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {ι' : Type.{u3}} [_inst_1 : NormedRing.{u1} α] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, u3} Real ι' Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Summable.{0, max u2 u3} Real (Prod.{u2, u3} ι ι') Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Prod.{u2, u3} ι ι') => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f (Prod.fst.{u2, u3} ι ι' x)) (g (Prod.snd.{u2, u3} ι ι' x)))))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u3}} {ι' : Type.{u1}} [_inst_1 : NormedRing.{u2} α] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u3} Real ι Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u2} α (NormedRing.toNorm.{u2} α _inst_1) (f x))) -> (Summable.{0, u1} Real ι' Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u2} α (NormedRing.toNorm.{u2} α _inst_1) (g x))) -> (Summable.{0, max u3 u1} Real (Prod.{u3, u1} ι ι') Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Prod.{u3, u1} ι ι') => Norm.norm.{u2} α (NormedRing.toNorm.{u2} α _inst_1) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α (NormedRing.toRing.{u2} α _inst_1))))) (f (Prod.fst.{u3, u1} ι ι' x)) (g (Prod.snd.{u3, u1} ι ι' x)))))
-Case conversion may be inaccurate. Consider using '#align summable.mul_norm Summable.mul_normₓ'. -/
 theorem Summable.mul_norm {f : ι → α} {g : ι' → α} (hf : Summable fun x => ‖f x‖)
     (hg : Summable fun x => ‖g x‖) : Summable fun x : ι × ι' => ‖f x.1 * g x.2‖ :=
   summable_of_nonneg_of_le (fun x => norm_nonneg (f x.1 * g x.2))
@@ -77,24 +65,12 @@ theorem Summable.mul_norm {f : ι → α} {g : ι' → α} (hf : Summable fun x
     (hf.mul_of_nonneg hg (fun x => norm_nonneg <| f x) fun x => norm_nonneg <| g x : _)
 #align summable.mul_norm Summable.mul_norm
 
-/- warning: summable_mul_of_summable_norm -> summable_mul_of_summable_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {ι' : Type.{u3}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, u3} Real ι' Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Summable.{u1, max u2 u3} α (Prod.{u2, u3} ι ι') (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) (fun (x : Prod.{u2, u3} ι ι') => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f (Prod.fst.{u2, u3} ι ι' x)) (g (Prod.snd.{u2, u3} ι ι' x))))
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u2}} {ι' : Type.{u1}} [_inst_1 : NormedRing.{u3} α] [_inst_2 : CompleteSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u3} α (NormedRing.toNorm.{u3} α _inst_1) (f x))) -> (Summable.{0, u1} Real ι' Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u3} α (NormedRing.toNorm.{u3} α _inst_1) (g x))) -> (Summable.{u3, max u2 u1} α (Prod.{u2, u1} ι ι') (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))) (fun (x : Prod.{u2, u1} ι ι') => HMul.hMul.{u3, u3, u3} α α α (instHMul.{u3} α (NonUnitalNonAssocRing.toMul.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (f (Prod.fst.{u2, u1} ι ι' x)) (g (Prod.snd.{u2, u1} ι ι' x))))
-Case conversion may be inaccurate. Consider using '#align summable_mul_of_summable_norm summable_mul_of_summable_normₓ'. -/
 theorem summable_mul_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     Summable fun x : ι × ι' => f x.1 * g x.2 :=
   summable_of_summable_norm (hf.mul_norm hg)
 #align summable_mul_of_summable_norm summable_mul_of_summable_norm
 
-/- warning: tsum_mul_tsum_of_summable_norm -> tsum_mul_tsum_of_summable_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {ι' : Type.{u3}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, u3} Real ι' Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (tsum.{u1, u2} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) ι (fun (x : ι) => f x)) (tsum.{u1, u3} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) ι' (fun (y : ι') => g y))) (tsum.{u1, max u2 u3} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) (Prod.{u2, u3} ι ι') (fun (z : Prod.{u2, u3} ι ι') => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f (Prod.fst.{u2, u3} ι ι' z)) (g (Prod.snd.{u2, u3} ι ι' z)))))
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u2}} {ι' : Type.{u1}} [_inst_1 : NormedRing.{u3} α] [_inst_2 : CompleteSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u3} α (NormedRing.toNorm.{u3} α _inst_1) (f x))) -> (Summable.{0, u1} Real ι' Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u3} α (NormedRing.toNorm.{u3} α _inst_1) (g x))) -> (Eq.{succ u3} α (HMul.hMul.{u3, u3, u3} α α α (instHMul.{u3} α (NonUnitalNonAssocRing.toMul.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (tsum.{u3, u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))) ι (fun (x : ι) => f x)) (tsum.{u3, u1} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))) ι' (fun (y : ι') => g y))) (tsum.{u3, max u2 u1} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))) (Prod.{u2, u1} ι ι') (fun (z : Prod.{u2, u1} ι ι') => HMul.hMul.{u3, u3, u3} α α α (instHMul.{u3} α (NonUnitalNonAssocRing.toMul.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (f (Prod.fst.{u2, u1} ι ι' z)) (g (Prod.snd.{u2, u1} ι ι' z)))))
-Case conversion may be inaccurate. Consider using '#align tsum_mul_tsum_of_summable_norm tsum_mul_tsum_of_summable_normₓ'. -/
 /-- Product of two infinites sums indexed by arbitrary types.
     See also `tsum_mul_tsum` if `f` and `g` are *not* absolutely summable. -/
 theorem tsum_mul_tsum_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
@@ -137,12 +113,6 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → α}
 #align summable_norm_sum_mul_antidiagonal_of_summable_norm summable_norm_sum_mul_antidiagonal_of_summable_norm
 -/
 
-/- warning: tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm -> tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => f n)) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => g n))) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => Finset.sum.{u1, 0} α (Prod.{0, 0} Nat Nat) (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (Finset.Nat.antidiagonal n) (fun (kl : Prod.{0, 0} Nat Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f (Prod.fst.{0, 0} Nat Nat kl)) (g (Prod.snd.{0, 0} Nat Nat kl))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => f n)) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => g n))) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => Finset.sum.{u1, 0} α (Prod.{0, 0} Nat Nat) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (Finset.Nat.antidiagonal n) (fun (kl : Prod.{0, 0} Nat Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (f (Prod.fst.{0, 0} Nat Nat kl)) (g (Prod.snd.{0, 0} Nat Nat kl))))))
-Case conversion may be inaccurate. Consider using '#align tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_normₓ'. -/
 /-- The Cauchy product formula for the product of two infinite sums indexed by `ℕ`,
     expressed by summing on `finset.nat.antidiagonal`.
     See also `tsum_mul_tsum_eq_tsum_sum_antidiagonal` if `f` and `g` are
@@ -154,12 +124,6 @@ theorem tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm [CompleteSpace 
     (summable_of_summable_norm hg) (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm
 
-/- warning: summable_norm_sum_mul_range_of_summable_norm -> summable_norm_sum_mul_range_of_summable_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (n : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (Finset.sum.{u1, 0} α Nat (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (Finset.range (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 (k : Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f k) (g (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n k))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (g x))) -> (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (n : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (Finset.sum.{u1, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (k : Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (f k) (g (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n k))))))
-Case conversion may be inaccurate. Consider using '#align summable_norm_sum_mul_range_of_summable_norm summable_norm_sum_mul_range_of_summable_normₓ'. -/
 theorem summable_norm_sum_mul_range_of_summable_norm {f g : ℕ → α} (hf : Summable fun x => ‖f x‖)
     (hg : Summable fun x => ‖g x‖) : Summable fun n => ‖∑ k in range (n + 1), f k * g (n - k)‖ :=
   by
@@ -167,12 +131,6 @@ theorem summable_norm_sum_mul_range_of_summable_norm {f g : ℕ → α} (hf : Su
   exact summable_norm_sum_mul_antidiagonal_of_summable_norm hf hg
 #align summable_norm_sum_mul_range_of_summable_norm summable_norm_sum_mul_range_of_summable_norm
 
-/- warning: tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm -> tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => f n)) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => g n))) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => Finset.sum.{u1, 0} α Nat (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (Finset.range (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 (k : Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f k) (g (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n k))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => f n)) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => g n))) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => Finset.sum.{u1, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (k : Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (f k) (g (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n k))))))
-Case conversion may be inaccurate. Consider using '#align tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm tsum_mul_tsum_eq_tsum_sum_range_of_summable_normₓ'. -/
 /-- The Cauchy product formula for the product of two infinite sums indexed by `ℕ`,
     expressed by summing on `finset.range`.
     See also `tsum_mul_tsum_eq_tsum_sum_range` if `f` and `g` are

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anatole Dedecker
 
 ! This file was ported from Lean 3 source module analysis.normed.field.infinite_sum
-! leanprover-community/mathlib commit 008205aa645b3f194c1da47025c5f110c8406eab
+! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Analysis.Normed.Group.InfiniteSum
 
 /-! # Multiplying two infinite sums in a normed ring
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file, we prove various results about `(∑' x : ι, f x) * (∑' y : ι', g y)` in a normed
 ring. There are similar results proven in `topology/algebra/infinite_sum` (e.g `tsum_mul_tsum`),
 but in a normed ring we get summability results which aren't true in general.

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

@@ -32,6 +32,12 @@ open Finset
 /-! ### Arbitrary index types -/
 
 
+/- warning: summable.mul_of_nonneg -> Summable.mul_of_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {ι' : Type.{u2}} {f : ι -> Real} {g : ι' -> Real}, (Summable.{0, u1} Real ι Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) f) -> (Summable.{0, u2} Real ι' Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) g) -> (LE.le.{u1} (ι -> Real) (Pi.hasLe.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasLe)) (OfNat.ofNat.{u1} (ι -> Real) 0 (OfNat.mk.{u1} (ι -> Real) 0 (Zero.zero.{u1} (ι -> Real) (Pi.instZero.{u1, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.hasZero))))) f) -> (LE.le.{u2} (ι' -> Real) (Pi.hasLe.{u2, 0} ι' (fun (ᾰ : ι') => Real) (fun (i : ι') => Real.hasLe)) (OfNat.ofNat.{u2} (ι' -> Real) 0 (OfNat.mk.{u2} (ι' -> Real) 0 (Zero.zero.{u2} (ι' -> Real) (Pi.instZero.{u2, 0} ι' (fun (ᾰ : ι') => Real) (fun (i : ι') => Real.hasZero))))) g) -> (Summable.{0, max u1 u2} Real (Prod.{u1, u2} ι ι') Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Prod.{u1, u2} ι ι') => HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (f (Prod.fst.{u1, u2} ι ι' x)) (g (Prod.snd.{u1, u2} ι ι' x))))
+but is expected to have type
+  forall {ι : Type.{u2}} {ι' : Type.{u1}} {f : ι -> Real} {g : ι' -> Real}, (Summable.{0, u2} Real ι Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) f) -> (Summable.{0, u1} Real ι' Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) g) -> (LE.le.{u2} (ι -> Real) (Pi.hasLe.{u2, 0} ι (fun (ᾰ : ι) => Real) (fun (i : ι) => Real.instLEReal)) (OfNat.ofNat.{u2} (ι -> Real) 0 (Zero.toOfNat0.{u2} (ι -> Real) (Pi.instZero.{u2, 0} ι (fun (a._@.Mathlib.Analysis.Normed.Field.InfiniteSum._hyg.27 : ι) => Real) (fun (i : ι) => Real.instZeroReal)))) f) -> (LE.le.{u1} (ι' -> Real) (Pi.hasLe.{u1, 0} ι' (fun (ᾰ : ι') => Real) (fun (i : ι') => Real.instLEReal)) (OfNat.ofNat.{u1} (ι' -> Real) 0 (Zero.toOfNat0.{u1} (ι' -> Real) (Pi.instZero.{u1, 0} ι' (fun (a._@.Mathlib.Analysis.Normed.Field.InfiniteSum._hyg.32 : ι') => Real) (fun (i : ι') => Real.instZeroReal)))) g) -> (Summable.{0, max u2 u1} Real (Prod.{u2, u1} ι ι') Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Prod.{u2, u1} ι ι') => HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (f (Prod.fst.{u2, u1} ι ι' x)) (g (Prod.snd.{u2, u1} ι ι' x))))
+Case conversion may be inaccurate. Consider using '#align summable.mul_of_nonneg Summable.mul_of_nonnegₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable f) (hg : Summable g)
     (hf' : 0 ≤ f) (hg' : 0 ≤ g) : Summable fun x : ι × ι' => f x.1 * g x.2 :=
@@ -55,6 +61,12 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
     
 #align summable.mul_of_nonneg Summable.mul_of_nonneg
 
+/- warning: summable.mul_norm -> Summable.mul_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Type.{u2}} {ι' : Type.{u3}} [_inst_1 : NormedRing.{u1} α] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, u3} Real ι' Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Summable.{0, max u2 u3} Real (Prod.{u2, u3} ι ι') Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Prod.{u2, u3} ι ι') => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f (Prod.fst.{u2, u3} ι ι' x)) (g (Prod.snd.{u2, u3} ι ι' x)))))
+but is expected to have type
+  forall {α : Type.{u2}} {ι : Type.{u3}} {ι' : Type.{u1}} [_inst_1 : NormedRing.{u2} α] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u3} Real ι Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u2} α (NormedRing.toNorm.{u2} α _inst_1) (f x))) -> (Summable.{0, u1} Real ι' Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u2} α (NormedRing.toNorm.{u2} α _inst_1) (g x))) -> (Summable.{0, max u3 u1} Real (Prod.{u3, u1} ι ι') Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Prod.{u3, u1} ι ι') => Norm.norm.{u2} α (NormedRing.toNorm.{u2} α _inst_1) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α (NormedRing.toRing.{u2} α _inst_1))))) (f (Prod.fst.{u3, u1} ι ι' x)) (g (Prod.snd.{u3, u1} ι ι' x)))))
+Case conversion may be inaccurate. Consider using '#align summable.mul_norm Summable.mul_normₓ'. -/
 theorem Summable.mul_norm {f : ι → α} {g : ι' → α} (hf : Summable fun x => ‖f x‖)
     (hg : Summable fun x => ‖g x‖) : Summable fun x : ι × ι' => ‖f x.1 * g x.2‖ :=
   summable_of_nonneg_of_le (fun x => norm_nonneg (f x.1 * g x.2))
@@ -62,12 +74,24 @@ theorem Summable.mul_norm {f : ι → α} {g : ι' → α} (hf : Summable fun x
     (hf.mul_of_nonneg hg (fun x => norm_nonneg <| f x) fun x => norm_nonneg <| g x : _)
 #align summable.mul_norm Summable.mul_norm
 
+/- warning: summable_mul_of_summable_norm -> summable_mul_of_summable_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Type.{u2}} {ι' : Type.{u3}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, u3} Real ι' Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Summable.{u1, max u2 u3} α (Prod.{u2, u3} ι ι') (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) (fun (x : Prod.{u2, u3} ι ι') => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f (Prod.fst.{u2, u3} ι ι' x)) (g (Prod.snd.{u2, u3} ι ι' x))))
+but is expected to have type
+  forall {α : Type.{u3}} {ι : Type.{u2}} {ι' : Type.{u1}} [_inst_1 : NormedRing.{u3} α] [_inst_2 : CompleteSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u3} α (NormedRing.toNorm.{u3} α _inst_1) (f x))) -> (Summable.{0, u1} Real ι' Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u3} α (NormedRing.toNorm.{u3} α _inst_1) (g x))) -> (Summable.{u3, max u2 u1} α (Prod.{u2, u1} ι ι') (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))) (fun (x : Prod.{u2, u1} ι ι') => HMul.hMul.{u3, u3, u3} α α α (instHMul.{u3} α (NonUnitalNonAssocRing.toMul.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (f (Prod.fst.{u2, u1} ι ι' x)) (g (Prod.snd.{u2, u1} ι ι' x))))
+Case conversion may be inaccurate. Consider using '#align summable_mul_of_summable_norm summable_mul_of_summable_normₓ'. -/
 theorem summable_mul_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     Summable fun x : ι × ι' => f x.1 * g x.2 :=
   summable_of_summable_norm (hf.mul_norm hg)
 #align summable_mul_of_summable_norm summable_mul_of_summable_norm
 
+/- warning: tsum_mul_tsum_of_summable_norm -> tsum_mul_tsum_of_summable_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Type.{u2}} {ι' : Type.{u3}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, u3} Real ι' Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (tsum.{u1, u2} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) ι (fun (x : ι) => f x)) (tsum.{u1, u3} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) ι' (fun (y : ι') => g y))) (tsum.{u1, max u2 u3} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) (Prod.{u2, u3} ι ι') (fun (z : Prod.{u2, u3} ι ι') => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f (Prod.fst.{u2, u3} ι ι' z)) (g (Prod.snd.{u2, u3} ι ι' z)))))
+but is expected to have type
+  forall {α : Type.{u3}} {ι : Type.{u2}} {ι' : Type.{u1}} [_inst_1 : NormedRing.{u3} α] [_inst_2 : CompleteSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))] {f : ι -> α} {g : ι' -> α}, (Summable.{0, u2} Real ι Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι) => Norm.norm.{u3} α (NormedRing.toNorm.{u3} α _inst_1) (f x))) -> (Summable.{0, u1} Real ι' Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : ι') => Norm.norm.{u3} α (NormedRing.toNorm.{u3} α _inst_1) (g x))) -> (Eq.{succ u3} α (HMul.hMul.{u3, u3, u3} α α α (instHMul.{u3} α (NonUnitalNonAssocRing.toMul.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (tsum.{u3, u2} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))) ι (fun (x : ι) => f x)) (tsum.{u3, u1} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))) ι' (fun (y : ι') => g y))) (tsum.{u3, max u2 u1} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u3} α (PseudoMetricSpace.toUniformSpace.{u3} α (SeminormedRing.toPseudoMetricSpace.{u3} α (NormedRing.toSeminormedRing.{u3} α _inst_1)))) (Prod.{u2, u1} ι ι') (fun (z : Prod.{u2, u1} ι ι') => HMul.hMul.{u3, u3, u3} α α α (instHMul.{u3} α (NonUnitalNonAssocRing.toMul.{u3} α (NonAssocRing.toNonUnitalNonAssocRing.{u3} α (Ring.toNonAssocRing.{u3} α (NormedRing.toRing.{u3} α _inst_1))))) (f (Prod.fst.{u2, u1} ι ι' z)) (g (Prod.snd.{u2, u1} ι ι' z)))))
+Case conversion may be inaccurate. Consider using '#align tsum_mul_tsum_of_summable_norm tsum_mul_tsum_of_summable_normₓ'. -/
 /-- Product of two infinites sums indexed by arbitrary types.
     See also `tsum_mul_tsum` if `f` and `g` are *not* absolutely summable. -/
 theorem tsum_mul_tsum_of_summable_norm [CompleteSpace α] {f : ι → α} {g : ι' → α}
@@ -92,6 +116,7 @@ section Nat
 
 open Finset.Nat
 
+#print summable_norm_sum_mul_antidiagonal_of_summable_norm /-
 theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → α}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     Summable fun n => ‖∑ kl in antidiagonal n, f kl.1 * g kl.2‖ :=
@@ -107,7 +132,14 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → α}
     _ ≤ ∑ kl in antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖ := sum_le_sum fun i _ => norm_mul_le _ _
     
 #align summable_norm_sum_mul_antidiagonal_of_summable_norm summable_norm_sum_mul_antidiagonal_of_summable_norm
+-/
 
+/- warning: tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm -> tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => f n)) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => g n))) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => Finset.sum.{u1, 0} α (Prod.{0, 0} Nat Nat) (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (Finset.Nat.antidiagonal n) (fun (kl : Prod.{0, 0} Nat Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f (Prod.fst.{0, 0} Nat Nat kl)) (g (Prod.snd.{0, 0} Nat Nat kl))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => f n)) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => g n))) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => Finset.sum.{u1, 0} α (Prod.{0, 0} Nat Nat) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (Finset.Nat.antidiagonal n) (fun (kl : Prod.{0, 0} Nat Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (f (Prod.fst.{0, 0} Nat Nat kl)) (g (Prod.snd.{0, 0} Nat Nat kl))))))
+Case conversion may be inaccurate. Consider using '#align tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_normₓ'. -/
 /-- The Cauchy product formula for the product of two infinite sums indexed by `ℕ`,
     expressed by summing on `finset.nat.antidiagonal`.
     See also `tsum_mul_tsum_eq_tsum_sum_antidiagonal` if `f` and `g` are
@@ -119,6 +151,12 @@ theorem tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm [CompleteSpace 
     (summable_of_summable_norm hg) (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm
 
+/- warning: summable_norm_sum_mul_range_of_summable_norm -> summable_norm_sum_mul_range_of_summable_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (n : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (Finset.sum.{u1, 0} α Nat (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (Finset.range (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 (k : Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f k) (g (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n k))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (g x))) -> (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (n : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (Finset.sum.{u1, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (k : Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (f k) (g (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n k))))))
+Case conversion may be inaccurate. Consider using '#align summable_norm_sum_mul_range_of_summable_norm summable_norm_sum_mul_range_of_summable_normₓ'. -/
 theorem summable_norm_sum_mul_range_of_summable_norm {f g : ℕ → α} (hf : Summable fun x => ‖f x‖)
     (hg : Summable fun x => ‖g x‖) : Summable fun n => ‖∑ k in range (n + 1), f k * g (n - k)‖ :=
   by
@@ -126,6 +164,12 @@ theorem summable_norm_sum_mul_range_of_summable_norm {f g : ℕ → α} (hf : Su
   exact summable_norm_sum_mul_antidiagonal_of_summable_norm hf hg
 #align summable_norm_sum_mul_range_of_summable_norm summable_norm_sum_mul_range_of_summable_norm
 
+/- warning: tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm -> tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.addCommMonoid (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toHasNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => f n)) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => g n))) (tsum.{u1, 0} α (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => Finset.sum.{u1, 0} α Nat (AddCommGroup.toAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NonUnitalNormedRing.toNormedAddCommGroup.{u1} α (NormedRing.toNonUnitalNormedRing.{u1} α _inst_1)))) (Finset.range (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 (k : Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (NormedRing.toRing.{u1} α _inst_1)))) (f k) (g (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n k))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedRing.{u1} α] [_inst_2 : CompleteSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))] {f : Nat -> α} {g : Nat -> α}, (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (f x))) -> (Summable.{0, 0} Real Nat Real.instAddCommMonoidReal (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : Nat) => Norm.norm.{u1} α (NormedRing.toNorm.{u1} α _inst_1) (g x))) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => f n)) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => g n))) (tsum.{u1, 0} α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedRing.toPseudoMetricSpace.{u1} α (NormedRing.toSeminormedRing.{u1} α _inst_1)))) Nat (fun (n : Nat) => Finset.sum.{u1, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (k : Nat) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (NormedRing.toRing.{u1} α _inst_1))))) (f k) (g (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n k))))))
+Case conversion may be inaccurate. Consider using '#align tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm tsum_mul_tsum_eq_tsum_sum_range_of_summable_normₓ'. -/
 /-- The Cauchy product formula for the product of two infinite sums indexed by `ℕ`,
     expressed by summing on `finset.range`.
     See also `tsum_mul_tsum_eq_tsum_sum_range` if `f` and `g` are

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -45,10 +45,10 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
       sum_mono_set_of_nonneg (fun x => mul_nonneg (hf' _) (hg' _)) subset_product
     _ = ∑ x in u.image Prod.fst, ∑ y in u.image Prod.snd, f x * g y := sum_product
     _ = ∑ x in u.image Prod.fst, f x * ∑ y in u.image Prod.snd, g y :=
-      sum_congr rfl fun x _ => mul_sum.symm
+      (sum_congr rfl fun x _ => mul_sum.symm)
     _ ≤ ∑ x in u.image Prod.fst, f x * t :=
-      sum_le_sum fun x _ =>
-        mul_le_mul_of_nonneg_left (sum_le_hasSum _ (fun _ _ => hg' _) hg) (hf' _)
+      (sum_le_sum fun x _ =>
+        mul_le_mul_of_nonneg_left (sum_le_hasSum _ (fun _ _ => hg' _) hg) (hf' _))
     _ = (∑ x in u.image Prod.fst, f x) * t := sum_mul.symm
     _ ≤ s * t :=
       mul_le_mul_of_nonneg_right (sum_le_hasSum _ (fun _ _ => hf' _) hf) (hg.NonNeg fun _ => hg' _)

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

We move some lemmas out of Topology/Instances/ENNReal into Topology/Algebra/InfiniteSum/Real. Also use this to address a porting TODO.

This was originally part of #12446

Co-authored-by: Chris Birkbeck <c.birkbeck@uea.ac.uk>

@@ -5,7 +5,7 @@ Authors: Anatole Dedecker
 -/
 import Mathlib.Analysis.Normed.Field.Basic
 import Mathlib.Analysis.Normed.Group.InfiniteSum
-import Mathlib.Topology.Instances.ENNReal
+import Mathlib.Topology.Algebra.InfiniteSum.Real
 
 #align_import analysis.normed.field.infinite_sum from "leanprover-community/mathlib"@"008205aa645b3f194c1da47025c5f110c8406eab"
 
@@ -67,7 +67,6 @@ In order to avoid `Nat` subtraction, we also provide
 where the `n`-th term is a sum over all pairs `(k, l)` such that `k+l=n`, which corresponds to the
 `Finset` `Finset.antidiagonal n`. -/
 
-
 section Nat
 
 open Finset.Nat

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -23,7 +23,8 @@ We first establish results about arbitrary index types, `ι` and `ι'`, and then
 
 variable {R : Type*} {ι : Type*} {ι' : Type*} [NormedRing R]
 
-open BigOperators Classical
+open scoped Classical
+open BigOperators
 
 open Finset
 

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

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

@@ -5,6 +5,7 @@ Authors: Anatole Dedecker
 -/
 import Mathlib.Analysis.Normed.Field.Basic
 import Mathlib.Analysis.Normed.Group.InfiniteSum
+import Mathlib.Topology.Instances.ENNReal
 
 #align_import analysis.normed.field.infinite_sum from "leanprover-community/mathlib"@"008205aa645b3f194c1da47025c5f110c8406eab"
 

Subset of #9319

@@ -30,7 +30,7 @@ open Finset
 
 theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable f) (hg : Summable g)
     (hf' : 0 ≤ f) (hg' : 0 ≤ g) : Summable fun x : ι × ι' => f x.1 * g x.2 :=
-  (summable_prod_of_nonneg <| fun _ ↦ mul_nonneg (hf' _) (hg' _)).2 ⟨fun x ↦ hg.mul_left (f x),
+  (summable_prod_of_nonneg fun _ ↦ mul_nonneg (hf' _) (hg' _)).2 ⟨fun x ↦ hg.mul_left (f x),
     by simpa only [hg.tsum_mul_left _] using hf.mul_right (∑' x, g x)⟩
 #align summable.mul_of_nonneg Summable.mul_of_nonneg
 

Rename

• summable_of_norm_bounded -> Summable.of_norm_bounded;
• summable_of_norm_bounded_eventually -> Summable.of_norm_bounded_eventually;
• summable_of_nnnorm_bounded -> Summable.of_nnnorm_bounded;
• summable_of_summable_norm -> Summable.of_norm;
• summable_of_summable_nnnorm -> Summable.of_nnnorm;

New lemmas

• Summable.of_norm_bounded_eventually_nat
• Summable.norm

Misc changes

• Golf a few proofs.

@@ -36,7 +36,7 @@ theorem Summable.mul_of_nonneg {f : ι → ℝ} {g : ι' → ℝ} (hf : Summable
 
 theorem Summable.mul_norm {f : ι → R} {g : ι' → R} (hf : Summable fun x => ‖f x‖)
     (hg : Summable fun x => ‖g x‖) : Summable fun x : ι × ι' => ‖f x.1 * g x.2‖ :=
-  summable_of_nonneg_of_le (fun x => norm_nonneg (f x.1 * g x.2))
+  .of_nonneg_of_le (fun _ ↦ norm_nonneg _)
     (fun x => norm_mul_le (f x.1) (g x.2))
     (hf.mul_of_nonneg hg (fun x => norm_nonneg <| f x) fun x => norm_nonneg <| g x : _)
 #align summable.mul_norm Summable.mul_norm
@@ -44,7 +44,7 @@ theorem Summable.mul_norm {f : ι → R} {g : ι' → R} (hf : Summable fun x =>
 theorem summable_mul_of_summable_norm [CompleteSpace R] {f : ι → R} {g : ι' → R}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     Summable fun x : ι × ι' => f x.1 * g x.2 :=
-  summable_of_summable_norm (hf.mul_norm hg)
+  (hf.mul_norm hg).of_norm
 #align summable_mul_of_summable_norm summable_mul_of_summable_norm
 
 /-- Product of two infinites sums indexed by arbitrary types.
@@ -52,8 +52,7 @@ theorem summable_mul_of_summable_norm [CompleteSpace R] {f : ι → R} {g : ι'
 theorem tsum_mul_tsum_of_summable_norm [CompleteSpace R] {f : ι → R} {g : ι' → R}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     ((∑' x, f x) * ∑' y, g y) = ∑' z : ι × ι', f z.1 * g z.2 :=
-  tsum_mul_tsum (summable_of_summable_norm hf) (summable_of_summable_norm hg)
-    (summable_mul_of_summable_norm hf hg)
+  tsum_mul_tsum hf.of_norm hg.of_norm (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_of_summable_norm tsum_mul_tsum_of_summable_norm
 
 /-! ### `ℕ`-indexed families (Cauchy product)
@@ -77,8 +76,7 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → R}
   have :=
     summable_sum_mul_antidiagonal_of_summable_mul
       (Summable.mul_of_nonneg hf hg (fun _ => norm_nonneg _) fun _ => norm_nonneg _)
-  refine' summable_of_nonneg_of_le (fun _ => norm_nonneg _) _ this
-  intro n
+  refine this.of_nonneg_of_le (fun _ => norm_nonneg _) (fun n ↦ ?_)
   calc
     ‖∑ kl in antidiagonal n, f kl.1 * g kl.2‖ ≤ ∑ kl in antidiagonal n, ‖f kl.1 * g kl.2‖ :=
       norm_sum_le _ _
@@ -92,8 +90,7 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → R}
 theorem tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm [CompleteSpace R] {f g : ℕ → R}
     (hf : Summable fun x => ‖f x‖) (hg : Summable fun x => ‖g x‖) :
     ((∑' n, f n) * ∑' n, g n) = ∑' n, ∑ kl in antidiagonal n, f kl.1 * g kl.2 :=
-  tsum_mul_tsum_eq_tsum_sum_antidiagonal (summable_of_summable_norm hf)
-    (summable_of_summable_norm hg) (summable_mul_of_summable_norm hf hg)
+  tsum_mul_tsum_eq_tsum_sum_antidiagonal hf.of_norm hg.of_norm (summable_mul_of_summable_norm hf hg)
 #align tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm
 
 theorem summable_norm_sum_mul_range_of_summable_norm {f g : ℕ → R} (hf : Summable fun x => ‖f x‖)

We define a type class Finset.HasAntidiagonal A which contains a function antidiagonal : A → Finset (A × A) such that antidiagonal n is the Finset of all pairs adding to n, as witnessed by mem_antidiagonal.

When A is a canonically ordered add monoid with locally finite order this typeclass can be instantiated with Finset.antidiagonalOfLocallyFinite. This applies in particular when A is ℕ, more generally or σ →₀ ℕ, or even ι →₀ A under the additional assumption OrderedSub A that make it a canonically ordered add monoid. (In fact, we would just need an AddMonoid with a compatible order, finite Iic, such that if a + b = n, then a, b ≤ n, and any finiteness condition would be OK.)

For computational reasons it is better to manually provide instances for ℕ and σ →₀ ℕ, to avoid quadratic runtime performance. These instances are provided as Finset.Nat.instHasAntidiagonal and Finsupp.instHasAntidiagonal. This is why Finset.antidiagonalOfLocallyFinite is an abbrev and not an instance.

This definition does not exactly match with that of Multiset.antidiagonal defined in Mathlib.Data.Multiset.Antidiagonal, because of the multiplicities. Indeed, by counting multiplicities, Multiset α is equivalent to α →₀ ℕ, but Finset.antidiagonal and Multiset.antidiagonal will return different objects. For example, for s : Multiset ℕ := {0,0,0}, Multiset.antidiagonal s has 8 elements but Finset.antidiagonal s has only 4.

def s : Multiset ℕ := {0, 0, 0}
#eval (Finset.antidiagonal s).card -- 4
#eval Multiset.card (Multiset.antidiagonal s) -- 8

TODO

• Define HasMulAntidiagonal (for monoids). For PNat, we will recover the set of divisors of a strictly positive integer.

This closes #7917

Co-authored by: María Inés de Frutos-Fernández <mariaines.dff@gmail.com> and Eric Wieser <efw27@cam.ac.uk>

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -64,7 +64,7 @@ We prove two versions of the Cauchy product formula. The first one is
 In order to avoid `Nat` subtraction, we also provide
 `tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm`,
 where the `n`-th term is a sum over all pairs `(k, l)` such that `k+l=n`, which corresponds to the
-`Finset` `Finset.Nat.antidiagonal n`. -/
+`Finset` `Finset.antidiagonal n`. -/
 
 
 section Nat
@@ -86,7 +86,7 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → R}
 #align summable_norm_sum_mul_antidiagonal_of_summable_norm summable_norm_sum_mul_antidiagonal_of_summable_norm
 
 /-- The Cauchy product formula for the product of two infinite sums indexed by `ℕ`,
-    expressed by summing on `Finset.Nat.antidiagonal`.
+    expressed by summing on `Finset.antidiagonal`.
     See also `tsum_mul_tsum_eq_tsum_sum_antidiagonal` if `f` and `g` are
     *not* absolutely summable. -/
 theorem tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm [CompleteSpace R] {f g : ℕ → R}

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

This has nice performance benefits.

@@ -20,7 +20,7 @@ We first establish results about arbitrary index types, `ι` and `ι'`, and then
 -/
 
 
-variable {R : Type _} {ι : Type _} {ι' : Type _} [NormedRing R]
+variable {R : Type*} {ι : Type*} {ι' : Type*} [NormedRing R]
 
 open BigOperators Classical
 

• 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) 2021 Anatole Dedecker. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anatole Dedecker
-
-! This file was ported from Lean 3 source module analysis.normed.field.infinite_sum
-! leanprover-community/mathlib commit 008205aa645b3f194c1da47025c5f110c8406eab
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Normed.Field.Basic
 import Mathlib.Analysis.Normed.Group.InfiniteSum
 
+#align_import analysis.normed.field.infinite_sum from "leanprover-community/mathlib"@"008205aa645b3f194c1da47025c5f110c8406eab"
+
 /-! # Multiplying two infinite sums in a normed ring
 
 In this file, we prove various results about `(∑' x : ι, f x) * (∑' y : ι', g y)` in a normed

100 sample uses of the new tactic gcongr, added in #3965.

@@ -85,8 +85,7 @@ theorem summable_norm_sum_mul_antidiagonal_of_summable_norm {f g : ℕ → R}
   calc
     ‖∑ kl in antidiagonal n, f kl.1 * g kl.2‖ ≤ ∑ kl in antidiagonal n, ‖f kl.1 * g kl.2‖ :=
       norm_sum_le _ _
-    _ ≤ ∑ kl in antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖ := sum_le_sum fun i _ => norm_mul_le _ _
-    
+    _ ≤ ∑ kl in antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖ := by gcongr; apply norm_mul_le
 #align summable_norm_sum_mul_antidiagonal_of_summable_norm summable_norm_sum_mul_antidiagonal_of_summable_norm
 
 /-- The Cauchy product formula for the product of two infinite sums indexed by `ℕ`,
@@ -118,4 +117,3 @@ theorem tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm [CompleteSpace R] {f g
 #align tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm
 
 end Nat
-