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

@@ -3,11 +3,11 @@ Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 -/
-import Analysis.Calculus.BumpFunctionInner
+import Analysis.Calculus.BumpFunction.Basic
 import Analysis.Calculus.ParametricIntegral
 import MeasureTheory.Constructions.Prod.Integral
 import MeasureTheory.Function.LocallyIntegrable
-import MeasureTheory.Group.Integration
+import MeasureTheory.Group.Integral
 import MeasureTheory.Group.Prod
 import MeasureTheory.Integral.IntervalIntegral
 
@@ -1248,9 +1248,9 @@ end NontriviallyNormedField
 
 open scoped convolution
 
-section IsROrC
+section RCLike
 
-variable [IsROrC 𝕜]
+variable [RCLike 𝕜]
 
 variable [NormedSpace 𝕜 E]
 
@@ -1420,7 +1420,7 @@ theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport
     simp only [this, convolution_zero, Pi.zero_apply]
     exact hasFDerivAt_const (0 : F) x₀
   skip
-  have : ProperSpace G := FiniteDimensional.proper_isROrC 𝕜 G
+  have : ProperSpace G := FiniteDimensional.proper_rclike 𝕜 G
   set L' := L.precompR G
   have h1 : ∀ᶠ x in 𝓝 x₀, ae_strongly_measurable (fun t => L (f t) (g (x - t))) μ :=
     eventually_of_forall
@@ -1459,14 +1459,14 @@ theorem HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
 #align has_compact_support.has_fderiv_at_convolution_left HasCompactSupport.hasFDerivAt_convolution_left
 -/
 
-end IsROrC
+end RCLike
 
 section Real
 
 /-! The one-variable case -/
 
 
-variable [IsROrC 𝕜]
+variable [RCLike 𝕜]
 
 variable [NormedSpace 𝕜 E]
 
@@ -1511,7 +1511,7 @@ end Real
 
 section WithParam
 
-variable [IsROrC 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 𝕜 E''] [NormedSpace ℝ F]
+variable [RCLike 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 𝕜 E''] [NormedSpace ℝ F]
   [NormedSpace 𝕜 F] [CompleteSpace F] [MeasurableSpace G] [NormedAddCommGroup G] [BorelSpace G]
   [NormedSpace 𝕜 G] [NormedAddCommGroup P] [NormedSpace 𝕜 P] {μ : Measure G}
   (L : E →L[𝕜] E' →L[𝕜] F)

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

@@ -660,7 +660,7 @@ theorem support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g
   intro x h2x
   by_contra hx
   apply h2x
-  simp_rw [Set.mem_add, not_exists, not_and_or, nmem_support] at hx 
+  simp_rw [Set.mem_add, not_exists, not_and_or, nmem_support] at hx
   rw [convolution_def]
   convert integral_zero G F
   ext t
@@ -764,7 +764,7 @@ theorem continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set
       have H' : (p, x) ∈ (s ×ˢ univ : Set (P × G)) := by
         simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff] using hps
       have : g p x ∈ closed_ball (0 : E') C := hC (mem_image_of_mem _ ⟨H, H'⟩)
-      rwa [mem_closedBall_zero_iff] at this 
+      rwa [mem_closedBall_zero_iff] at this
     · have : g p x = 0 := hgs _ _ hps hx
       rw [this]
       simpa only [norm_zero] using Cpos.le
@@ -792,7 +792,7 @@ theorem continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set
       exact mem_nhdsWithin_iff_exists_mem_nhds_inter.2 ⟨w, w_open.mem_nhds q₀w, subset.rfl⟩
     filter_upwards [this]
     rintro ⟨p, x⟩ hpx
-    simp only [prod_mk_mem_set_prod_eq] at hpx 
+    simp only [prod_mk_mem_set_prod_eq] at hpx
     apply eventually_of_forall fun a => _
     apply convolution_integrand_bound_right_of_le_of_subset _ _ hpx.2 _
     · intro x
@@ -1034,11 +1034,11 @@ theorem convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 :
     by
     intro t; by_cases ht : t ∈ support f
     · have h2t := hf ht
-      rw [mem_ball_zero_iff] at h2t 
+      rw [mem_ball_zero_iff] at h2t
       specialize hg (x₀ - t)
-      rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg 
+      rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg
       rw [hg h2t]
-    · rw [nmem_support] at ht 
+    · rw [nmem_support] at ht
       simp_rw [ht, L.map_zero₂]
   simp_rw [convolution_def, h2]
 #align convolution_eq_right' convolution_eq_right'
@@ -1074,12 +1074,12 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
     by
     intro t; by_cases ht : t ∈ support f
     · have h2t := hf ht
-      rw [mem_ball_zero_iff] at h2t 
+      rw [mem_ball_zero_iff] at h2t
       specialize hg (x₀ - t)
-      rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg 
+      rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg
       refine' ((L (f t)).dist_le_opNorm _ _).trans _
       exact mul_le_mul_of_nonneg_left (hg h2t) (norm_nonneg _)
-    · rw [nmem_support] at ht 
+    · rw [nmem_support] at ht
       simp_rw [ht, L.map_zero₂, L.map_zero, norm_zero, MulZeroClass.zero_mul, dist_self]
   simp_rw [convolution_def]
   simp_rw [dist_eq_norm] at h2 ⊢
@@ -1139,13 +1139,13 @@ theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x
     (hk : Tendsto k l (𝓝 x₀)) :
     Tendsto (fun i : ι => (φ i ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀) :=
   by
-  simp_rw [tendsto_small_sets_iff] at hφ 
+  simp_rw [tendsto_small_sets_iff] at hφ
   rw [Metric.tendsto_nhds] at hcg ⊢
-  simp_rw [Metric.eventually_prod_nhds_iff] at hcg 
+  simp_rw [Metric.eventually_prod_nhds_iff] at hcg
   intro ε hε
   have h2ε : 0 < ε / 3 := div_pos hε (by norm_num)
   obtain ⟨p, hp, δ, hδ, hgδ⟩ := hcg _ h2ε
-  dsimp only [uncurry] at hgδ 
+  dsimp only [uncurry] at hgδ
   have h2k := hk.eventually (ball_mem_nhds x₀ <| half_pos hδ)
   have h2φ := hφ (ball (0 : G) _) <| ball_mem_nhds _ (half_pos hδ)
   filter_upwards [hp, h2k, h2φ, hnφ, hiφ, hmg] with i hpi hki hφi hnφi hiφi hmgi
@@ -1365,7 +1365,7 @@ theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z =
     (measure_preserving_sub_prod μ ν).map_eq
   suffices integrable (uncurry fun x y => L₃ (f y) (L₄ (g x) (k (x₀ - y - x)))) (μ.prod ν)
     by
-    rw [← h3] at this 
+    rw [← h3] at this
     convert this.comp_measurable (measurable_sub.prod_mk measurable_snd)
     ext ⟨x, y⟩
     simp_rw [uncurry, Function.comp_apply, sub_sub_sub_cancel_right]
@@ -1591,10 +1591,10 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
         ·
           simp only [hx, singleton_prod, mem_image, Prod.mk.inj_iff, eq_self_iff_true, true_and_iff,
             exists_eq_right]
-        · rw [← dist_eq_norm] at hp 
+        · rw [← dist_eq_norm] at hp
           simpa only [Prod.dist_eq, εpos, dist_self, max_lt_iff, and_true_iff] using hp
       have : g' (p, x) ∈ closed_ball (0 : P × G →L[𝕜] E') C := hC (mem_image_of_mem _ H)
-      rwa [mem_closedBall_zero_iff] at this 
+      rwa [mem_closedBall_zero_iff] at this
     · have : g' (p, x) = 0 := g'_zero _ _ hps hx
       rw [this]
       simpa only [norm_zero] using Cpos.le
@@ -1642,7 +1642,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     by
     apply eventually_of_forall
     intro a x hx
-    rw [Prod.dist_eq, dist_eq_norm, dist_eq_norm] at hx 
+    rw [Prod.dist_eq, dist_eq_norm, dist_eq_norm] at hx
     have : (-tsupport fun a => g' (x.1, a)) + ball q₀.2 δ ⊆ U :=
       by
       apply subset.trans _ hδ
@@ -1676,7 +1676,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     have N : s ×ˢ univ ∈ 𝓝 (x.1, x.2 - a) := by
       apply A'
       apply h₀ε
-      rw [Prod.dist_eq] at hx 
+      rw [Prod.dist_eq] at hx
       exact lt_of_lt_of_le (lt_of_le_of_lt (le_max_left _ _) hx) δε
     have Z := ((hg.differentiable_on le_rfl).DifferentiableAt N).HasFDerivAt
     have Z' : HasFDerivAt (fun x : P × G => (x.1, x.2 - a)) (ContinuousLinearMap.id 𝕜 (P × G)) x :=
@@ -1825,7 +1825,7 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
       ContinuousLinearEquiv.prod_apply, ContinuousLinearEquiv.map_sub,
       ContinuousLinearEquiv.arrowCongr, ContinuousLinearEquiv.arrowCongrSL_symm_apply,
       ContinuousLinearEquiv.coe_coe, comp_app, ContinuousLinearEquiv.apply_symm_apply]
-  simp_rw [this] at A 
+  simp_rw [this] at A
   exact A
 #align cont_diff_on_convolution_right_with_param contDiffOn_convolution_right_with_param
 -/
@@ -1961,7 +1961,7 @@ theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Meas
     (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     Integrable (posConvolution f g L ν) μ :=
   by
-  rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg 
+  rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg
   rw [posConvolution_eq_convolution_indicator f g L ν]
   exact (hf.convolution_integrand L hg).integral_prod_left
 #align integrable_pos_convolution integrable_posConvolution
@@ -1976,7 +1976,7 @@ theorem integral_posConvolution [CompleteSpace E] [CompleteSpace E'] {μ ν : Me
     ∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0 ..x, L (f t) (g (x - t)) ∂ν ∂μ =
       L (∫ x : ℝ in Ioi 0, f x ∂ν) (∫ x : ℝ in Ioi 0, g x ∂μ) :=
   by
-  rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg 
+  rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg
   simp_rw [← integral_indicator measurableSet_Ioi]
   convert integral_convolution L hf hg using 2
   apply posConvolution_eq_convolution_indicator

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

@@ -400,7 +400,7 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
           v.to_measurable_equiv.measurable_embedding).1
       A
   ext x
-  simp only [Homeomorph.neg, sub_eq_add_neg, coe_toAddUnits, Homeomorph.trans_apply,
+  simp only [Homeomorph.neg, sub_eq_add_neg, val_toAddUnits_apply, Homeomorph.trans_apply,
     Equiv.neg_apply, Equiv.toFun_as_coe, Homeomorph.homeomorph_mk_coe, Equiv.coe_fn_mk,
     Homeomorph.coe_addLeft]
 #align has_compact_support.convolution_exists_at HasCompactSupport.convolutionExistsAt

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

@@ -1077,7 +1077,7 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
       rw [mem_ball_zero_iff] at h2t 
       specialize hg (x₀ - t)
       rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg 
-      refine' ((L (f t)).dist_le_op_norm _ _).trans _
+      refine' ((L (f t)).dist_le_opNorm _ _).trans _
       exact mul_le_mul_of_nonneg_left (hg h2t) (norm_nonneg _)
     · rw [nmem_support] at ht 
       simp_rw [ht, L.map_zero₂, L.map_zero, norm_zero, MulZeroClass.zero_mul, dist_self]

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

@@ -1722,7 +1722,7 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
       ∀ q₀ : P × G,
         q₀.1 ∈ s → HasFDerivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (f' q₀.1 q₀.2) q₀ :=
       hasFDerivAt_convolution_right_with_param L hs hk hgs hf hg.one_of_succ
-    rw [contDiffOn_succ_iff_fderiv_of_open (hs.prod (@isOpen_univ G _))] at hg ⊢
+    rw [contDiffOn_succ_iff_fderiv_of_isOpen (hs.prod (@isOpen_univ G _))] at hg ⊢
     constructor
     · rintro ⟨p, x⟩ ⟨hp, hx⟩
       exact (A (p, x) hp).DifferentiableAt.DifferentiableWithinAt

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

@@ -717,12 +717,12 @@ variable [BorelSpace G] [FirstCountableTopology G] [TopologicalSpace P] [FirstCo
 /- ./././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 continuousOn_convolution_right_with_param' /-
+#print continuousOn_convolution_right_with_param /-
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
 compactly supported. Version where `g` depends on an additional parameter in a subset `s` of
 a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
 not assuming `t2_space G`. -/
-theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set P} {k : Set G}
+theorem continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
     (hk : IsCompact k) (h'k : IsClosed k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
     (hf : LocallyIntegrable f μ) (hg : ContinuousOn (↿g) (s ×ˢ univ)) :
     ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) :=
@@ -821,9 +821,11 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     rintro ⟨q, x⟩ ⟨hq, hx⟩
     exact ⟨hq, mem_univ _⟩
   exact continuous_within_at_of_dominated I1 I2 I3 I4
-#align continuous_on_convolution_right_with_param' continuousOn_convolution_right_with_param'
+#align continuous_on_convolution_right_with_param' continuousOn_convolution_right_with_param
 -/
 
+/- warning: continuous_on_convolution_right_with_param clashes with continuous_on_convolution_right_with_param' -> continuousOn_convolution_right_with_param
+Case conversion may be inaccurate. Consider using '#align continuous_on_convolution_right_with_param continuousOn_convolution_right_with_paramₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print continuousOn_convolution_right_with_param /-
@@ -834,29 +836,31 @@ theorem continuousOn_convolution_right_with_param [T2Space G] {g : P → G → E
     {k : Set G} (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
     (hf : LocallyIntegrable f μ) (hg : ContinuousOn (↿g) (s ×ˢ univ)) :
     ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) :=
-  continuousOn_convolution_right_with_param' L hk hk.IsClosed hgs hf hg
+  continuousOn_convolution_right_with_param L hk hk.IsClosed hgs hf hg
 #align continuous_on_convolution_right_with_param continuousOn_convolution_right_with_param
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print continuousOn_convolution_right_with_param_comp' /-
+#print continuousOn_convolution_right_with_param_comp /-
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
 compactly supported. Version where `g` depends on an additional parameter in an open subset `s` of
 a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
 given in terms of compositions with an additional continuous map.
 Version not assuming `t2_space G`. -/
-theorem continuousOn_convolution_right_with_param_comp' {s : Set P} {v : P → G}
+theorem continuousOn_convolution_right_with_param_comp {s : Set P} {v : P → G}
     (hv : ContinuousOn v s) {g : P → G → E'} {k : Set G} (hk : IsCompact k) (h'k : IsClosed k)
     (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
     (hg : ContinuousOn (↿g) (s ×ˢ univ)) : ContinuousOn (fun x => (f ⋆[L, μ] g x) (v x)) s :=
   by
   apply
-    (continuousOn_convolution_right_with_param' L hk h'k hgs hf hg).comp (continuous_on_id.prod hv)
+    (continuousOn_convolution_right_with_param L hk h'k hgs hf hg).comp (continuous_on_id.prod hv)
   intro x hx
   simp only [hx, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, id.def]
-#align continuous_on_convolution_right_with_param_comp' continuousOn_convolution_right_with_param_comp'
+#align continuous_on_convolution_right_with_param_comp' continuousOn_convolution_right_with_param_comp
 -/
 
+/- warning: continuous_on_convolution_right_with_param_comp clashes with continuous_on_convolution_right_with_param_comp' -> continuousOn_convolution_right_with_param_comp
+Case conversion may be inaccurate. Consider using '#align continuous_on_convolution_right_with_param_comp continuousOn_convolution_right_with_param_compₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print continuousOn_convolution_right_with_param_comp /-
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
@@ -867,7 +871,7 @@ theorem continuousOn_convolution_right_with_param_comp [T2Space G] {s : Set P} {
     (hv : ContinuousOn v s) {g : P → G → E'} {k : Set G} (hk : IsCompact k)
     (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
     (hg : ContinuousOn (↿g) (s ×ˢ univ)) : ContinuousOn (fun x => (f ⋆[L, μ] g x) (v x)) s :=
-  continuousOn_convolution_right_with_param_comp' L hv hk hk.IsClosed hgs hf hg
+  continuousOn_convolution_right_with_param_comp L hv hk hk.IsClosed hgs hf hg
 #align continuous_on_convolution_right_with_param_comp continuousOn_convolution_right_with_param_comp
 -/
 
@@ -882,7 +886,7 @@ theorem HasCompactSupport.continuous_convolution_right (hcg : HasCompactSupport
   let g' : G → G → E' := fun p q => g q
   have : ContinuousOn (↿g') (univ ×ˢ univ) := (hg.comp continuous_snd).ContinuousOn
   exact
-    continuousOn_convolution_right_with_param_comp' L
+    continuousOn_convolution_right_with_param_comp L
       (continuous_iff_continuousOn_univ.1 continuous_id) hcg (isClosed_tsupport _)
       (fun p x hp hx => image_eq_zero_of_nmem_tsupport hx) hf this
 #align has_compact_support.continuous_convolution_right HasCompactSupport.continuous_convolution_right

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

@@ -3,13 +3,13 @@ Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 -/
-import Mathbin.Analysis.Calculus.BumpFunctionInner
-import Mathbin.Analysis.Calculus.ParametricIntegral
-import Mathbin.MeasureTheory.Constructions.Prod.Integral
-import Mathbin.MeasureTheory.Function.LocallyIntegrable
-import Mathbin.MeasureTheory.Group.Integration
-import Mathbin.MeasureTheory.Group.Prod
-import Mathbin.MeasureTheory.Integral.IntervalIntegral
+import Analysis.Calculus.BumpFunctionInner
+import Analysis.Calculus.ParametricIntegral
+import MeasureTheory.Constructions.Prod.Integral
+import MeasureTheory.Function.LocallyIntegrable
+import MeasureTheory.Group.Integration
+import MeasureTheory.Group.Prod
+import MeasureTheory.Integral.IntervalIntegral
 
 #align_import analysis.convolution from "leanprover-community/mathlib"@"8905e5ed90859939681a725b00f6063e65096d95"
 
@@ -691,7 +691,7 @@ variable [TopologicalAddGroup G]
 #print HasCompactSupport.convolution /-
 theorem HasCompactSupport.convolution [T2Space G] (hcf : HasCompactSupport f)
     (hcg : HasCompactSupport g) : HasCompactSupport (f ⋆[L, μ] g) :=
-  isCompact_of_isClosed_subset (hcg.IsCompact.add hcf) isClosed_closure <|
+  IsCompact.of_isClosed_subset (hcg.IsCompact.add hcf) isClosed_closure <|
     closure_minimal
       ((support_convolution_subset_swap L).trans <| add_subset_add subset_closure subset_closure)
       (hcg.IsCompact.add hcf).IsClosed
@@ -775,7 +775,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     filter_upwards [self_mem_nhdsWithin]
     rintro ⟨p, x⟩ ⟨hp, hx⟩
     refine' (HasCompactSupport.convolutionExists_right L _ hf (A _ hp) _).1
-    exact isCompact_of_isClosed_subset hk (isClosed_tsupport _) (B p hp)
+    exact IsCompact.of_isClosed_subset hk (isClosed_tsupport _) (B p hp)
   let K' := -k + {q₀.2}
   have hK' : IsCompact K' := hk.neg.add isCompact_singleton
   obtain ⟨U, U_open, K'U, hU⟩ : ∃ U, IsOpen U ∧ K' ⊆ U ∧ integrable_on f U μ
@@ -1604,7 +1604,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     filter_upwards [A' q₀ hq₀]
     rintro ⟨p, x⟩ ⟨hp, hx⟩
     refine' (HasCompactSupport.convolutionExists_right L _ hf (A _ hp) _).1
-    apply isCompact_of_isClosed_subset hk (isClosed_tsupport _)
+    apply IsCompact.of_isClosed_subset hk (isClosed_tsupport _)
     exact closure_minimal (support_subset_iff'.2 fun z hz => hgs _ _ hp hz) hk.is_closed
   have I2 : integrable (fun a : G => L (f a) (g q₀.1 (q₀.2 - a))) μ :=
     by

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

@@ -2,11 +2,6 @@
 Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
-
-! This file was ported from Lean 3 source module analysis.convolution
-! leanprover-community/mathlib commit 8905e5ed90859939681a725b00f6063e65096d95
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.Calculus.BumpFunctionInner
 import Mathbin.Analysis.Calculus.ParametricIntegral
@@ -16,6 +11,8 @@ import Mathbin.MeasureTheory.Group.Integration
 import Mathbin.MeasureTheory.Group.Prod
 import Mathbin.MeasureTheory.Integral.IntervalIntegral
 
+#align_import analysis.convolution from "leanprover-community/mathlib"@"8905e5ed90859939681a725b00f6063e65096d95"
+
 /-!
 # Convolution of functions
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8905e5ed90859939681a725b00f6063e65096d95

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 
 ! This file was ported from Lean 3 source module analysis.convolution
-! leanprover-community/mathlib commit 1b089e3bdc3ce6b39cd472543474a0a137128c6c
+! leanprover-community/mathlib commit 8905e5ed90859939681a725b00f6063e65096d95
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -1823,8 +1823,7 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
     simp only [ef, eg, comp_app, ContinuousLinearEquiv.apply_symm_apply, coe_comp',
       ContinuousLinearEquiv.prod_apply, ContinuousLinearEquiv.map_sub,
       ContinuousLinearEquiv.arrowCongr, ContinuousLinearEquiv.arrowCongrSL_symm_apply,
-      ContinuousLinearEquiv.coe_coe, comp_app, ContinuousLinearEquiv.apply_symm_apply,
-      LinearEquiv.invFun_eq_symm, ContinuousLinearEquiv.arrowCongrₛₗ_symm_apply, eq_self_iff_true]
+      ContinuousLinearEquiv.coe_coe, comp_app, ContinuousLinearEquiv.apply_symm_apply]
   simp_rw [this] at A 
   exact A
 #align cont_diff_on_convolution_right_with_param contDiffOn_convolution_right_with_param

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 
 ! This file was ported from Lean 3 source module analysis.convolution
-! leanprover-community/mathlib commit f7ebde7ee0d1505dfccac8644ae12371aa3c1c9f
+! leanprover-community/mathlib commit 1b089e3bdc3ce6b39cd472543474a0a137128c6c
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -19,6 +19,9 @@ import Mathbin.MeasureTheory.Integral.IntervalIntegral
 /-!
 # Convolution of functions
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file defines the convolution on two functions, i.e. `x ↦ ∫ f(t)g(x - t) ∂t`.
 In the general case, these functions can be vector-valued, and have an arbitrary (additive)
 group as domain. We use a continuous bilinear operation `L` on these function values as

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

@@ -120,6 +120,7 @@ section NoMeasurability
 
 variable [AddGroup G] [TopologicalSpace G]
 
+#print convolution_integrand_bound_right_of_le_of_subset /-
 theorem convolution_integrand_bound_right_of_le_of_subset {C : ℝ} (hC : ∀ i, ‖g i‖ ≤ C) {x t : G}
     {s u : Set G} (hx : x ∈ s) (hu : -tsupport g + s ⊆ u) :
     ‖L (f t) (g (x - t))‖ ≤ u.indicator (fun t => ‖L‖ * ‖f t‖ * C) t :=
@@ -134,7 +135,9 @@ theorem convolution_integrand_bound_right_of_le_of_subset {C : ℝ} (hC : ∀ i,
       rw [neg_sub, sub_add_cancel]
     rw [nmem_support.mp this, (L _).map_zero, norm_zero]
 #align convolution_integrand_bound_right_of_le_of_subset convolution_integrand_bound_right_of_le_of_subset
+-/
 
+#print HasCompactSupport.convolution_integrand_bound_right_of_subset /-
 theorem HasCompactSupport.convolution_integrand_bound_right_of_subset (hcg : HasCompactSupport g)
     (hg : Continuous g) {x t : G} {s u : Set G} (hx : x ∈ s) (hu : -tsupport g + s ⊆ u) :
     ‖L (f t) (g (x - t))‖ ≤ u.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖) t :=
@@ -142,18 +145,24 @@ theorem HasCompactSupport.convolution_integrand_bound_right_of_subset (hcg : Has
   apply convolution_integrand_bound_right_of_le_of_subset _ (fun i => _) hx hu
   exact le_ciSup (hg.norm.bdd_above_range_of_has_compact_support hcg.norm) _
 #align has_compact_support.convolution_integrand_bound_right_of_subset HasCompactSupport.convolution_integrand_bound_right_of_subset
+-/
 
+#print HasCompactSupport.convolution_integrand_bound_right /-
 theorem HasCompactSupport.convolution_integrand_bound_right (hcg : HasCompactSupport g)
     (hg : Continuous g) {x t : G} {s : Set G} (hx : x ∈ s) :
     ‖L (f t) (g (x - t))‖ ≤ (-tsupport g + s).indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖) t :=
   hcg.convolution_integrand_bound_right_of_subset L hg hx Subset.rfl
 #align has_compact_support.convolution_integrand_bound_right HasCompactSupport.convolution_integrand_bound_right
+-/
 
+#print Continuous.convolution_integrand_fst /-
 theorem Continuous.convolution_integrand_fst [ContinuousSub G] (hg : Continuous g) (t : G) :
     Continuous fun x => L (f t) (g (x - t)) :=
   L.continuous₂.comp₂ continuous_const <| hg.comp <| continuous_id.sub continuous_const
 #align continuous.convolution_integrand_fst Continuous.convolution_integrand_fst
+-/
 
+#print HasCompactSupport.convolution_integrand_bound_left /-
 theorem HasCompactSupport.convolution_integrand_bound_left (hcf : HasCompactSupport f)
     (hf : Continuous f) {x t : G} {s : Set G} (hx : x ∈ s) :
     ‖L (f (x - t)) (g t)‖ ≤ (-tsupport f + s).indicator (fun t => (‖L‖ * ⨆ i, ‖f i‖) * ‖g t‖) t :=
@@ -161,6 +170,7 @@ theorem HasCompactSupport.convolution_integrand_bound_left (hcf : HasCompactSupp
   convert hcf.convolution_integrand_bound_right L.flip hf hx
   simp_rw [L.op_norm_flip, mul_right_comm]
 #align has_compact_support.convolution_integrand_bound_left HasCompactSupport.convolution_integrand_bound_left
+-/
 
 end NoMeasurability
 
@@ -168,28 +178,34 @@ section Measurability
 
 variable [MeasurableSpace G] {μ ν : Measure G}
 
+#print ConvolutionExistsAt /-
 /-- The convolution of `f` and `g` exists at `x` when the function `t ↦ L (f t) (g (x - t))` is
 integrable. There are various conditions on `f` and `g` to prove this. -/
 def ConvolutionExistsAt [Sub G] (f : G → E) (g : G → E') (x : G) (L : E →L[𝕜] E' →L[𝕜] F)
     (μ : Measure G := by exact MeasureTheory.MeasureSpace.volume) : Prop :=
   Integrable (fun t => L (f t) (g (x - t))) μ
 #align convolution_exists_at ConvolutionExistsAt
+-/
 
+#print ConvolutionExists /-
 /-- The convolution of `f` and `g` exists when the function `t ↦ L (f t) (g (x - t))` is integrable
 for all `x : G`. There are various conditions on `f` and `g` to prove this. -/
 def ConvolutionExists [Sub G] (f : G → E) (g : G → E') (L : E →L[𝕜] E' →L[𝕜] F)
     (μ : Measure G := by exact MeasureTheory.MeasureSpace.volume) : Prop :=
   ∀ x : G, ConvolutionExistsAt f g x L μ
 #align convolution_exists ConvolutionExists
+-/
 
 section ConvolutionExists
 
 variable {L}
 
+#print ConvolutionExistsAt.integrable /-
 theorem ConvolutionExistsAt.integrable [Sub G] {x : G} (h : ConvolutionExistsAt f g x L μ) :
     Integrable (fun t => L (f t) (g (x - t))) μ :=
   h
 #align convolution_exists_at.integrable ConvolutionExistsAt.integrable
+-/
 
 variable (L)
 
@@ -197,30 +213,37 @@ section Group
 
 variable [AddGroup G]
 
+#print MeasureTheory.AEStronglyMeasurable.convolution_integrand' /-
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand' [MeasurableAdd₂ G]
     [MeasurableNeg G] [SigmaFinite ν] (hf : AEStronglyMeasurable f ν)
     (hg : AEStronglyMeasurable g <| map (fun p : G × G => p.1 - p.2) (μ.Prod ν)) :
     AEStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
   L.aestronglyMeasurable_comp₂ hf.snd <| hg.comp_measurable measurable_sub
 #align measure_theory.ae_strongly_measurable.convolution_integrand' MeasureTheory.AEStronglyMeasurable.convolution_integrand'
+-/
 
 section
 
 variable [MeasurableAdd G] [MeasurableNeg G]
 
+#print MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd' /-
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd'
     (hf : AEStronglyMeasurable f μ) {x : G}
     (hg : AEStronglyMeasurable g <| map (fun t => x - t) μ) :
     AEStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
   L.aestronglyMeasurable_comp₂ hf <| hg.comp_measurable <| measurable_id.const_sub x
 #align measure_theory.ae_strongly_measurable.convolution_integrand_snd' MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd'
+-/
 
+#print MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd' /-
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd' {x : G}
     (hf : AEStronglyMeasurable f <| map (fun t => x - t) μ) (hg : AEStronglyMeasurable g μ) :
     AEStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
   L.aestronglyMeasurable_comp₂ (hf.comp_measurable <| measurable_id.const_sub x) hg
 #align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd' MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd'
+-/
 
+#print BddAbove.convolutionExistsAt' /-
 /-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
 We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
 on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
@@ -249,7 +272,9 @@ theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
   · rw [integrable_indicator_iff hs]; exact ((hf.norm.const_mul _).mul_const _).IntegrableOn
   · exact hf.ae_strongly_measurable.convolution_integrand_snd' L hmg
 #align bdd_above.convolution_exists_at' BddAbove.convolutionExistsAt'
+-/
 
+#print ConvolutionExistsAt.ofNorm' /-
 /-- If `‖f‖ *[μ] ‖g‖` exists, then `f *[L, μ] g` exists. -/
 theorem ConvolutionExistsAt.ofNorm' {x₀ : G}
     (h : ConvolutionExistsAt (fun x => ‖f x‖) (fun x => ‖g x‖) x₀ (mul ℝ ℝ) μ)
@@ -261,6 +286,7 @@ theorem ConvolutionExistsAt.ofNorm' {x₀ : G}
   rw [mul_apply', ← mul_assoc]
   apply L.le_op_norm₂
 #align convolution_exists_at.of_norm' ConvolutionExistsAt.ofNorm'
+-/
 
 end
 
@@ -268,13 +294,16 @@ section Left
 
 variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
+#print MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd /-
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd (hf : AEStronglyMeasurable f μ)
     (hg : AEStronglyMeasurable g μ) (x : G) :
     AEStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
   hf.convolution_integrand_snd' L <|
     hg.mono' <| (quasiMeasurePreserving_sub_left_of_right_invariant μ x).AbsolutelyContinuous
 #align measure_theory.ae_strongly_measurable.convolution_integrand_snd MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd
+-/
 
+#print MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd /-
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd
     (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) (x : G) :
     AEStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
@@ -283,7 +312,9 @@ theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd
             x).AbsolutelyContinuous).convolution_integrand_swap_snd'
     L hg
 #align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd
+-/
 
+#print ConvolutionExistsAt.ofNorm /-
 /-- If `‖f‖ *[μ] ‖g‖` exists, then `f *[L, μ] g` exists. -/
 theorem ConvolutionExistsAt.ofNorm {x₀ : G}
     (h : ConvolutionExistsAt (fun x => ‖f x‖) (fun x => ‖g x‖) x₀ (mul ℝ ℝ) μ)
@@ -292,6 +323,7 @@ theorem ConvolutionExistsAt.ofNorm {x₀ : G}
   h.ofNorm' L hmf <|
     hmg.mono' (quasiMeasurePreserving_sub_left_of_right_invariant μ x₀).AbsolutelyContinuous
 #align convolution_exists_at.of_norm ConvolutionExistsAt.ofNorm
+-/
 
 end Left
 
@@ -300,13 +332,16 @@ section Right
 variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
   [SigmaFinite ν]
 
+#print MeasureTheory.AEStronglyMeasurable.convolution_integrand /-
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand (hf : AEStronglyMeasurable f ν)
     (hg : AEStronglyMeasurable g μ) :
     AEStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
   hf.convolution_integrand' L <|
     hg.mono' (quasiMeasurePreserving_sub_of_right_invariant μ ν).AbsolutelyContinuous
 #align measure_theory.ae_strongly_measurable.convolution_integrand MeasureTheory.AEStronglyMeasurable.convolution_integrand
+-/
 
+#print MeasureTheory.Integrable.convolution_integrand /-
 theorem MeasureTheory.Integrable.convolution_integrand (hf : Integrable f ν) (hg : Integrable g μ) :
     Integrable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
   by
@@ -329,18 +364,22 @@ theorem MeasureTheory.Integrable.convolution_integrand (hf : Integrable f ν) (h
           ((hg.comp_sub_right t).norm.const_mul _) (eventually_of_forall fun t => L.le_op_norm₂ _ _)
     exact integral_nonneg fun x => norm_nonneg _
 #align measure_theory.integrable.convolution_integrand MeasureTheory.Integrable.convolution_integrand
+-/
 
+#print MeasureTheory.Integrable.ae_convolution_exists /-
 theorem MeasureTheory.Integrable.ae_convolution_exists (hf : Integrable f ν) (hg : Integrable g μ) :
     ∀ᵐ x ∂μ, ConvolutionExistsAt f g x L ν :=
   ((integrable_prod_iff <|
           hf.AEStronglyMeasurable.convolution_integrand L hg.AEStronglyMeasurable).mp <|
       hf.convolution_integrand L hg).1
 #align measure_theory.integrable.ae_convolution_exists MeasureTheory.Integrable.ae_convolution_exists
+-/
 
 end Right
 
 variable [TopologicalSpace G] [TopologicalAddGroup G] [BorelSpace G]
 
+#print HasCompactSupport.convolutionExistsAt /-
 theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
     (h : HasCompactSupport fun t => L (f t) (g (x₀ - t))) (hf : LocallyIntegrable f μ)
     (hg : Continuous g) : ConvolutionExistsAt f g x₀ L μ :=
@@ -365,8 +404,10 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
     Equiv.neg_apply, Equiv.toFun_as_coe, Homeomorph.homeomorph_mk_coe, Equiv.coe_fn_mk,
     Homeomorph.coe_addLeft]
 #align has_compact_support.convolution_exists_at HasCompactSupport.convolutionExistsAt
+-/
 
-theorem HasCompactSupport.convolutionExistsRight (hcg : HasCompactSupport g)
+#print HasCompactSupport.convolutionExists_right /-
+theorem HasCompactSupport.convolutionExists_right (hcg : HasCompactSupport g)
     (hf : LocallyIntegrable f μ) (hg : Continuous g) : ConvolutionExists f g L μ :=
   by
   intro x₀
@@ -374,9 +415,11 @@ theorem HasCompactSupport.convolutionExistsRight (hcg : HasCompactSupport g)
   refine' (hcg.comp_homeomorph (Homeomorph.subLeft x₀)).mono _
   refine' fun t => mt fun ht : g (x₀ - t) = 0 => _
   simp_rw [ht, (L _).map_zero]
-#align has_compact_support.convolution_exists_right HasCompactSupport.convolutionExistsRight
+#align has_compact_support.convolution_exists_right HasCompactSupport.convolutionExists_right
+-/
 
-theorem HasCompactSupport.convolutionExistsLeftOfContinuousRight (hcf : HasCompactSupport f)
+#print HasCompactSupport.convolutionExists_left_of_continuous_right /-
+theorem HasCompactSupport.convolutionExists_left_of_continuous_right (hcf : HasCompactSupport f)
     (hf : LocallyIntegrable f μ) (hg : Continuous g) : ConvolutionExists f g L μ :=
   by
   intro x₀
@@ -384,7 +427,8 @@ theorem HasCompactSupport.convolutionExistsLeftOfContinuousRight (hcf : HasCompa
   refine' hcf.mono _
   refine' fun t => mt fun ht : f t = 0 => _
   simp_rw [ht, L.map_zero₂]
-#align has_compact_support.convolution_exists_left_of_continuous_right HasCompactSupport.convolutionExistsLeftOfContinuousRight
+#align has_compact_support.convolution_exists_left_of_continuous_right HasCompactSupport.convolutionExists_left_of_continuous_right
+-/
 
 end Group
 
@@ -396,6 +440,7 @@ section MeasurableGroup
 
 variable [MeasurableNeg G] [IsAddLeftInvariant μ]
 
+#print BddAbove.convolutionExistsAt /-
 /-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
 We assume that the integrand has compact support and `g` is bounded on this support (note that
 both properties hold if `g` is continuous with compact support). We also require that `f` is
@@ -416,39 +461,50 @@ theorem BddAbove.convolutionExistsAt [MeasurableAdd₂ G] [SigmaFinite μ] {x₀
     exact
       map_mono_of_ae_measurable restrict_le_self (measurable_const.sub measurable_id').AEMeasurable
 #align bdd_above.convolution_exists_at BddAbove.convolutionExistsAt
+-/
 
 variable {L} [MeasurableAdd G] [IsNegInvariant μ]
 
+#print convolutionExistsAt_flip /-
 theorem convolutionExistsAt_flip :
     ConvolutionExistsAt g f x L.flip μ ↔ ConvolutionExistsAt f g x L μ := by
   simp_rw [ConvolutionExistsAt, ← integrable_comp_sub_left (fun t => L (f t) (g (x - t))) x,
     sub_sub_cancel, flip_apply]
 #align convolution_exists_at_flip convolutionExistsAt_flip
+-/
 
+#print ConvolutionExistsAt.integrable_swap /-
 theorem ConvolutionExistsAt.integrable_swap (h : ConvolutionExistsAt f g x L μ) :
     Integrable (fun t => L (f (x - t)) (g t)) μ := by convert h.comp_sub_left x;
   simp_rw [sub_sub_self]
 #align convolution_exists_at.integrable_swap ConvolutionExistsAt.integrable_swap
+-/
 
+#print convolutionExistsAt_iff_integrable_swap /-
 theorem convolutionExistsAt_iff_integrable_swap :
     ConvolutionExistsAt f g x L μ ↔ Integrable (fun t => L (f (x - t)) (g t)) μ :=
   convolutionExistsAt_flip.symm
 #align convolution_exists_at_iff_integrable_swap convolutionExistsAt_iff_integrable_swap
+-/
 
 end MeasurableGroup
 
 variable [TopologicalSpace G] [TopologicalAddGroup G] [BorelSpace G] [IsAddLeftInvariant μ]
   [IsNegInvariant μ]
 
+#print HasCompactSupport.convolutionExistsLeft /-
 theorem HasCompactSupport.convolutionExistsLeft (hcf : HasCompactSupport f) (hf : Continuous f)
     (hg : LocallyIntegrable g μ) : ConvolutionExists f g L μ := fun x₀ =>
-  convolutionExistsAt_flip.mp <| hcf.convolutionExistsRight L.flip hg hf x₀
+  convolutionExistsAt_flip.mp <| hcf.convolutionExists_right L.flip hg hf x₀
 #align has_compact_support.convolution_exists_left HasCompactSupport.convolutionExistsLeft
+-/
 
+#print HasCompactSupport.convolutionExistsRightOfContinuousLeft /-
 theorem HasCompactSupport.convolutionExistsRightOfContinuousLeft (hcg : HasCompactSupport g)
     (hf : Continuous f) (hg : LocallyIntegrable g μ) : ConvolutionExists f g L μ := fun x₀ =>
-  convolutionExistsAt_flip.mp <| hcg.convolutionExistsLeftOfContinuousRight L.flip hg hf x₀
+  convolutionExistsAt_flip.mp <| hcg.convolutionExists_left_of_continuous_right L.flip hg hf x₀
 #align has_compact_support.convolution_exists_right_of_continuous_left HasCompactSupport.convolutionExistsRightOfContinuousLeft
+-/
 
 end CommGroup
 
@@ -456,12 +512,14 @@ end ConvolutionExists
 
 variable [NormedSpace ℝ F] [CompleteSpace F]
 
+#print convolution /-
 /-- The convolution of two functions `f` and `g` with respect to a continuous bilinear map `L` and
 measure `μ`. It is defined to be `(f ⋆[L, μ] g) x = ∫ t, L (f t) (g (x - t)) ∂μ`. -/
 noncomputable def convolution [Sub G] (f : G → E) (g : G → E') (L : E →L[𝕜] E' →L[𝕜] F)
     (μ : Measure G := by exact MeasureTheory.MeasureSpace.volume) : G → F := fun x =>
   ∫ t, L (f t) (g (x - t)) ∂μ
 #align convolution convolution
+-/
 
 scoped[convolution] notation:67 f " ⋆[" L:67 ", " μ:67 "] " g:66 => convolution f g L μ
 
@@ -472,67 +530,90 @@ scoped[convolution]
   notation:67 f " ⋆ " g:66 =>
     convolution f g (ContinuousLinearMap.lsmul ℝ ℝ) MeasureTheory.MeasureSpace.volume
 
+#print convolution_def /-
 theorem convolution_def [Sub G] : (f ⋆[L, μ] g) x = ∫ t, L (f t) (g (x - t)) ∂μ :=
   rfl
 #align convolution_def convolution_def
+-/
 
+#print convolution_lsmul /-
 /-- The definition of convolution where the bilinear operator is scalar multiplication.
 Note: it often helps the elaborator to give the type of the convolution explicitly. -/
 theorem convolution_lsmul [Sub G] {f : G → 𝕜} {g : G → F} :
     (f ⋆[lsmul 𝕜 𝕜, μ] g : G → F) x = ∫ t, f t • g (x - t) ∂μ :=
   rfl
 #align convolution_lsmul convolution_lsmul
+-/
 
+#print convolution_mul /-
 /-- The definition of convolution where the bilinear operator is multiplication. -/
 theorem convolution_mul [Sub G] [NormedSpace ℝ 𝕜] [CompleteSpace 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
     (f ⋆[mul 𝕜 𝕜, μ] g) x = ∫ t, f t * g (x - t) ∂μ :=
   rfl
 #align convolution_mul convolution_mul
+-/
 
 section Group
 
 variable {L} [AddGroup G]
 
+#print smul_convolution /-
 theorem smul_convolution [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : y • f ⋆[L, μ] g = y • (f ⋆[L, μ] g) := by
   ext; simp only [Pi.smul_apply, convolution_def, ← integral_smul, L.map_smul₂]
 #align smul_convolution smul_convolution
+-/
 
+#print convolution_smul /-
 theorem convolution_smul [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : f ⋆[L, μ] y • g = y • (f ⋆[L, μ] g) := by
   ext; simp only [Pi.smul_apply, convolution_def, ← integral_smul, (L _).map_smul]
 #align convolution_smul convolution_smul
+-/
 
+#print zero_convolution /-
 @[simp]
 theorem zero_convolution : 0 ⋆[L, μ] g = 0 := by ext;
   simp_rw [convolution_def, Pi.zero_apply, L.map_zero₂, integral_zero]
 #align zero_convolution zero_convolution
+-/
 
+#print convolution_zero /-
 @[simp]
 theorem convolution_zero : f ⋆[L, μ] 0 = 0 := by ext;
   simp_rw [convolution_def, Pi.zero_apply, (L _).map_zero, integral_zero]
 #align convolution_zero convolution_zero
+-/
 
+#print ConvolutionExistsAt.distrib_add /-
 theorem ConvolutionExistsAt.distrib_add {x : G} (hfg : ConvolutionExistsAt f g x L μ)
     (hfg' : ConvolutionExistsAt f g' x L μ) :
     (f ⋆[L, μ] (g + g')) x = (f ⋆[L, μ] g) x + (f ⋆[L, μ] g') x := by
   simp only [convolution_def, (L _).map_add, Pi.add_apply, integral_add hfg hfg']
 #align convolution_exists_at.distrib_add ConvolutionExistsAt.distrib_add
+-/
 
+#print ConvolutionExists.distrib_add /-
 theorem ConvolutionExists.distrib_add (hfg : ConvolutionExists f g L μ)
     (hfg' : ConvolutionExists f g' L μ) : f ⋆[L, μ] (g + g') = f ⋆[L, μ] g + f ⋆[L, μ] g' := by ext;
   exact (hfg x).distrib_add (hfg' x)
 #align convolution_exists.distrib_add ConvolutionExists.distrib_add
+-/
 
+#print ConvolutionExistsAt.add_distrib /-
 theorem ConvolutionExistsAt.add_distrib {x : G} (hfg : ConvolutionExistsAt f g x L μ)
     (hfg' : ConvolutionExistsAt f' g x L μ) :
     ((f + f') ⋆[L, μ] g) x = (f ⋆[L, μ] g) x + (f' ⋆[L, μ] g) x := by
   simp only [convolution_def, L.map_add₂, Pi.add_apply, integral_add hfg hfg']
 #align convolution_exists_at.add_distrib ConvolutionExistsAt.add_distrib
+-/
 
+#print ConvolutionExists.add_distrib /-
 theorem ConvolutionExists.add_distrib (hfg : ConvolutionExists f g L μ)
     (hfg' : ConvolutionExists f' g L μ) : (f + f') ⋆[L, μ] g = f ⋆[L, μ] g + f' ⋆[L, μ] g := by ext;
   exact (hfg x).add_distrib (hfg' x)
 #align convolution_exists.add_distrib ConvolutionExists.add_distrib
+-/
 
+#print convolution_mono_right /-
 theorem convolution_mono_right {f g g' : G → ℝ} (hfg : ConvolutionExistsAt f g x (lsmul ℝ ℝ) μ)
     (hfg' : ConvolutionExistsAt f g' x (lsmul ℝ ℝ) μ) (hf : ∀ x, 0 ≤ f x) (hg : ∀ x, g x ≤ g' x) :
     (f ⋆[lsmul ℝ ℝ, μ] g) x ≤ (f ⋆[lsmul ℝ ℝ, μ] g') x :=
@@ -542,7 +623,9 @@ theorem convolution_mono_right {f g g' : G → ℝ} (hfg : ConvolutionExistsAt f
   intro t
   apply mul_le_mul_of_nonneg_left (hg _) (hf _)
 #align convolution_mono_right convolution_mono_right
+-/
 
+#print convolution_mono_right_of_nonneg /-
 theorem convolution_mono_right_of_nonneg {f g g' : G → ℝ}
     (hfg' : ConvolutionExistsAt f g' x (lsmul ℝ ℝ) μ) (hf : ∀ x, 0 ≤ f x) (hg : ∀ x, g x ≤ g' x)
     (hg' : ∀ x, 0 ≤ g' x) : (f ⋆[lsmul ℝ ℝ, μ] g) x ≤ (f ⋆[lsmul ℝ ℝ, μ] g') x :=
@@ -553,9 +636,11 @@ theorem convolution_mono_right_of_nonneg {f g g' : G → ℝ}
   rw [this]
   exact integral_nonneg fun y => mul_nonneg (hf y) (hg' (x - y))
 #align convolution_mono_right_of_nonneg convolution_mono_right_of_nonneg
+-/
 
 variable (L)
 
+#print convolution_congr /-
 theorem convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ]
     [IsAddRightInvariant μ] (h1 : f =ᵐ[μ] f') (h2 : g =ᵐ[μ] g') : f ⋆[L, μ] g = f' ⋆[L, μ] g' :=
   by
@@ -567,7 +652,9 @@ theorem convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ
             (quasi_measure_preserving_sub_left_of_right_invariant μ x).tendsto_ae).fun_comp
       ↿fun x y => L x y
 #align convolution_congr convolution_congr
+-/
 
+#print support_convolution_subset_swap /-
 theorem support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g + support f :=
   by
   intro x h2x
@@ -582,15 +669,18 @@ theorem support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g
   · rw [h, L.map_zero₂]
   · exact (h <| sub_add_cancel x t).elim
 #align support_convolution_subset_swap support_convolution_subset_swap
+-/
 
 section
 
 variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
+#print MeasureTheory.Integrable.integrable_convolution /-
 theorem MeasureTheory.Integrable.integrable_convolution (hf : Integrable f μ)
     (hg : Integrable g μ) : Integrable (f ⋆[L, μ] g) μ :=
   (hf.convolution_integrand L hg).integral_prod_left
 #align measure_theory.integrable.integrable_convolution MeasureTheory.Integrable.integrable_convolution
+-/
 
 end
 
@@ -598,6 +688,7 @@ variable [TopologicalSpace G]
 
 variable [TopologicalAddGroup G]
 
+#print HasCompactSupport.convolution /-
 theorem HasCompactSupport.convolution [T2Space G] (hcf : HasCompactSupport f)
     (hcg : HasCompactSupport g) : HasCompactSupport (f ⋆[L, μ] g) :=
   isCompact_of_isClosed_subset (hcg.IsCompact.add hcf) isClosed_closure <|
@@ -605,6 +696,7 @@ theorem HasCompactSupport.convolution [T2Space G] (hcf : HasCompactSupport f)
       ((support_convolution_subset_swap L).trans <| add_subset_add subset_closure subset_closure)
       (hcg.IsCompact.add hcf).IsClosed
 #align has_compact_support.convolution HasCompactSupport.convolution
+-/
 
 variable [BorelSpace G] [FirstCountableTopology G] [TopologicalSpace P] [FirstCountableTopology P]
 
@@ -625,6 +717,7 @@ variable [BorelSpace G] [FirstCountableTopology G] [TopologicalSpace P] [FirstCo
 /- ./././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 continuousOn_convolution_right_with_param' /-
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
 compactly supported. Version where `g` depends on an additional parameter in a subset `s` of
 a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
@@ -681,7 +774,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     by
     filter_upwards [self_mem_nhdsWithin]
     rintro ⟨p, x⟩ ⟨hp, hx⟩
-    refine' (HasCompactSupport.convolutionExistsRight L _ hf (A _ hp) _).1
+    refine' (HasCompactSupport.convolutionExists_right L _ hf (A _ hp) _).1
     exact isCompact_of_isClosed_subset hk (isClosed_tsupport _) (B p hp)
   let K' := -k + {q₀.2}
   have hK' : IsCompact K' := hk.neg.add isCompact_singleton
@@ -729,9 +822,11 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     exact ⟨hq, mem_univ _⟩
   exact continuous_within_at_of_dominated I1 I2 I3 I4
 #align continuous_on_convolution_right_with_param' continuousOn_convolution_right_with_param'
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print continuousOn_convolution_right_with_param /-
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
 compactly supported. Version where `g` depends on an additional parameter in a subset `s` of
 a parameter space `P` (and the compact support `k` is independent of the parameter in `s`). -/
@@ -741,8 +836,10 @@ theorem continuousOn_convolution_right_with_param [T2Space G] {g : P → G → E
     ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) :=
   continuousOn_convolution_right_with_param' L hk hk.IsClosed hgs hf hg
 #align continuous_on_convolution_right_with_param continuousOn_convolution_right_with_param
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print continuousOn_convolution_right_with_param_comp' /-
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
 compactly supported. Version where `g` depends on an additional parameter in an open subset `s` of
 a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
@@ -758,8 +855,10 @@ theorem continuousOn_convolution_right_with_param_comp' {s : Set P} {v : P → G
   intro x hx
   simp only [hx, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, id.def]
 #align continuous_on_convolution_right_with_param_comp' continuousOn_convolution_right_with_param_comp'
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print continuousOn_convolution_right_with_param_comp /-
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
 compactly supported. Version where `g` depends on an additional parameter in an open subset `s` of
 a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
@@ -770,8 +869,10 @@ theorem continuousOn_convolution_right_with_param_comp [T2Space G] {s : Set P} {
     (hg : ContinuousOn (↿g) (s ×ˢ univ)) : ContinuousOn (fun x => (f ⋆[L, μ] g x) (v x)) s :=
   continuousOn_convolution_right_with_param_comp' L hv hk hk.IsClosed hgs hf hg
 #align continuous_on_convolution_right_with_param_comp continuousOn_convolution_right_with_param_comp
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print HasCompactSupport.continuous_convolution_right /-
 /-- The convolution is continuous if one function is locally integrable and the other has compact
 support and is continuous. -/
 theorem HasCompactSupport.continuous_convolution_right (hcg : HasCompactSupport g)
@@ -785,7 +886,9 @@ theorem HasCompactSupport.continuous_convolution_right (hcg : HasCompactSupport
       (continuous_iff_continuousOn_univ.1 continuous_id) hcg (isClosed_tsupport _)
       (fun p x hp hx => image_eq_zero_of_nmem_tsupport hx) hf this
 #align has_compact_support.continuous_convolution_right HasCompactSupport.continuous_convolution_right
+-/
 
+#print BddAbove.continuous_convolution_right_of_integrable /-
 /-- The convolution is continuous if one function is integrable and the other is bounded and
 continuous. -/
 theorem BddAbove.continuous_convolution_right_of_integrable [SecondCountableTopology G]
@@ -811,6 +914,7 @@ theorem BddAbove.continuous_convolution_right_of_integrable [SecondCountableTopo
         (L.continuous₂.comp₂ continuous_const <|
             hg.comp <| continuous_id.sub <| by apply continuous_const).ContinuousAt
 #align bdd_above.continuous_convolution_right_of_integrable BddAbove.continuous_convolution_right_of_integrable
+-/
 
 end Group
 
@@ -818,9 +922,11 @@ section CommGroup
 
 variable [AddCommGroup G]
 
+#print support_convolution_subset /-
 theorem support_convolution_subset : support (f ⋆[L, μ] g) ⊆ support f + support g :=
   (support_convolution_subset_swap L).trans (add_comm _ _).Subset
 #align support_convolution_subset support_convolution_subset
+-/
 
 variable [IsAddLeftInvariant μ] [IsNegInvariant μ]
 
@@ -832,6 +938,7 @@ variable [MeasurableAdd G]
 
 variable (L)
 
+#print convolution_flip /-
 /-- Commutativity of convolution -/
 theorem convolution_flip : g ⋆[L.flip, μ] f = f ⋆[L, μ] g :=
   by
@@ -840,24 +947,32 @@ theorem convolution_flip : g ⋆[L.flip, μ] f = f ⋆[L, μ] g :=
   rw [← integral_sub_left_eq_self _ μ x]
   simp_rw [sub_sub_self, flip_apply]
 #align convolution_flip convolution_flip
+-/
 
+#print convolution_eq_swap /-
 /-- The symmetric definition of convolution. -/
 theorem convolution_eq_swap : (f ⋆[L, μ] g) x = ∫ t, L (f (x - t)) (g t) ∂μ := by
   rw [← convolution_flip]; rfl
 #align convolution_eq_swap convolution_eq_swap
+-/
 
+#print convolution_lsmul_swap /-
 /-- The symmetric definition of convolution where the bilinear operator is scalar multiplication. -/
 theorem convolution_lsmul_swap {f : G → 𝕜} {g : G → F} :
     (f ⋆[lsmul 𝕜 𝕜, μ] g : G → F) x = ∫ t, f (x - t) • g t ∂μ :=
   convolution_eq_swap _
 #align convolution_lsmul_swap convolution_lsmul_swap
+-/
 
+#print convolution_mul_swap /-
 /-- The symmetric definition of convolution where the bilinear operator is multiplication. -/
 theorem convolution_mul_swap [NormedSpace ℝ 𝕜] [CompleteSpace 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
     (f ⋆[mul 𝕜 𝕜, μ] g) x = ∫ t, f (x - t) * g t ∂μ :=
   convolution_eq_swap _
 #align convolution_mul_swap convolution_mul_swap
+-/
 
+#print convolution_neg_of_neg_eq /-
 /-- The convolution of two even functions is also even. -/
 theorem convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀ᵐ x ∂μ, g (-x) = g x) :
     (f ⋆[L, μ] g) (-x) = (f ⋆[L, μ] g) x :=
@@ -870,6 +985,7 @@ theorem convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀
     _ = ∫ t : G, (L (f t)) (g (x - t)) ∂μ := by rw [← integral_neg_eq_self];
       simp only [neg_neg, ← sub_eq_add_neg]
 #align convolution_neg_of_neg_eq convolution_neg_of_neg_eq
+-/
 
 end Measurable
 
@@ -879,17 +995,21 @@ variable [TopologicalAddGroup G]
 
 variable [BorelSpace G]
 
+#print HasCompactSupport.continuous_convolution_left /-
 theorem HasCompactSupport.continuous_convolution_left [FirstCountableTopology G]
     (hcf : HasCompactSupport f) (hf : Continuous f) (hg : LocallyIntegrable g μ) :
     Continuous (f ⋆[L, μ] g) := by rw [← convolution_flip];
   exact hcf.continuous_convolution_right L.flip hg hf
 #align has_compact_support.continuous_convolution_left HasCompactSupport.continuous_convolution_left
+-/
 
+#print BddAbove.continuous_convolution_left_of_integrable /-
 theorem BddAbove.continuous_convolution_left_of_integrable [SecondCountableTopology G]
     (hbf : BddAbove (range fun x => ‖f x‖)) (hf : Continuous f) (hg : Integrable g μ) :
     Continuous (f ⋆[L, μ] g) := by rw [← convolution_flip];
   exact hbf.continuous_convolution_right_of_integrable L.flip hg hf
 #align bdd_above.continuous_convolution_left_of_integrable BddAbove.continuous_convolution_left_of_integrable
+-/
 
 end CommGroup
 
@@ -897,6 +1017,7 @@ section NormedAddCommGroup
 
 variable [SeminormedAddCommGroup G]
 
+#print convolution_eq_right' /-
 /-- Compute `(f ⋆ g) x₀` if the support of the `f` is within `metric.ball 0 R`, and `g` is constant
 on `metric.ball x₀ R`.
 
@@ -917,11 +1038,13 @@ theorem convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 :
       simp_rw [ht, L.map_zero₂]
   simp_rw [convolution_def, h2]
 #align convolution_eq_right' convolution_eq_right'
+-/
 
 variable [BorelSpace G] [SecondCountableTopology G]
 
 variable [IsAddLeftInvariant μ] [SigmaFinite μ]
 
+#print dist_convolution_le' /-
 /-- Approximate `(f ⋆ g) x₀` if the support of the `f` is bounded within a ball, and `g` is near
 `g x₀` on a ball with the same radius around `x₀`. See `dist_convolution_le` for a special case.
 
@@ -969,9 +1092,11 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
   refine' (integral_mono (L.integrable_comp hif).norm (hif.norm.const_mul _) h3).trans_eq _
   rw [integral_mul_left]
 #align dist_convolution_le' dist_convolution_le'
+-/
 
 variable [NormedSpace ℝ E] [NormedSpace ℝ E'] [CompleteSpace E']
 
+#print dist_convolution_le /-
 /-- Approximate `f ⋆ g` if the support of the `f` is bounded within a ball, and `g` is near `g x₀`
 on a ball with the same radius around `x₀`.
 
@@ -989,7 +1114,9 @@ theorem dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'}
   · simp_rw [Real.norm_of_nonneg (hnf _), hintf, mul_one]
     exact (mul_le_mul_of_nonneg_right op_norm_lsmul_le hε).trans_eq (one_mul ε)
 #align dist_convolution_le dist_convolution_le
+-/
 
+#print convolution_tendsto_right /-
 /-- `(φ i ⋆ g i) (k i)` tends to `z₀` as `i` tends to some filter `l` if
 * `φ` is a sequence of nonnegative functions with integral `1` as `i` tends to `l`;
 * The support of `φ` tends to small neighborhoods around `(0 : G)` as `i` tends to `l`;
@@ -1028,6 +1155,7 @@ theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x
   refine' ((dist_triangle _ _ _).trans_lt (add_lt_add_of_le_of_lt this hgi)).trans_eq _
   field_simp; ring_nf
 #align convolution_tendsto_right convolution_tendsto_right
+-/
 
 end NormedAddCommGroup
 
@@ -1043,11 +1171,13 @@ variable [CompleteSpace E']
 
 variable {a : G} {φ : ContDiffBump (0 : G)}
 
+#print ContDiffBump.convolution_eq_right /-
 /-- If `φ` is a bump function, compute `(φ ⋆ g) x₀` if `g` is constant on `metric.ball x₀ φ.R`. -/
 theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :
     (φ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = integral μ φ • g x₀ := by
   simp_rw [convolution_eq_right' _ φ.support_eq.subset hg, lsmul_apply, integral_smul_const]
 #align cont_diff_bump.convolution_eq_right ContDiffBump.convolution_eq_right
+-/
 
 variable [BorelSpace G]
 
@@ -1055,6 +1185,7 @@ variable [IsLocallyFiniteMeasure μ] [IsOpenPosMeasure μ]
 
 variable [FiniteDimensional ℝ G]
 
+#print ContDiffBump.normed_convolution_eq_right /-
 /-- If `φ` is a normed bump function, compute `φ ⋆ g` if `g` is constant on `metric.ball x₀ φ.R`. -/
 theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :
     (φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = g x₀ :=
@@ -1062,9 +1193,11 @@ theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut
   simp_rw [convolution_eq_right' _ φ.support_normed_eq.subset hg, lsmul_apply]
   exact integral_normed_smul φ μ (g x₀)
 #align cont_diff_bump.normed_convolution_eq_right ContDiffBump.normed_convolution_eq_right
+-/
 
 variable [IsAddLeftInvariant μ]
 
+#print ContDiffBump.dist_normed_convolution_le /-
 /-- If `φ` is a normed bump function, approximate `(φ ⋆ g) x₀` if `g` is near `g x₀` on a ball with
 radius `φ.R` around `x₀`. -/
 theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AEStronglyMeasurable g μ)
@@ -1073,7 +1206,9 @@ theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AEStronglyMeasur
   dist_convolution_le (by simp_rw [← dist_self (g x₀), hg x₀ (mem_ball_self φ.R_pos)])
     φ.support_normed_eq.Subset φ.nonneg_normed φ.integral_normed hmg hg
 #align cont_diff_bump.dist_normed_convolution_le ContDiffBump.dist_normed_convolution_le
+-/
 
+#print ContDiffBump.convolution_tendsto_right /-
 /-- `(φ i ⋆ g i) (k i)` tends to `z₀` as `i` tends to some filter `l` if
 * `φ` is a sequence of normed bump functions such that `(φ i).R` tends to `0` as `i` tends to `l`;
 * `g i` is `mu`-a.e. strongly measurable as `i` tends to `l`;
@@ -1088,7 +1223,9 @@ theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)} {g : 
     (eventually_of_forall fun i => (φ i).integral_normed) (tendsto_support_normed_smallSets hφ) hig
     hcg hk
 #align cont_diff_bump.convolution_tendsto_right ContDiffBump.convolution_tendsto_right
+-/
 
+#print ContDiffBump.convolution_tendsto_right_of_continuous /-
 /-- Special case of `cont_diff_bump.convolution_tendsto_right` where `g` is continuous,
   and the limit is taken only in the first function. -/
 theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι}
@@ -1097,6 +1234,7 @@ theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (
   convolution_tendsto_right hφ (eventually_of_forall fun _ => hg.AEStronglyMeasurable)
     ((hg.Tendsto x₀).comp tendsto_snd) tendsto_const_nhds
 #align cont_diff_bump.convolution_tendsto_right_of_continuous ContDiffBump.convolution_tendsto_right_of_continuous
+-/
 
 end ContDiffBump
 
@@ -1144,6 +1282,7 @@ variable [AddGroup G]
 
 variable [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ]
 
+#print integral_convolution /-
 theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace ℝ E]
     [NormedSpace ℝ E'] [CompleteSpace E] [CompleteSpace E'] (hf : Integrable f ν)
     (hg : Integrable g μ) : ∫ x, (f ⋆[L, ν] g) x ∂μ = L (∫ x, f x ∂ν) (∫ x, g x ∂μ) :=
@@ -1152,9 +1291,11 @@ theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace
   simp_rw [integral_comp_comm _ (hg.comp_sub_right _), integral_sub_right_eq_self]
   exact (L.flip (∫ x, g x ∂μ)).integral_comp_comm hf
 #align integral_convolution integral_convolution
+-/
 
 variable [MeasurableAdd₂ G] [IsAddRightInvariant ν] [MeasurableNeg G]
 
+#print convolution_assoc' /-
 /-- Convolution is associative. This has a weak but inconvenient integrability condition.
 See also `convolution_assoc`. -/
 theorem convolution_assoc' (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z = L₃ x (L₄ y z))
@@ -1182,7 +1323,9 @@ theorem convolution_assoc' (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z
       exact (L₃ (f t)).integral_comp_comm ht
     _ = (f ⋆[L₃, ν] g ⋆[L₄, μ] k) x₀ := rfl
 #align convolution_assoc' convolution_assoc'
+-/
 
+#print convolution_assoc /-
 /-- Convolution is associative. This requires that
 * all maps are a.e. strongly measurable w.r.t one of the measures
 * `f ⋆[L, ν] g` exists almost everywhere
@@ -1241,11 +1384,13 @@ theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z =
       apply L₄.le_op_norm₂
     exact integral_nonneg fun x => norm_nonneg _
 #align convolution_assoc convolution_assoc
+-/
 
 end Assoc
 
 variable [NormedAddCommGroup G] [BorelSpace G]
 
+#print convolution_precompR_apply /-
 theorem convolution_precompR_apply {g : G → E'' →L[𝕜] E'} (hf : LocallyIntegrable f μ)
     (hcg : HasCompactSupport g) (hg : Continuous g) (x₀ : G) (x : E'') :
     (f ⋆[L.precompR E'', μ] g) x₀ x = (f ⋆[L, μ] fun a => g a x) x₀ :=
@@ -1254,9 +1399,11 @@ theorem convolution_precompR_apply {g : G → E'' →L[𝕜] E'} (hf : LocallyIn
   simp_rw [convolution_def, ContinuousLinearMap.integral_apply this]
   rfl
 #align convolution_precompR_apply convolution_precompR_apply
+-/
 
 variable [NormedSpace 𝕜 G] [SigmaFinite μ] [IsAddLeftInvariant μ]
 
+#print HasCompactSupport.hasFDerivAt_convolution_right /-
 /-- Compute the total derivative of `f ⋆ g` if `g` is `C^1` with compact support and `f` is locally
 integrable. To write down the total derivative as a convolution, we use
 `continuous_linear_map.precompR`. -/
@@ -1296,7 +1443,9 @@ theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport
     exact ((hf.integrable_on_is_compact hK').norm.const_mul _).mul_const _
   · exact eventually_of_forall fun t x hx => (L _).HasFDerivAt.comp x (h3 x t)
 #align has_compact_support.has_fderiv_at_convolution_right HasCompactSupport.hasFDerivAt_convolution_right
+-/
 
+#print HasCompactSupport.hasFDerivAt_convolution_left /-
 theorem HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
     (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 1 f) (hg : LocallyIntegrable g μ) (x₀ : G) :
     HasFDerivAt (f ⋆[L, μ] g) ((fderiv 𝕜 f ⋆[L.precompL G, μ] g) x₀) x₀ :=
@@ -1304,6 +1453,7 @@ theorem HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
   simp (config := { singlePass := true }) only [← convolution_flip]
   exact hcf.has_fderiv_at_convolution_right L.flip hg hf x₀
 #align has_compact_support.has_fderiv_at_convolution_left HasCompactSupport.hasFDerivAt_convolution_left
+-/
 
 end IsROrC
 
@@ -1332,6 +1482,7 @@ variable {μ : Measure 𝕜}
 
 variable [IsAddLeftInvariant μ] [SigmaFinite μ]
 
+#print HasCompactSupport.hasDerivAt_convolution_right /-
 theorem HasCompactSupport.hasDerivAt_convolution_right (hf : LocallyIntegrable f₀ μ)
     (hcg : HasCompactSupport g₀) (hg : ContDiff 𝕜 1 g₀) (x₀ : 𝕜) :
     HasDerivAt (f₀ ⋆[L, μ] g₀) ((f₀ ⋆[L, μ] deriv g₀) x₀) x₀ :=
@@ -1340,7 +1491,9 @@ theorem HasCompactSupport.hasDerivAt_convolution_right (hf : LocallyIntegrable f
   rw [convolution_precompR_apply L hf (hcg.fderiv 𝕜) (hg.continuous_fderiv le_rfl)]
   rfl
 #align has_compact_support.has_deriv_at_convolution_right HasCompactSupport.hasDerivAt_convolution_right
+-/
 
+#print HasCompactSupport.hasDerivAt_convolution_left /-
 theorem HasCompactSupport.hasDerivAt_convolution_left [IsNegInvariant μ]
     (hcf : HasCompactSupport f₀) (hf : ContDiff 𝕜 1 f₀) (hg : LocallyIntegrable g₀ μ) (x₀ : 𝕜) :
     HasDerivAt (f₀ ⋆[L, μ] g₀) ((deriv f₀ ⋆[L, μ] g₀) x₀) x₀ :=
@@ -1348,6 +1501,7 @@ theorem HasCompactSupport.hasDerivAt_convolution_left [IsNegInvariant μ]
   simp (config := { singlePass := true }) only [← convolution_flip]
   exact hcf.has_deriv_at_convolution_right L.flip hg hf x₀
 #align has_compact_support.has_deriv_at_convolution_left HasCompactSupport.hasDerivAt_convolution_left
+-/
 
 end Real
 
@@ -1367,6 +1521,7 @@ variable [IsROrC 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 
 /- ./././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 hasFDerivAt_convolution_right_with_param /-
 /-- The derivative of the convolution `f * g` is given by `f * Dg`, when `f` is locally integrable
 and `g` is `C^1` and compactly supported. Version where `g` depends on an additional parameter in an
 open subset `s` of a parameter space `P` (and the compact support `k` is independent of the
@@ -1448,7 +1603,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     by
     filter_upwards [A' q₀ hq₀]
     rintro ⟨p, x⟩ ⟨hp, hx⟩
-    refine' (HasCompactSupport.convolutionExistsRight L _ hf (A _ hp) _).1
+    refine' (HasCompactSupport.convolutionExists_right L _ hf (A _ hp) _).1
     apply isCompact_of_isClosed_subset hk (isClosed_tsupport _)
     exact closure_minimal (support_subset_iff'.2 fun z hz => hgs _ _ hp hz) hk.is_closed
   have I2 : integrable (fun a : G => L (f a) (g q₀.1 (q₀.2 - a))) μ :=
@@ -1459,7 +1614,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     by
     have T : HasCompactSupport fun y => g' (q₀.1, y) :=
       HasCompactSupport.intro hk fun x hx => g'_zero q₀.1 x hq₀ hx
-    apply (HasCompactSupport.convolutionExistsRight (L.precompR (P × G) : _) T hf _ q₀.2).1
+    apply (HasCompactSupport.convolutionExists_right (L.precompR (P × G) : _) T hf _ q₀.2).1
     have : ContinuousOn g' (s ×ˢ univ) :=
       hg.continuous_on_fderiv_of_open (hs.prod isOpen_univ) le_rfl
     apply this.comp_continuous (continuous_const.prod_mk continuous_id')
@@ -1529,10 +1684,12 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     exact Z.comp x Z'
   exact hasFDerivAt_integral_of_dominated_of_fderiv_le δpos I1 I2 I3 I4 I5 I6
 #align has_fderiv_at_convolution_right_with_param hasFDerivAt_convolution_right_with_param
+-/
 
 /- ./././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 contDiffOn_convolution_right_with_param_aux /-
 /-- The convolution `f * g` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`).
@@ -1588,11 +1745,13 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
     intro n
     exact ih n L hgs (hg n)
 #align cont_diff_on_convolution_right_with_param_aux contDiffOn_convolution_right_with_param_aux
+-/
 
 /- ./././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 -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print contDiffOn_convolution_right_with_param /-
 /-- The convolution `f * g` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`). -/
@@ -1666,8 +1825,10 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
   simp_rw [this] at A 
   exact A
 #align cont_diff_on_convolution_right_with_param contDiffOn_convolution_right_with_param
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print contDiffOn_convolution_right_with_param_comp /-
 /-- The convolution `f * g` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
@@ -1681,9 +1842,11 @@ theorem contDiffOn_convolution_right_with_param_comp {n : ℕ∞} (L : E →L[
   intro x hx
   simp only [hx, mem_preimage, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, id.def]
 #align cont_diff_on_convolution_right_with_param_comp contDiffOn_convolution_right_with_param_comp
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print contDiffOn_convolution_left_with_param /-
 /-- The convolution `g * f` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`). -/
@@ -1694,8 +1857,10 @@ theorem contDiffOn_convolution_left_with_param [μ.IsAddLeftInvariant] [μ.IsNeg
     ContDiffOn 𝕜 n (fun q : P × G => (g q.1 ⋆[L, μ] f) q.2) (s ×ˢ univ) := by
   simpa only [convolution_flip] using contDiffOn_convolution_right_with_param L.flip hs hk hgs hf hg
 #align cont_diff_on_convolution_left_with_param contDiffOn_convolution_left_with_param
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print contDiffOn_convolution_left_with_param_comp /-
 /-- The convolution `g * f` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
@@ -1710,7 +1875,9 @@ theorem contDiffOn_convolution_left_with_param_comp [μ.IsAddLeftInvariant] [μ.
   intro x hx
   simp only [hx, mem_preimage, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, id.def]
 #align cont_diff_on_convolution_left_with_param_comp contDiffOn_convolution_left_with_param_comp
+-/
 
+#print HasCompactSupport.contDiff_convolution_right /-
 theorem HasCompactSupport.contDiff_convolution_right {n : ℕ∞} (hcg : HasCompactSupport g)
     (hf : LocallyIntegrable f μ) (hg : ContDiff 𝕜 n g) : ContDiff 𝕜 n (f ⋆[L, μ] g) :=
   by
@@ -1720,12 +1887,15 @@ theorem HasCompactSupport.contDiff_convolution_right {n : ℕ∞} (hcg : HasComp
     contDiffOn_convolution_right_with_param_comp L contDiffOn_id isOpen_univ hk
       (fun p x hp hx => h'k x hx) hf (hg.comp contDiff_snd).ContDiffOn
 #align has_compact_support.cont_diff_convolution_right HasCompactSupport.contDiff_convolution_right
+-/
 
+#print HasCompactSupport.contDiff_convolution_left /-
 theorem HasCompactSupport.contDiff_convolution_left [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
     {n : ℕ∞} (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 n f) (hg : LocallyIntegrable g μ) :
     ContDiff 𝕜 n (f ⋆[L, μ] g) := by rw [← convolution_flip];
   exact hcf.cont_diff_convolution_right L.flip hg hf
 #align has_compact_support.cont_diff_convolution_left HasCompactSupport.contDiff_convolution_left
+-/
 
 end WithParam
 
@@ -1733,6 +1903,7 @@ section Nonneg
 
 variable [NormedSpace ℝ E] [NormedSpace ℝ E'] [NormedSpace ℝ F] [CompleteSpace F]
 
+#print posConvolution /-
 /-- The forward convolution of two functions `f` and `g` on `ℝ`, with respect to a continuous
 bilinear map `L` and measure `ν`. It is defined to be the function mapping `x` to
 `∫ t in 0..x, L (f t) (g (x - t)) ∂ν` if `0 < x`, and 0 otherwise. -/
@@ -1740,7 +1911,9 @@ noncomputable def posConvolution (f : ℝ → E) (g : ℝ → E') (L : E →L[
     (ν : Measure ℝ := by exact MeasureTheory.MeasureSpace.volume) : ℝ → F :=
   indicator (Ioi (0 : ℝ)) fun x => ∫ t in 0 ..x, L (f t) (g (x - t)) ∂ν
 #align pos_convolution posConvolution
+-/
 
+#print posConvolution_eq_convolution_indicator /-
 theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E') (L : E →L[ℝ] E' →L[ℝ] F)
     (ν : Measure ℝ := by exact MeasureTheory.MeasureSpace.volume) [NoAtoms ν] :
     posConvolution f g L ν = convolution (indicator (Ioi 0) f) (indicator (Ioi 0) g) L ν :=
@@ -1777,7 +1950,9 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
       rw [indicator_of_not_mem (mem_Ioi.not.mpr ht), ContinuousLinearMap.map_zero,
         ContinuousLinearMap.zero_apply]
 #align pos_convolution_eq_convolution_indicator posConvolution_eq_convolution_indicator
+-/
 
+#print integrable_posConvolution /-
 theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measure ℝ} [SigmaFinite μ]
     [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
     (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
@@ -1787,10 +1962,12 @@ theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Meas
   rw [posConvolution_eq_convolution_indicator f g L ν]
   exact (hf.convolution_integrand L hg).integral_prod_left
 #align integrable_pos_convolution integrable_posConvolution
+-/
 
+#print integral_posConvolution /-
 /-- The integral over `Ioi 0` of a forward convolution of two functions is equal to the product
 of their integrals over this set. (Compare `integral_convolution` for the two-sided convolution.) -/
-theorem integral_pos_convolution [CompleteSpace E] [CompleteSpace E'] {μ ν : Measure ℝ}
+theorem integral_posConvolution [CompleteSpace E] [CompleteSpace E'] {μ ν : Measure ℝ}
     [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
     (hf : IntegrableOn f (Ioi 0) ν) (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     ∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0 ..x, L (f t) (g (x - t)) ∂ν ∂μ =
@@ -1800,7 +1977,8 @@ theorem integral_pos_convolution [CompleteSpace E] [CompleteSpace E'] {μ ν : M
   simp_rw [← integral_indicator measurableSet_Ioi]
   convert integral_convolution L hf hg using 2
   apply posConvolution_eq_convolution_indicator
-#align integral_pos_convolution integral_pos_convolution
+#align integral_pos_convolution integral_posConvolution
+-/
 
 end Nonneg
 

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

@@ -463,14 +463,11 @@ noncomputable def convolution [Sub G] (f : G → E) (g : G → E') (L : E →L[
   ∫ t, L (f t) (g (x - t)) ∂μ
 #align convolution convolution
 
--- mathport name: convolution
 scoped[convolution] notation:67 f " ⋆[" L:67 ", " μ:67 "] " g:66 => convolution f g L μ
 
--- mathport name: convolution.volume
 scoped[convolution]
   notation:67 f " ⋆[" L:67 "]" g:66 => convolution f g L MeasureTheory.MeasureSpace.volume
 
--- mathport name: convolution.lsmul
 scoped[convolution]
   notation:67 f " ⋆ " g:66 =>
     convolution f g (ContinuousLinearMap.lsmul ℝ ℝ) MeasureTheory.MeasureSpace.volume

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

@@ -865,7 +865,7 @@ theorem convolution_mul_swap [NormedSpace ℝ 𝕜] [CompleteSpace 𝕜] {f : G
 theorem convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀ᵐ x ∂μ, g (-x) = g x) :
     (f ⋆[L, μ] g) (-x) = (f ⋆[L, μ] g) x :=
   calc
-    (∫ t : G, (L (f t)) (g (-x - t)) ∂μ) = ∫ t : G, (L (f (-t))) (g (x + t)) ∂μ :=
+    ∫ t : G, (L (f t)) (g (-x - t)) ∂μ = ∫ t : G, (L (f (-t))) (g (x + t)) ∂μ :=
       by
       apply integral_congr_ae
       filter_upwards [h1, (eventually_add_left_iff μ x).2 h2] with t ht h't
@@ -981,7 +981,7 @@ on a ball with the same radius around `x₀`.
 This is a special case of `dist_convolution_le'` where `L` is `(•)`, `f` has integral 1 and `f` is
 nonnegative. -/
 theorem dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε)
-    (hf : support f ⊆ ball (0 : G) R) (hnf : ∀ x, 0 ≤ f x) (hintf : (∫ x, f x ∂μ) = 1)
+    (hf : support f ⊆ ball (0 : G) R) (hnf : ∀ x, 0 ≤ f x) (hintf : ∫ x, f x ∂μ = 1)
     (hmg : AEStronglyMeasurable g μ) (hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
     dist ((f ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) z₀ ≤ ε :=
   by
@@ -1004,7 +1004,7 @@ See also `cont_diff_bump.convolution_tendsto_right`.
 -/
 theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x₀ : G} {z₀ : E'}
     {φ : ι → G → ℝ} {k : ι → G} (hnφ : ∀ᶠ i in l, ∀ x, 0 ≤ φ i x)
-    (hiφ : ∀ᶠ i in l, (∫ x, φ i x ∂μ) = 1)
+    (hiφ : ∀ᶠ i in l, ∫ x, φ i x ∂μ = 1)
     -- todo: we could weaken this to "the integral tends to 1"
     (hφ : Tendsto (fun n => support (φ n)) l (𝓝 0).smallSets)
     (hmg : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ᶠ 𝓝 x₀) (𝓝 z₀))
@@ -1149,7 +1149,7 @@ variable [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ]
 
 theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace ℝ E]
     [NormedSpace ℝ E'] [CompleteSpace E] [CompleteSpace E'] (hf : Integrable f ν)
-    (hg : Integrable g μ) : (∫ x, (f ⋆[L, ν] g) x ∂μ) = L (∫ x, f x ∂ν) (∫ x, g x ∂μ) :=
+    (hg : Integrable g μ) : ∫ x, (f ⋆[L, ν] g) x ∂μ = L (∫ x, f x ∂ν) (∫ x, g x ∂μ) :=
   by
   refine' (integral_integral_swap (by apply hf.convolution_integrand L hg)).trans _
   simp_rw [integral_comp_comm _ (hg.comp_sub_right _), integral_sub_right_eq_self]
@@ -1796,7 +1796,7 @@ of their integrals over this set. (Compare `integral_convolution` for the two-si
 theorem integral_pos_convolution [CompleteSpace E] [CompleteSpace E'] {μ ν : Measure ℝ}
     [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
     (hf : IntegrableOn f (Ioi 0) ν) (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
-    (∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0 ..x, L (f t) (g (x - t)) ∂ν ∂μ) =
+    ∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0 ..x, L (f t) (g (x - t)) ∂ν ∂μ =
       L (∫ x : ℝ in Ioi 0, f x ∂ν) (∫ x : ℝ in Ioi 0, g x ∂μ) :=
   by
   rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg 

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

@@ -872,7 +872,6 @@ theorem convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀
       simp_rw [ht, ← h't, neg_add']
     _ = ∫ t : G, (L (f t)) (g (x - t)) ∂μ := by rw [← integral_neg_eq_self];
       simp only [neg_neg, ← sub_eq_add_neg]
-    
 #align convolution_neg_of_neg_eq convolution_neg_of_neg_eq
 
 end Measurable
@@ -1185,7 +1184,6 @@ theorem convolution_assoc' (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z
         ((quasi_measure_preserving_sub_left_of_right_invariant ν x₀).ae hgk).mono fun t ht => _
       exact (L₃ (f t)).integral_comp_comm ht
     _ = (f ⋆[L₃, ν] g ⋆[L₄, μ] k) x₀ := rfl
-    
 #align convolution_assoc' convolution_assoc'
 
 /-- Convolution is associative. This requires that

mathlib commit https://github.com/leanprover-community/mathlib/commit/58a272265b5e05f258161260dd2c5d247213cbd3

@@ -1048,7 +1048,7 @@ variable [CompleteSpace E']
 variable {a : G} {φ : ContDiffBump (0 : G)}
 
 /-- If `φ` is a bump function, compute `(φ ⋆ g) x₀` if `g` is constant on `metric.ball x₀ φ.R`. -/
-theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.r, g x = g x₀) :
+theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :
     (φ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = integral μ φ • g x₀ := by
   simp_rw [convolution_eq_right' _ φ.support_eq.subset hg, lsmul_apply, integral_smul_const]
 #align cont_diff_bump.convolution_eq_right ContDiffBump.convolution_eq_right
@@ -1060,7 +1060,7 @@ variable [IsLocallyFiniteMeasure μ] [IsOpenPosMeasure μ]
 variable [FiniteDimensional ℝ G]
 
 /-- If `φ` is a normed bump function, compute `φ ⋆ g` if `g` is constant on `metric.ball x₀ φ.R`. -/
-theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.r, g x = g x₀) :
+theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :
     (φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = g x₀ :=
   by
   simp_rw [convolution_eq_right' _ φ.support_normed_eq.subset hg, lsmul_apply]
@@ -1072,7 +1072,7 @@ variable [IsAddLeftInvariant μ]
 /-- If `φ` is a normed bump function, approximate `(φ ⋆ g) x₀` if `g` is near `g x₀` on a ball with
 radius `φ.R` around `x₀`. -/
 theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AEStronglyMeasurable g μ)
-    (hg : ∀ x ∈ ball x₀ φ.r, dist (g x) (g x₀) ≤ ε) :
+    (hg : ∀ x ∈ ball x₀ φ.rOut, dist (g x) (g x₀) ≤ ε) :
     dist ((φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) (g x₀) ≤ ε :=
   dist_convolution_le (by simp_rw [← dist_self (g x₀), hg x₀ (mem_ball_self φ.R_pos)])
     φ.support_normed_eq.Subset φ.nonneg_normed φ.integral_normed hmg hg
@@ -1084,7 +1084,7 @@ theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AEStronglyMeasur
 * `g i x` tends to `z₀` as `(i, x)` tends to `l ×ᶠ 𝓝 x₀`;
 * `k i` tends to `x₀`. -/
 theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)} {g : ι → G → E'} {k : ι → G}
-    {x₀ : G} {z₀ : E'} {l : Filter ι} (hφ : Tendsto (fun i => (φ i).r) l (𝓝 0))
+    {x₀ : G} {z₀ : E'} {l : Filter ι} (hφ : Tendsto (fun i => (φ i).rOut) l (𝓝 0))
     (hig : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ᶠ 𝓝 x₀) (𝓝 z₀))
     (hk : Tendsto k l (𝓝 x₀)) :
     Tendsto (fun i => ((fun x => (φ i).normed μ x) ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀) :=
@@ -1096,7 +1096,7 @@ theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)} {g : 
 /-- Special case of `cont_diff_bump.convolution_tendsto_right` where `g` is continuous,
   and the limit is taken only in the first function. -/
 theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι}
-    (hφ : Tendsto (fun i => (φ i).r) l (𝓝 0)) (hg : Continuous g) (x₀ : G) :
+    (hφ : Tendsto (fun i => (φ i).rOut) l (𝓝 0)) (hg : Continuous g) (x₀ : G) :
     Tendsto (fun i => ((fun x => (φ i).normed μ x) ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) l (𝓝 (g x₀)) :=
   convolution_tendsto_right hφ (eventually_of_forall fun _ => hg.AEStronglyMeasurable)
     ((hg.Tendsto x₀).comp tendsto_snd) tendsto_const_nhds

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

@@ -266,7 +266,7 @@ end
 
 section Left
 
-variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [AddRightInvariant μ]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd (hf : AEStronglyMeasurable f μ)
     (hg : AEStronglyMeasurable g μ) (x : G) :
@@ -297,7 +297,8 @@ end Left
 
 section Right
 
-variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [AddRightInvariant μ] [SigmaFinite ν]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
+  [SigmaFinite ν]
 
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand (hf : AEStronglyMeasurable f ν)
     (hg : AEStronglyMeasurable g μ) :
@@ -354,7 +355,8 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
     by
     apply (hg.comp v.continuous).ContinuousOn.aestronglyMeasurable_of_isCompact h
     exact (isClosed_tsupport _).MeasurableSet
-  convert((v.continuous.measurable.measure_preserving
+  convert
+    ((v.continuous.measurable.measure_preserving
               (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aestronglyMeasurable_comp_iff
           v.to_measurable_equiv.measurable_embedding).1
       A
@@ -392,7 +394,7 @@ variable [AddCommGroup G]
 
 section MeasurableGroup
 
-variable [MeasurableNeg G] [AddLeftInvariant μ]
+variable [MeasurableNeg G] [IsAddLeftInvariant μ]
 
 /-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
 We assume that the integrand has compact support and `g` is bounded on this support (note that
@@ -415,7 +417,7 @@ theorem BddAbove.convolutionExistsAt [MeasurableAdd₂ G] [SigmaFinite μ] {x₀
       map_mono_of_ae_measurable restrict_le_self (measurable_const.sub measurable_id').AEMeasurable
 #align bdd_above.convolution_exists_at BddAbove.convolutionExistsAt
 
-variable {L} [MeasurableAdd G] [NegInvariant μ]
+variable {L} [MeasurableAdd G] [IsNegInvariant μ]
 
 theorem convolutionExistsAt_flip :
     ConvolutionExistsAt g f x L.flip μ ↔ ConvolutionExistsAt f g x L μ := by
@@ -435,8 +437,8 @@ theorem convolutionExistsAt_iff_integrable_swap :
 
 end MeasurableGroup
 
-variable [TopologicalSpace G] [TopologicalAddGroup G] [BorelSpace G] [AddLeftInvariant μ]
-  [NegInvariant μ]
+variable [TopologicalSpace G] [TopologicalAddGroup G] [BorelSpace G] [IsAddLeftInvariant μ]
+  [IsNegInvariant μ]
 
 theorem HasCompactSupport.convolutionExistsLeft (hcf : HasCompactSupport f) (hf : Continuous f)
     (hg : LocallyIntegrable g μ) : ConvolutionExists f g L μ := fun x₀ =>
@@ -557,8 +559,8 @@ theorem convolution_mono_right_of_nonneg {f g g' : G → ℝ}
 
 variable (L)
 
-theorem convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [AddRightInvariant μ]
-    (h1 : f =ᵐ[μ] f') (h2 : g =ᵐ[μ] g') : f ⋆[L, μ] g = f' ⋆[L, μ] g' :=
+theorem convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ]
+    [IsAddRightInvariant μ] (h1 : f =ᵐ[μ] f') (h2 : g =ᵐ[μ] g') : f ⋆[L, μ] g = f' ⋆[L, μ] g' :=
   by
   ext x
   apply integral_congr_ae
@@ -586,7 +588,7 @@ theorem support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g
 
 section
 
-variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [AddRightInvariant μ]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
 theorem MeasureTheory.Integrable.integrable_convolution (hf : Integrable f μ)
     (hg : Integrable g μ) : Integrable (f ⋆[L, μ] g) μ :=
@@ -823,7 +825,7 @@ theorem support_convolution_subset : support (f ⋆[L, μ] g) ⊆ support f + su
   (support_convolution_subset_swap L).trans (add_comm _ _).Subset
 #align support_convolution_subset support_convolution_subset
 
-variable [AddLeftInvariant μ] [NegInvariant μ]
+variable [IsAddLeftInvariant μ] [IsNegInvariant μ]
 
 section Measurable
 
@@ -866,7 +868,7 @@ theorem convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀
     (∫ t : G, (L (f t)) (g (-x - t)) ∂μ) = ∫ t : G, (L (f (-t))) (g (x + t)) ∂μ :=
       by
       apply integral_congr_ae
-      filter_upwards [h1, (eventually_add_left_iff μ x).2 h2]with t ht h't
+      filter_upwards [h1, (eventually_add_left_iff μ x).2 h2] with t ht h't
       simp_rw [ht, ← h't, neg_add']
     _ = ∫ t : G, (L (f t)) (g (x - t)) ∂μ := by rw [← integral_neg_eq_self];
       simp only [neg_neg, ← sub_eq_add_neg]
@@ -922,7 +924,7 @@ theorem convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 :
 
 variable [BorelSpace G] [SecondCountableTopology G]
 
-variable [AddLeftInvariant μ] [SigmaFinite μ]
+variable [IsAddLeftInvariant μ] [SigmaFinite μ]
 
 /-- Approximate `(f ⋆ g) x₀` if the support of the `f` is bounded within a ball, and `g` is near
 `g x₀` on a ball with the same radius around `x₀`. See `dist_convolution_le` for a special case.
@@ -986,7 +988,7 @@ theorem dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'}
   by
   have hif : integrable f μ := by by_contra hif;
     exact zero_ne_one ((integral_undef hif).symm.trans hintf)
-  convert(dist_convolution_le' _ hε hif hf hmg hg).trans _
+  convert (dist_convolution_le' _ hε hif hf hmg hg).trans _
   · simp_rw [lsmul_apply, integral_smul_const, hintf, one_smul]
   · simp_rw [Real.norm_of_nonneg (hnf _), hintf, mul_one]
     exact (mul_le_mul_of_nonneg_right op_norm_lsmul_le hε).trans_eq (one_mul ε)
@@ -1019,7 +1021,7 @@ theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x
   dsimp only [uncurry] at hgδ 
   have h2k := hk.eventually (ball_mem_nhds x₀ <| half_pos hδ)
   have h2φ := hφ (ball (0 : G) _) <| ball_mem_nhds _ (half_pos hδ)
-  filter_upwards [hp, h2k, h2φ, hnφ, hiφ, hmg]with i hpi hki hφi hnφi hiφi hmgi
+  filter_upwards [hp, h2k, h2φ, hnφ, hiφ, hmg] with i hpi hki hφi hnφi hiφi hmgi
   have hgi : dist (g i (k i)) z₀ < ε / 3 := hgδ hpi (hki.trans <| half_lt_self hδ)
   have h1 : ∀ x' ∈ ball (k i) (δ / 2), dist (g i x') (g i (k i)) ≤ ε / 3 + ε / 3 :=
     by
@@ -1053,7 +1055,7 @@ theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.r, g x = g
 
 variable [BorelSpace G]
 
-variable [LocallyFiniteMeasure μ] [OpenPosMeasure μ]
+variable [IsLocallyFiniteMeasure μ] [IsOpenPosMeasure μ]
 
 variable [FiniteDimensional ℝ G]
 
@@ -1065,7 +1067,7 @@ theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.r, g
   exact integral_normed_smul φ μ (g x₀)
 #align cont_diff_bump.normed_convolution_eq_right ContDiffBump.normed_convolution_eq_right
 
-variable [AddLeftInvariant μ]
+variable [IsAddLeftInvariant μ]
 
 /-- If `φ` is a normed bump function, approximate `(φ ⋆ g) x₀` if `g` is near `g x₀` on a ball with
 radius `φ.R` around `x₀`. -/
@@ -1144,7 +1146,7 @@ variable (L₄ : E' →L[𝕜] E'' →L[𝕜] F'')
 
 variable [AddGroup G]
 
-variable [SigmaFinite μ] [SigmaFinite ν] [AddRightInvariant μ]
+variable [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ]
 
 theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace ℝ E]
     [NormedSpace ℝ E'] [CompleteSpace E] [CompleteSpace E'] (hf : Integrable f ν)
@@ -1155,7 +1157,7 @@ theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace
   exact (L.flip (∫ x, g x ∂μ)).integral_comp_comm hf
 #align integral_convolution integral_convolution
 
-variable [MeasurableAdd₂ G] [AddRightInvariant ν] [MeasurableNeg G]
+variable [MeasurableAdd₂ G] [IsAddRightInvariant ν] [MeasurableNeg G]
 
 /-- Convolution is associative. This has a weak but inconvenient integrability condition.
 See also `convolution_assoc`. -/
@@ -1258,7 +1260,7 @@ theorem convolution_precompR_apply {g : G → E'' →L[𝕜] E'} (hf : LocallyIn
   rfl
 #align convolution_precompR_apply convolution_precompR_apply
 
-variable [NormedSpace 𝕜 G] [SigmaFinite μ] [AddLeftInvariant μ]
+variable [NormedSpace 𝕜 G] [SigmaFinite μ] [IsAddLeftInvariant μ]
 
 /-- Compute the total derivative of `f ⋆ g` if `g` is `C^1` with compact support and `f` is locally
 integrable. To write down the total derivative as a convolution, we use
@@ -1300,8 +1302,8 @@ theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport
   · exact eventually_of_forall fun t x hx => (L _).HasFDerivAt.comp x (h3 x t)
 #align has_compact_support.has_fderiv_at_convolution_right HasCompactSupport.hasFDerivAt_convolution_right
 
-theorem HasCompactSupport.hasFDerivAt_convolution_left [NegInvariant μ] (hcf : HasCompactSupport f)
-    (hf : ContDiff 𝕜 1 f) (hg : LocallyIntegrable g μ) (x₀ : G) :
+theorem HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
+    (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 1 f) (hg : LocallyIntegrable g μ) (x₀ : G) :
     HasFDerivAt (f ⋆[L, μ] g) ((fderiv 𝕜 f ⋆[L.precompL G, μ] g) x₀) x₀ :=
   by
   simp (config := { singlePass := true }) only [← convolution_flip]
@@ -1333,19 +1335,19 @@ variable [CompleteSpace F]
 
 variable {μ : Measure 𝕜}
 
-variable [AddLeftInvariant μ] [SigmaFinite μ]
+variable [IsAddLeftInvariant μ] [SigmaFinite μ]
 
 theorem HasCompactSupport.hasDerivAt_convolution_right (hf : LocallyIntegrable f₀ μ)
     (hcg : HasCompactSupport g₀) (hg : ContDiff 𝕜 1 g₀) (x₀ : 𝕜) :
     HasDerivAt (f₀ ⋆[L, μ] g₀) ((f₀ ⋆[L, μ] deriv g₀) x₀) x₀ :=
   by
-  convert(hcg.has_fderiv_at_convolution_right L hf hg x₀).HasDerivAt
+  convert (hcg.has_fderiv_at_convolution_right L hf hg x₀).HasDerivAt
   rw [convolution_precompR_apply L hf (hcg.fderiv 𝕜) (hg.continuous_fderiv le_rfl)]
   rfl
 #align has_compact_support.has_deriv_at_convolution_right HasCompactSupport.hasDerivAt_convolution_right
 
-theorem HasCompactSupport.hasDerivAt_convolution_left [NegInvariant μ] (hcf : HasCompactSupport f₀)
-    (hf : ContDiff 𝕜 1 f₀) (hg : LocallyIntegrable g₀ μ) (x₀ : 𝕜) :
+theorem HasCompactSupport.hasDerivAt_convolution_left [IsNegInvariant μ]
+    (hcf : HasCompactSupport f₀) (hf : ContDiff 𝕜 1 f₀) (hg : LocallyIntegrable g₀ μ) (x₀ : 𝕜) :
     HasDerivAt (f₀ ⋆[L, μ] g₀) ((deriv f₀ ⋆[L, μ] g₀) x₀) x₀ :=
   by
   simp (config := { singlePass := true }) only [← convolution_flip]
@@ -1690,7 +1692,7 @@ theorem contDiffOn_convolution_right_with_param_comp {n : ℕ∞} (L : E →L[
 /-- The convolution `g * f` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`). -/
-theorem contDiffOn_convolution_left_with_param [μ.AddLeftInvariant] [μ.NegInvariant]
+theorem contDiffOn_convolution_left_with_param [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
     (L : E' →L[𝕜] E →L[𝕜] F) {f : G → E} {n : ℕ∞} {g : P → G → E'} {s : Set P} {k : Set G}
     (hs : IsOpen s) (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
     (hf : LocallyIntegrable f μ) (hg : ContDiffOn 𝕜 n (↿g) (s ×ˢ univ)) :
@@ -1703,7 +1705,7 @@ theorem contDiffOn_convolution_left_with_param [μ.AddLeftInvariant] [μ.NegInva
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
 given in terms of composition with additional smooth functions. -/
-theorem contDiffOn_convolution_left_with_param_comp [μ.AddLeftInvariant] [μ.NegInvariant]
+theorem contDiffOn_convolution_left_with_param_comp [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
     (L : E' →L[𝕜] E →L[𝕜] F) {s : Set P} {n : ℕ∞} {v : P → G} (hv : ContDiffOn 𝕜 n v s) {f : G → E}
     {g : P → G → E'} {k : Set G} (hs : IsOpen s) (hk : IsCompact k)
     (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
@@ -1724,8 +1726,8 @@ theorem HasCompactSupport.contDiff_convolution_right {n : ℕ∞} (hcg : HasComp
       (fun p x hp hx => h'k x hx) hf (hg.comp contDiff_snd).ContDiffOn
 #align has_compact_support.cont_diff_convolution_right HasCompactSupport.contDiff_convolution_right
 
-theorem HasCompactSupport.contDiff_convolution_left [μ.AddLeftInvariant] [μ.NegInvariant] {n : ℕ∞}
-    (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 n f) (hg : LocallyIntegrable g μ) :
+theorem HasCompactSupport.contDiff_convolution_left [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
+    {n : ℕ∞} (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 n f) (hg : LocallyIntegrable g μ) :
     ContDiff 𝕜 n (f ⋆[L, μ] g) := by rw [← convolution_flip];
   exact hcf.cont_diff_convolution_right L.flip hg hf
 #align has_compact_support.cont_diff_convolution_left HasCompactSupport.contDiff_convolution_left
@@ -1770,7 +1772,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
     ·
       rw [indicator_of_not_mem (not_mem_Ioo_of_ge ht),
         indicator_of_not_mem (not_mem_Ioi.mpr (sub_nonpos_of_le ht)), ContinuousLinearMap.map_zero]
-  · convert(integral_zero ℝ F).symm
+  · convert (integral_zero ℝ F).symm
     ext1 t
     by_cases ht : 0 < t
     · rw [indicator_of_not_mem (_ : x - t ∉ Ioi 0), ContinuousLinearMap.map_zero]
@@ -1782,7 +1784,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
 #align pos_convolution_eq_convolution_indicator posConvolution_eq_convolution_indicator
 
 theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measure ℝ} [SigmaFinite μ]
-    [SigmaFinite ν] [AddRightInvariant μ] [NoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
+    [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
     (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     Integrable (posConvolution f g L ν) μ :=
   by
@@ -1794,7 +1796,7 @@ theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Meas
 /-- The integral over `Ioi 0` of a forward convolution of two functions is equal to the product
 of their integrals over this set. (Compare `integral_convolution` for the two-sided convolution.) -/
 theorem integral_pos_convolution [CompleteSpace E] [CompleteSpace E'] {μ ν : Measure ℝ}
-    [SigmaFinite μ] [SigmaFinite ν] [AddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
+    [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
     (hf : IntegrableOn f (Ioi 0) ν) (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     (∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0 ..x, L (f t) (g (x - t)) ∂ν ∂μ) =
       L (∫ x : ℝ in Ioi 0, f x ∂ν) (∫ x : ℝ in Ioi 0, g x ∂μ) :=

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

@@ -574,7 +574,7 @@ theorem support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g
   intro x h2x
   by_contra hx
   apply h2x
-  simp_rw [Set.mem_add, not_exists, not_and_or, nmem_support] at hx
+  simp_rw [Set.mem_add, not_exists, not_and_or, nmem_support] at hx 
   rw [convolution_def]
   convert integral_zero G F
   ext t
@@ -660,7 +660,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     obtain ⟨w, w_open, q₀w, hw⟩ : ∃ w, IsOpen w ∧ q₀.1 ∈ w ∧ w ×ˢ k ⊆ t :=
       by
       obtain ⟨w, v, w_open, v_open, hw, hv, hvw⟩ :
-        ∃ (w : Set P)(v : Set G), IsOpen w ∧ IsOpen v ∧ {q₀.fst} ⊆ w ∧ k ⊆ v ∧ w ×ˢ v ⊆ t
+        ∃ (w : Set P) (v : Set G), IsOpen w ∧ IsOpen v ∧ {q₀.fst} ⊆ w ∧ k ⊆ v ∧ w ×ˢ v ⊆ t
       exact generalized_tube_lemma isCompact_singleton hk t_open kt
       exact ⟨w, w_open, singleton_subset_iff.1 hw, subset.trans (Set.prod_mono subset.rfl hv) hvw⟩
     refine' ⟨w, C, w_open, q₀w, Cpos.le, _⟩
@@ -672,7 +672,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
       have H' : (p, x) ∈ (s ×ˢ univ : Set (P × G)) := by
         simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff] using hps
       have : g p x ∈ closed_ball (0 : E') C := hC (mem_image_of_mem _ ⟨H, H'⟩)
-      rwa [mem_closedBall_zero_iff] at this
+      rwa [mem_closedBall_zero_iff] at this 
     · have : g p x = 0 := hgs _ _ hps hx
       rw [this]
       simpa only [norm_zero] using Cpos.le
@@ -691,7 +691,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
   let bound : G → ℝ := indicator U fun a => ‖L‖ * ‖f a‖ * C
   have I2 : ∀ᶠ q : P × G in 𝓝[s ×ˢ univ] q₀, ∀ᵐ a ∂μ, ‖L (f a) (g q.1 (q.2 - a))‖ ≤ bound a :=
     by
-    obtain ⟨V, V_mem, hV⟩ : ∃ (V : Set G)(H : V ∈ 𝓝 (0 : G)), K' + V ⊆ U
+    obtain ⟨V, V_mem, hV⟩ : ∃ (V : Set G) (H : V ∈ 𝓝 (0 : G)), K' + V ⊆ U
     exact compact_open_separated_add_right hK' U_open K'U
     have : ((w ∩ s) ×ˢ ({q₀.2} + V) : Set (P × G)) ∈ 𝓝[s ×ˢ univ] q₀ :=
       by
@@ -700,7 +700,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
       exact mem_nhdsWithin_iff_exists_mem_nhds_inter.2 ⟨w, w_open.mem_nhds q₀w, subset.rfl⟩
     filter_upwards [this]
     rintro ⟨p, x⟩ hpx
-    simp only [prod_mk_mem_set_prod_eq] at hpx
+    simp only [prod_mk_mem_set_prod_eq] at hpx 
     apply eventually_of_forall fun a => _
     apply convolution_integrand_bound_right_of_le_of_subset _ _ hpx.2 _
     · intro x
@@ -911,11 +911,11 @@ theorem convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 :
     by
     intro t; by_cases ht : t ∈ support f
     · have h2t := hf ht
-      rw [mem_ball_zero_iff] at h2t
+      rw [mem_ball_zero_iff] at h2t 
       specialize hg (x₀ - t)
-      rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg
+      rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg 
       rw [hg h2t]
-    · rw [nmem_support] at ht
+    · rw [nmem_support] at ht 
       simp_rw [ht, L.map_zero₂]
   simp_rw [convolution_def, h2]
 #align convolution_eq_right' convolution_eq_right'
@@ -949,15 +949,15 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
     by
     intro t; by_cases ht : t ∈ support f
     · have h2t := hf ht
-      rw [mem_ball_zero_iff] at h2t
+      rw [mem_ball_zero_iff] at h2t 
       specialize hg (x₀ - t)
-      rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg
+      rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg 
       refine' ((L (f t)).dist_le_op_norm _ _).trans _
       exact mul_le_mul_of_nonneg_left (hg h2t) (norm_nonneg _)
-    · rw [nmem_support] at ht
+    · rw [nmem_support] at ht 
       simp_rw [ht, L.map_zero₂, L.map_zero, norm_zero, MulZeroClass.zero_mul, dist_self]
   simp_rw [convolution_def]
-  simp_rw [dist_eq_norm] at h2⊢
+  simp_rw [dist_eq_norm] at h2 ⊢
   rw [← integral_sub hfg.integrable]; swap; · exact (L.flip z₀).integrable_comp hif
   refine'
     (norm_integral_le_of_norm_le ((L.integrable_comp hif).norm.mul_const ε)
@@ -1010,13 +1010,13 @@ theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x
     (hk : Tendsto k l (𝓝 x₀)) :
     Tendsto (fun i : ι => (φ i ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀) :=
   by
-  simp_rw [tendsto_small_sets_iff] at hφ
-  rw [Metric.tendsto_nhds] at hcg⊢
-  simp_rw [Metric.eventually_prod_nhds_iff] at hcg
+  simp_rw [tendsto_small_sets_iff] at hφ 
+  rw [Metric.tendsto_nhds] at hcg ⊢
+  simp_rw [Metric.eventually_prod_nhds_iff] at hcg 
   intro ε hε
   have h2ε : 0 < ε / 3 := div_pos hε (by norm_num)
   obtain ⟨p, hp, δ, hδ, hgδ⟩ := hcg _ h2ε
-  dsimp only [uncurry] at hgδ
+  dsimp only [uncurry] at hgδ 
   have h2k := hk.eventually (ball_mem_nhds x₀ <| half_pos hδ)
   have h2φ := hφ (ball (0 : G) _) <| ball_mem_nhds _ (half_pos hδ)
   filter_upwards [hp, h2k, h2φ, hnφ, hiφ, hmg]with i hpi hki hφi hnφi hiφi hmgi
@@ -1172,7 +1172,7 @@ theorem convolution_assoc' (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z
     _ = ∫ s, ∫ t, L₃ (f s) (L₄ (g (t - s)) (k (x₀ - t))) ∂μ ∂ν := by rw [integral_integral_swap hi]
     _ = ∫ s, ∫ u, L₃ (f s) (L₄ (g u) (k (x₀ - s - u))) ∂μ ∂ν :=
       by
-      congr ; ext t
+      congr; ext t
       rw [eq_comm, ← integral_sub_right_eq_self _ t]
       · simp_rw [sub_sub_sub_cancel_right]
       · infer_instance
@@ -1221,7 +1221,7 @@ theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z =
     (measure_preserving_sub_prod μ ν).map_eq
   suffices integrable (uncurry fun x y => L₃ (f y) (L₄ (g x) (k (x₀ - y - x)))) (μ.prod ν)
     by
-    rw [← h3] at this
+    rw [← h3] at this 
     convert this.comp_measurable (measurable_sub.prod_mk measurable_snd)
     ext ⟨x, y⟩
     simp_rw [uncurry, Function.comp_apply, sub_sub_sub_cancel_right]
@@ -1420,7 +1420,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
       by
       obtain ⟨ε, εpos, hε⟩ : ∃ ε : ℝ, 0 < ε ∧ thickening ε ({q₀.fst} ×ˢ k) ⊆ t
       exact A.exists_thickening_subset_open t_open kt
-      obtain ⟨δ, δpos, hδ⟩ : ∃ (δ : ℝ)(H : 0 < δ), ball q₀.1 δ ⊆ s
+      obtain ⟨δ, δpos, hδ⟩ : ∃ (δ : ℝ) (H : 0 < δ), ball q₀.1 δ ⊆ s
       exact Metric.isOpen_iff.1 hs _ hq₀
       refine' ⟨min ε δ, lt_min εpos δpos, _, _⟩
       · exact subset.trans (thickening_mono (min_le_left _ _) _) hε
@@ -1435,10 +1435,10 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
         ·
           simp only [hx, singleton_prod, mem_image, Prod.mk.inj_iff, eq_self_iff_true, true_and_iff,
             exists_eq_right]
-        · rw [← dist_eq_norm] at hp
+        · rw [← dist_eq_norm] at hp 
           simpa only [Prod.dist_eq, εpos, dist_self, max_lt_iff, and_true_iff] using hp
       have : g' (p, x) ∈ closed_ball (0 : P × G →L[𝕜] E') C := hC (mem_image_of_mem _ H)
-      rwa [mem_closedBall_zero_iff] at this
+      rwa [mem_closedBall_zero_iff] at this 
     · have : g' (p, x) = 0 := g'_zero _ _ hps hx
       rw [this]
       simpa only [norm_zero] using Cpos.le
@@ -1474,7 +1474,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
   exact hf.integrable_on_nhds_is_compact hK'
   obtain ⟨δ, δpos, δε, hδ⟩ : ∃ δ, (0 : ℝ) < δ ∧ δ ≤ ε ∧ K' + ball 0 δ ⊆ U :=
     by
-    obtain ⟨V, V_mem, hV⟩ : ∃ (V : Set G)(V_mem : V ∈ 𝓝 (0 : G)), K' + V ⊆ U
+    obtain ⟨V, V_mem, hV⟩ : ∃ (V : Set G) (V_mem : V ∈ 𝓝 (0 : G)), K' + V ⊆ U
     exact compact_open_separated_add_right hK' U_open K'U
     rcases Metric.mem_nhds_iff.1 V_mem with ⟨δ, δpos, hδ⟩
     refine' ⟨min δ ε, lt_min δpos εpos, min_le_right _ _, _⟩
@@ -1486,7 +1486,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     by
     apply eventually_of_forall
     intro a x hx
-    rw [Prod.dist_eq, dist_eq_norm, dist_eq_norm] at hx
+    rw [Prod.dist_eq, dist_eq_norm, dist_eq_norm] at hx 
     have : (-tsupport fun a => g' (x.1, a)) + ball q₀.2 δ ⊆ U :=
       by
       apply subset.trans _ hδ
@@ -1520,7 +1520,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     have N : s ×ˢ univ ∈ 𝓝 (x.1, x.2 - a) := by
       apply A'
       apply h₀ε
-      rw [Prod.dist_eq] at hx
+      rw [Prod.dist_eq] at hx 
       exact lt_of_lt_of_le (lt_of_le_of_lt (le_max_left _ _) hx) δε
     have Z := ((hg.differentiable_on le_rfl).DifferentiableAt N).HasFDerivAt
     have Z' : HasFDerivAt (fun x : P × G => (x.1, x.2 - a)) (ContinuousLinearMap.id 𝕜 (P × G)) x :=
@@ -1556,7 +1556,7 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
     universe, which is why we make the assumption in the lemma that all the relevant spaces
     come from the same universe). -/
   induction' n using ENat.nat_induction with n ih ih generalizing g E' F
-  · rw [contDiffOn_zero] at hg⊢
+  · rw [contDiffOn_zero] at hg ⊢
     exact continuousOn_convolution_right_with_param L hk hgs hf hg
   · let f' : P → G → P × G →L[𝕜] F := fun p a =>
       (f ⋆[L.precompR (P × G), μ] fun x : G => fderiv 𝕜 (uncurry g) (p, x)) a
@@ -1564,7 +1564,7 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
       ∀ q₀ : P × G,
         q₀.1 ∈ s → HasFDerivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (f' q₀.1 q₀.2) q₀ :=
       hasFDerivAt_convolution_right_with_param L hs hk hgs hf hg.one_of_succ
-    rw [contDiffOn_succ_iff_fderiv_of_open (hs.prod (@isOpen_univ G _))] at hg⊢
+    rw [contDiffOn_succ_iff_fderiv_of_open (hs.prod (@isOpen_univ G _))] at hg ⊢
     constructor
     · rintro ⟨p, x⟩ ⟨hp, hx⟩
       exact (A (p, x) hp).DifferentiableAt.DifferentiableWithinAt
@@ -1587,7 +1587,7 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
       apply funext
       rintro ⟨p, x⟩
       rfl
-  · rw [contDiffOn_top] at hg⊢
+  · rw [contDiffOn_top] at hg ⊢
     intro n
     exact ih n L hgs (hg n)
 #align cont_diff_on_convolution_right_with_param_aux contDiffOn_convolution_right_with_param_aux
@@ -1666,7 +1666,7 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
       ContinuousLinearEquiv.arrowCongr, ContinuousLinearEquiv.arrowCongrSL_symm_apply,
       ContinuousLinearEquiv.coe_coe, comp_app, ContinuousLinearEquiv.apply_symm_apply,
       LinearEquiv.invFun_eq_symm, ContinuousLinearEquiv.arrowCongrₛₗ_symm_apply, eq_self_iff_true]
-  simp_rw [this] at A
+  simp_rw [this] at A 
   exact A
 #align cont_diff_on_convolution_right_with_param contDiffOn_convolution_right_with_param
 
@@ -1759,7 +1759,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
       rcases le_or_lt t 0 with (h | h)
       · exact Or.inl h
       · rcases lt_or_le t x with (h' | h')
-        exacts[Or.inr (Or.inl ⟨h, h'⟩), Or.inr (Or.inr h')]
+        exacts [Or.inr (Or.inl ⟨h, h'⟩), Or.inr (Or.inr h')]
     rcases this with (ht | ht | ht)
     ·
       rw [indicator_of_not_mem (not_mem_Ioo_of_le ht), indicator_of_not_mem (not_mem_Ioi.mpr ht),
@@ -1774,7 +1774,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
     ext1 t
     by_cases ht : 0 < t
     · rw [indicator_of_not_mem (_ : x - t ∉ Ioi 0), ContinuousLinearMap.map_zero]
-      rw [not_mem_Ioi] at h⊢
+      rw [not_mem_Ioi] at h ⊢
       exact sub_nonpos.mpr (h.trans ht.le)
     ·
       rw [indicator_of_not_mem (mem_Ioi.not.mpr ht), ContinuousLinearMap.map_zero,
@@ -1786,7 +1786,7 @@ theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Meas
     (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     Integrable (posConvolution f g L ν) μ :=
   by
-  rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg
+  rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg 
   rw [posConvolution_eq_convolution_indicator f g L ν]
   exact (hf.convolution_integrand L hg).integral_prod_left
 #align integrable_pos_convolution integrable_posConvolution
@@ -1799,7 +1799,7 @@ theorem integral_pos_convolution [CompleteSpace E] [CompleteSpace E'] {μ ν : M
     (∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0 ..x, L (f t) (g (x - t)) ∂ν ∂μ) =
       L (∫ x : ℝ in Ioi 0, f x ∂ν) (∫ x : ℝ in Ioi 0, g x ∂μ) :=
   by
-  rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg
+  rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg 
   simp_rw [← integral_indicator measurableSet_Ioi]
   convert integral_convolution L hf hg using 2
   apply posConvolution_eq_convolution_indicator

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

@@ -266,7 +266,7 @@ end
 
 section Left
 
-variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [AddRightInvariant μ]
 
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd (hf : AEStronglyMeasurable f μ)
     (hg : AEStronglyMeasurable g μ) (x : G) :
@@ -297,8 +297,7 @@ end Left
 
 section Right
 
-variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
-  [SigmaFinite ν]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [AddRightInvariant μ] [SigmaFinite ν]
 
 theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand (hf : AEStronglyMeasurable f ν)
     (hg : AEStronglyMeasurable g μ) :
@@ -353,7 +352,7 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
   have A :
     ae_strongly_measurable (g ∘ ⇑v) (μ.restrict (tsupport fun t : G => (L (f t)) (g (x₀ - t)))) :=
     by
-    apply (hg.comp v.continuous).ContinuousOn.aEStronglyMeasurable_of_isCompact h
+    apply (hg.comp v.continuous).ContinuousOn.aestronglyMeasurable_of_isCompact h
     exact (isClosed_tsupport _).MeasurableSet
   convert((v.continuous.measurable.measure_preserving
               (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aestronglyMeasurable_comp_iff
@@ -393,7 +392,7 @@ variable [AddCommGroup G]
 
 section MeasurableGroup
 
-variable [MeasurableNeg G] [IsAddLeftInvariant μ]
+variable [MeasurableNeg G] [AddLeftInvariant μ]
 
 /-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
 We assume that the integrand has compact support and `g` is bounded on this support (note that
@@ -416,7 +415,7 @@ theorem BddAbove.convolutionExistsAt [MeasurableAdd₂ G] [SigmaFinite μ] {x₀
       map_mono_of_ae_measurable restrict_le_self (measurable_const.sub measurable_id').AEMeasurable
 #align bdd_above.convolution_exists_at BddAbove.convolutionExistsAt
 
-variable {L} [MeasurableAdd G] [IsNegInvariant μ]
+variable {L} [MeasurableAdd G] [NegInvariant μ]
 
 theorem convolutionExistsAt_flip :
     ConvolutionExistsAt g f x L.flip μ ↔ ConvolutionExistsAt f g x L μ := by
@@ -436,8 +435,8 @@ theorem convolutionExistsAt_iff_integrable_swap :
 
 end MeasurableGroup
 
-variable [TopologicalSpace G] [TopologicalAddGroup G] [BorelSpace G] [IsAddLeftInvariant μ]
-  [IsNegInvariant μ]
+variable [TopologicalSpace G] [TopologicalAddGroup G] [BorelSpace G] [AddLeftInvariant μ]
+  [NegInvariant μ]
 
 theorem HasCompactSupport.convolutionExistsLeft (hcf : HasCompactSupport f) (hf : Continuous f)
     (hg : LocallyIntegrable g μ) : ConvolutionExists f g L μ := fun x₀ =>
@@ -558,8 +557,8 @@ theorem convolution_mono_right_of_nonneg {f g g' : G → ℝ}
 
 variable (L)
 
-theorem convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ]
-    [IsAddRightInvariant μ] (h1 : f =ᵐ[μ] f') (h2 : g =ᵐ[μ] g') : f ⋆[L, μ] g = f' ⋆[L, μ] g' :=
+theorem convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [AddRightInvariant μ]
+    (h1 : f =ᵐ[μ] f') (h2 : g =ᵐ[μ] g') : f ⋆[L, μ] g = f' ⋆[L, μ] g' :=
   by
   ext x
   apply integral_congr_ae
@@ -587,7 +586,7 @@ theorem support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g
 
 section
 
-variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [AddRightInvariant μ]
 
 theorem MeasureTheory.Integrable.integrable_convolution (hf : Integrable f μ)
     (hg : Integrable g μ) : Integrable (f ⋆[L, μ] g) μ :=
@@ -824,7 +823,7 @@ theorem support_convolution_subset : support (f ⋆[L, μ] g) ⊆ support f + su
   (support_convolution_subset_swap L).trans (add_comm _ _).Subset
 #align support_convolution_subset support_convolution_subset
 
-variable [IsAddLeftInvariant μ] [IsNegInvariant μ]
+variable [AddLeftInvariant μ] [NegInvariant μ]
 
 section Measurable
 
@@ -923,7 +922,7 @@ theorem convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 :
 
 variable [BorelSpace G] [SecondCountableTopology G]
 
-variable [IsAddLeftInvariant μ] [SigmaFinite μ]
+variable [AddLeftInvariant μ] [SigmaFinite μ]
 
 /-- Approximate `(f ⋆ g) x₀` if the support of the `f` is bounded within a ball, and `g` is near
 `g x₀` on a ball with the same radius around `x₀`. See `dist_convolution_le` for a special case.
@@ -1066,7 +1065,7 @@ theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.r, g
   exact integral_normed_smul φ μ (g x₀)
 #align cont_diff_bump.normed_convolution_eq_right ContDiffBump.normed_convolution_eq_right
 
-variable [IsAddLeftInvariant μ]
+variable [AddLeftInvariant μ]
 
 /-- If `φ` is a normed bump function, approximate `(φ ⋆ g) x₀` if `g` is near `g x₀` on a ball with
 radius `φ.R` around `x₀`. -/
@@ -1145,7 +1144,7 @@ variable (L₄ : E' →L[𝕜] E'' →L[𝕜] F'')
 
 variable [AddGroup G]
 
-variable [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ]
+variable [SigmaFinite μ] [SigmaFinite ν] [AddRightInvariant μ]
 
 theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace ℝ E]
     [NormedSpace ℝ E'] [CompleteSpace E] [CompleteSpace E'] (hf : Integrable f ν)
@@ -1156,7 +1155,7 @@ theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace
   exact (L.flip (∫ x, g x ∂μ)).integral_comp_comm hf
 #align integral_convolution integral_convolution
 
-variable [MeasurableAdd₂ G] [IsAddRightInvariant ν] [MeasurableNeg G]
+variable [MeasurableAdd₂ G] [AddRightInvariant ν] [MeasurableNeg G]
 
 /-- Convolution is associative. This has a weak but inconvenient integrability condition.
 See also `convolution_assoc`. -/
@@ -1259,7 +1258,7 @@ theorem convolution_precompR_apply {g : G → E'' →L[𝕜] E'} (hf : LocallyIn
   rfl
 #align convolution_precompR_apply convolution_precompR_apply
 
-variable [NormedSpace 𝕜 G] [SigmaFinite μ] [IsAddLeftInvariant μ]
+variable [NormedSpace 𝕜 G] [SigmaFinite μ] [AddLeftInvariant μ]
 
 /-- Compute the total derivative of `f ⋆ g` if `g` is `C^1` with compact support and `f` is locally
 integrable. To write down the total derivative as a convolution, we use
@@ -1301,8 +1300,8 @@ theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport
   · exact eventually_of_forall fun t x hx => (L _).HasFDerivAt.comp x (h3 x t)
 #align has_compact_support.has_fderiv_at_convolution_right HasCompactSupport.hasFDerivAt_convolution_right
 
-theorem HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
-    (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 1 f) (hg : LocallyIntegrable g μ) (x₀ : G) :
+theorem HasCompactSupport.hasFDerivAt_convolution_left [NegInvariant μ] (hcf : HasCompactSupport f)
+    (hf : ContDiff 𝕜 1 f) (hg : LocallyIntegrable g μ) (x₀ : G) :
     HasFDerivAt (f ⋆[L, μ] g) ((fderiv 𝕜 f ⋆[L.precompL G, μ] g) x₀) x₀ :=
   by
   simp (config := { singlePass := true }) only [← convolution_flip]
@@ -1334,7 +1333,7 @@ variable [CompleteSpace F]
 
 variable {μ : Measure 𝕜}
 
-variable [IsAddLeftInvariant μ] [SigmaFinite μ]
+variable [AddLeftInvariant μ] [SigmaFinite μ]
 
 theorem HasCompactSupport.hasDerivAt_convolution_right (hf : LocallyIntegrable f₀ μ)
     (hcg : HasCompactSupport g₀) (hg : ContDiff 𝕜 1 g₀) (x₀ : 𝕜) :
@@ -1345,8 +1344,8 @@ theorem HasCompactSupport.hasDerivAt_convolution_right (hf : LocallyIntegrable f
   rfl
 #align has_compact_support.has_deriv_at_convolution_right HasCompactSupport.hasDerivAt_convolution_right
 
-theorem HasCompactSupport.hasDerivAt_convolution_left [IsNegInvariant μ]
-    (hcf : HasCompactSupport f₀) (hf : ContDiff 𝕜 1 f₀) (hg : LocallyIntegrable g₀ μ) (x₀ : 𝕜) :
+theorem HasCompactSupport.hasDerivAt_convolution_left [NegInvariant μ] (hcf : HasCompactSupport f₀)
+    (hf : ContDiff 𝕜 1 f₀) (hg : LocallyIntegrable g₀ μ) (x₀ : 𝕜) :
     HasDerivAt (f₀ ⋆[L, μ] g₀) ((deriv f₀ ⋆[L, μ] g₀) x₀) x₀ :=
   by
   simp (config := { singlePass := true }) only [← convolution_flip]
@@ -1691,7 +1690,7 @@ theorem contDiffOn_convolution_right_with_param_comp {n : ℕ∞} (L : E →L[
 /-- The convolution `g * f` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`). -/
-theorem contDiffOn_convolution_left_with_param [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
+theorem contDiffOn_convolution_left_with_param [μ.AddLeftInvariant] [μ.NegInvariant]
     (L : E' →L[𝕜] E →L[𝕜] F) {f : G → E} {n : ℕ∞} {g : P → G → E'} {s : Set P} {k : Set G}
     (hs : IsOpen s) (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
     (hf : LocallyIntegrable f μ) (hg : ContDiffOn 𝕜 n (↿g) (s ×ˢ univ)) :
@@ -1704,7 +1703,7 @@ theorem contDiffOn_convolution_left_with_param [μ.IsAddLeftInvariant] [μ.IsNeg
 supported. Version where `g` depends on an additional parameter in an open subset `s` of a
 parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
 given in terms of composition with additional smooth functions. -/
-theorem contDiffOn_convolution_left_with_param_comp [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
+theorem contDiffOn_convolution_left_with_param_comp [μ.AddLeftInvariant] [μ.NegInvariant]
     (L : E' →L[𝕜] E →L[𝕜] F) {s : Set P} {n : ℕ∞} {v : P → G} (hv : ContDiffOn 𝕜 n v s) {f : G → E}
     {g : P → G → E'} {k : Set G} (hs : IsOpen s) (hk : IsCompact k)
     (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
@@ -1725,8 +1724,8 @@ theorem HasCompactSupport.contDiff_convolution_right {n : ℕ∞} (hcg : HasComp
       (fun p x hp hx => h'k x hx) hf (hg.comp contDiff_snd).ContDiffOn
 #align has_compact_support.cont_diff_convolution_right HasCompactSupport.contDiff_convolution_right
 
-theorem HasCompactSupport.contDiff_convolution_left [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
-    {n : ℕ∞} (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 n f) (hg : LocallyIntegrable g μ) :
+theorem HasCompactSupport.contDiff_convolution_left [μ.AddLeftInvariant] [μ.NegInvariant] {n : ℕ∞}
+    (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 n f) (hg : LocallyIntegrable g μ) :
     ContDiff 𝕜 n (f ⋆[L, μ] g) := by rw [← convolution_flip];
   exact hcf.cont_diff_convolution_right L.flip hg hf
 #align has_compact_support.cont_diff_convolution_left HasCompactSupport.contDiff_convolution_left
@@ -1783,7 +1782,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
 #align pos_convolution_eq_convolution_indicator posConvolution_eq_convolution_indicator
 
 theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measure ℝ} [SigmaFinite μ]
-    [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
+    [SigmaFinite ν] [AddRightInvariant μ] [NoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
     (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     Integrable (posConvolution f g L ν) μ :=
   by
@@ -1795,7 +1794,7 @@ theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Meas
 /-- The integral over `Ioi 0` of a forward convolution of two functions is equal to the product
 of their integrals over this set. (Compare `integral_convolution` for the two-sided convolution.) -/
 theorem integral_pos_convolution [CompleteSpace E] [CompleteSpace E'] {μ ν : Measure ℝ}
-    [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
+    [SigmaFinite μ] [SigmaFinite ν] [AddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
     (hf : IntegrableOn f (Ioi 0) ν) (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     (∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0 ..x, L (f t) (g (x - t)) ∂ν ∂μ) =
       L (∫ x : ℝ in Ioi 0, f x ∂ν) (∫ x : ℝ in Ioi 0, g x ∂μ) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/88a563b158f59f2983cfad685664da95502e8cdd

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 
 ! This file was ported from Lean 3 source module analysis.convolution
-! leanprover-community/mathlib commit fd5edc43dc4f10b85abfe544b88f82cf13c5f844
+! leanprover-community/mathlib commit f7ebde7ee0d1505dfccac8644ae12371aa3c1c9f
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -1665,7 +1665,8 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
     simp only [ef, eg, comp_app, ContinuousLinearEquiv.apply_symm_apply, coe_comp',
       ContinuousLinearEquiv.prod_apply, ContinuousLinearEquiv.map_sub,
       ContinuousLinearEquiv.arrowCongr, ContinuousLinearEquiv.arrowCongrSL_symm_apply,
-      ContinuousLinearEquiv.coe_coe, comp_app, ContinuousLinearEquiv.apply_symm_apply]
+      ContinuousLinearEquiv.coe_coe, comp_app, ContinuousLinearEquiv.apply_symm_apply,
+      LinearEquiv.invFun_eq_symm, ContinuousLinearEquiv.arrowCongrₛₗ_symm_apply, eq_self_iff_true]
   simp_rw [this] at A
   exact A
 #align cont_diff_on_convolution_right_with_param contDiffOn_convolution_right_with_param

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

@@ -98,7 +98,7 @@ open Set Function Filter MeasureTheory MeasureTheory.Measure TopologicalSpace
 
 open ContinuousLinearMap Metric
 
-open Pointwise Topology NNReal Filter
+open scoped Pointwise Topology NNReal Filter
 
 universe u𝕜 uG uE uE' uE'' uF uF' uF'' uP
 
@@ -1107,7 +1107,7 @@ end Measurability
 
 end NontriviallyNormedField
 
-open convolution
+open scoped convolution
 
 section IsROrC
 

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

@@ -246,8 +246,7 @@ theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
     · have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
       rw [nmem_support.mp this, norm_zero]
   refine' integrable.mono' _ _ this
-  · rw [integrable_indicator_iff hs]
-    exact ((hf.norm.const_mul _).mul_const _).IntegrableOn
+  · rw [integrable_indicator_iff hs]; exact ((hf.norm.const_mul _).mul_const _).IntegrableOn
   · exact hf.ae_strongly_measurable.convolution_integrand_snd' L hmg
 #align bdd_above.convolution_exists_at' BddAbove.convolutionExistsAt'
 
@@ -426,9 +425,7 @@ theorem convolutionExistsAt_flip :
 #align convolution_exists_at_flip convolutionExistsAt_flip
 
 theorem ConvolutionExistsAt.integrable_swap (h : ConvolutionExistsAt f g x L μ) :
-    Integrable (fun t => L (f (x - t)) (g t)) μ :=
-  by
-  convert h.comp_sub_left x
+    Integrable (fun t => L (f (x - t)) (g t)) μ := by convert h.comp_sub_left x;
   simp_rw [sub_sub_self]
 #align convolution_exists_at.integrable_swap ConvolutionExistsAt.integrable_swap
 
@@ -498,27 +495,21 @@ section Group
 
 variable {L} [AddGroup G]
 
-theorem smul_convolution [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : y • f ⋆[L, μ] g = y • (f ⋆[L, μ] g) :=
-  by
-  ext
-  simp only [Pi.smul_apply, convolution_def, ← integral_smul, L.map_smul₂]
+theorem smul_convolution [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : y • f ⋆[L, μ] g = y • (f ⋆[L, μ] g) := by
+  ext; simp only [Pi.smul_apply, convolution_def, ← integral_smul, L.map_smul₂]
 #align smul_convolution smul_convolution
 
-theorem convolution_smul [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : f ⋆[L, μ] y • g = y • (f ⋆[L, μ] g) :=
-  by
-  ext
-  simp only [Pi.smul_apply, convolution_def, ← integral_smul, (L _).map_smul]
+theorem convolution_smul [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : f ⋆[L, μ] y • g = y • (f ⋆[L, μ] g) := by
+  ext; simp only [Pi.smul_apply, convolution_def, ← integral_smul, (L _).map_smul]
 #align convolution_smul convolution_smul
 
 @[simp]
-theorem zero_convolution : 0 ⋆[L, μ] g = 0 := by
-  ext
+theorem zero_convolution : 0 ⋆[L, μ] g = 0 := by ext;
   simp_rw [convolution_def, Pi.zero_apply, L.map_zero₂, integral_zero]
 #align zero_convolution zero_convolution
 
 @[simp]
-theorem convolution_zero : f ⋆[L, μ] 0 = 0 := by
-  ext
+theorem convolution_zero : f ⋆[L, μ] 0 = 0 := by ext;
   simp_rw [convolution_def, Pi.zero_apply, (L _).map_zero, integral_zero]
 #align convolution_zero convolution_zero
 
@@ -529,9 +520,7 @@ theorem ConvolutionExistsAt.distrib_add {x : G} (hfg : ConvolutionExistsAt f g x
 #align convolution_exists_at.distrib_add ConvolutionExistsAt.distrib_add
 
 theorem ConvolutionExists.distrib_add (hfg : ConvolutionExists f g L μ)
-    (hfg' : ConvolutionExists f g' L μ) : f ⋆[L, μ] (g + g') = f ⋆[L, μ] g + f ⋆[L, μ] g' :=
-  by
-  ext
+    (hfg' : ConvolutionExists f g' L μ) : f ⋆[L, μ] (g + g') = f ⋆[L, μ] g + f ⋆[L, μ] g' := by ext;
   exact (hfg x).distrib_add (hfg' x)
 #align convolution_exists.distrib_add ConvolutionExists.distrib_add
 
@@ -542,9 +531,7 @@ theorem ConvolutionExistsAt.add_distrib {x : G} (hfg : ConvolutionExistsAt f g x
 #align convolution_exists_at.add_distrib ConvolutionExistsAt.add_distrib
 
 theorem ConvolutionExists.add_distrib (hfg : ConvolutionExists f g L μ)
-    (hfg' : ConvolutionExists f' g L μ) : (f + f') ⋆[L, μ] g = f ⋆[L, μ] g + f' ⋆[L, μ] g :=
-  by
-  ext
+    (hfg' : ConvolutionExists f' g L μ) : (f + f') ⋆[L, μ] g = f ⋆[L, μ] g + f' ⋆[L, μ] g := by ext;
   exact (hfg x).add_distrib (hfg' x)
 #align convolution_exists.add_distrib ConvolutionExists.add_distrib
 
@@ -650,8 +637,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) :=
   by
   intro q₀ hq₀
-  replace hq₀ : q₀.1 ∈ s
-  · simpa only [mem_prod, mem_univ, and_true_iff] using hq₀
+  replace hq₀ : q₀.1 ∈ s; · simpa only [mem_prod, mem_univ, and_true_iff] using hq₀
   have A : ∀ p ∈ s, Continuous (g p) := by
     intro p hp
     apply hg.comp_continuous (continuous_const.prod_mk continuous_id') fun x => _
@@ -858,10 +844,8 @@ theorem convolution_flip : g ⋆[L.flip, μ] f = f ⋆[L, μ] g :=
 #align convolution_flip convolution_flip
 
 /-- The symmetric definition of convolution. -/
-theorem convolution_eq_swap : (f ⋆[L, μ] g) x = ∫ t, L (f (x - t)) (g t) ∂μ :=
-  by
-  rw [← convolution_flip]
-  rfl
+theorem convolution_eq_swap : (f ⋆[L, μ] g) x = ∫ t, L (f (x - t)) (g t) ∂μ := by
+  rw [← convolution_flip]; rfl
 #align convolution_eq_swap convolution_eq_swap
 
 /-- The symmetric definition of convolution where the bilinear operator is scalar multiplication. -/
@@ -885,9 +869,7 @@ theorem convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀
       apply integral_congr_ae
       filter_upwards [h1, (eventually_add_left_iff μ x).2 h2]with t ht h't
       simp_rw [ht, ← h't, neg_add']
-    _ = ∫ t : G, (L (f t)) (g (x - t)) ∂μ :=
-      by
-      rw [← integral_neg_eq_self]
+    _ = ∫ t : G, (L (f t)) (g (x - t)) ∂μ := by rw [← integral_neg_eq_self];
       simp only [neg_neg, ← sub_eq_add_neg]
     
 #align convolution_neg_of_neg_eq convolution_neg_of_neg_eq
@@ -902,15 +884,13 @@ variable [BorelSpace G]
 
 theorem HasCompactSupport.continuous_convolution_left [FirstCountableTopology G]
     (hcf : HasCompactSupport f) (hf : Continuous f) (hg : LocallyIntegrable g μ) :
-    Continuous (f ⋆[L, μ] g) := by
-  rw [← convolution_flip]
+    Continuous (f ⋆[L, μ] g) := by rw [← convolution_flip];
   exact hcf.continuous_convolution_right L.flip hg hf
 #align has_compact_support.continuous_convolution_left HasCompactSupport.continuous_convolution_left
 
 theorem BddAbove.continuous_convolution_left_of_integrable [SecondCountableTopology G]
     (hbf : BddAbove (range fun x => ‖f x‖)) (hf : Continuous f) (hg : Integrable g μ) :
-    Continuous (f ⋆[L, μ] g) := by
-  rw [← convolution_flip]
+    Continuous (f ⋆[L, μ] g) := by rw [← convolution_flip];
   exact hbf.continuous_convolution_right_of_integrable L.flip hg hf
 #align bdd_above.continuous_convolution_left_of_integrable BddAbove.continuous_convolution_left_of_integrable
 
@@ -930,8 +910,7 @@ theorem convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 :
   by
   have h2 : ∀ t, L (f t) (g (x₀ - t)) = L (f t) (g x₀) :=
     by
-    intro t
-    by_cases ht : t ∈ support f
+    intro t; by_cases ht : t ∈ support f
     · have h2t := hf ht
       rw [mem_ball_zero_iff] at h2t
       specialize hg (x₀ - t)
@@ -961,9 +940,7 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
     refine'
       BddAbove.convolutionExistsAt L _ metric.is_open_ball.measurable_set (subset_trans _ hf)
         hif.integrable_on hmg
-    swap
-    · refine' fun t => mt fun ht : f t = 0 => _
-      simp_rw [ht, L.map_zero₂]
+    swap; · refine' fun t => mt fun ht : f t = 0 => _; simp_rw [ht, L.map_zero₂]
     rw [bddAbove_def]
     refine' ⟨‖z₀‖ + ε, _⟩
     rintro _ ⟨x, hx, rfl⟩
@@ -971,8 +948,7 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
     rwa [mem_ball_iff_norm, norm_sub_rev, ← mem_ball_zero_iff]
   have h2 : ∀ t, dist (L (f t) (g (x₀ - t))) (L (f t) z₀) ≤ ‖L (f t)‖ * ε :=
     by
-    intro t
-    by_cases ht : t ∈ support f
+    intro t; by_cases ht : t ∈ support f
     · have h2t := hf ht
       rw [mem_ball_zero_iff] at h2t
       specialize hg (x₀ - t)
@@ -983,9 +959,7 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
       simp_rw [ht, L.map_zero₂, L.map_zero, norm_zero, MulZeroClass.zero_mul, dist_self]
   simp_rw [convolution_def]
   simp_rw [dist_eq_norm] at h2⊢
-  rw [← integral_sub hfg.integrable]
-  swap
-  · exact (L.flip z₀).integrable_comp hif
+  rw [← integral_sub hfg.integrable]; swap; · exact (L.flip z₀).integrable_comp hif
   refine'
     (norm_integral_le_of_norm_le ((L.integrable_comp hif).norm.mul_const ε)
           (eventually_of_forall h2)).trans
@@ -1011,8 +985,7 @@ theorem dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'}
     (hmg : AEStronglyMeasurable g μ) (hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
     dist ((f ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) z₀ ≤ ε :=
   by
-  have hif : integrable f μ := by
-    by_contra hif
+  have hif : integrable f μ := by by_contra hif;
     exact zero_ne_one ((integral_undef hif).symm.trans hintf)
   convert(dist_convolution_le' _ hε hif hf hmg hg).trans _
   · simp_rw [lsmul_apply, integral_smul_const, hintf, one_smul]
@@ -1056,8 +1029,7 @@ theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x
     exact ((dist_triangle _ _ _).trans_lt (add_lt_add hx'.out hki)).trans_eq (add_halves δ)
   have := dist_convolution_le (add_pos h2ε h2ε).le hφi hnφi hiφi hmgi h1
   refine' ((dist_triangle _ _ _).trans_lt (add_lt_add_of_le_of_lt this hgi)).trans_eq _
-  field_simp
-  ring_nf
+  field_simp; ring_nf
 #align convolution_tendsto_right convolution_tendsto_right
 
 end NormedAddCommGroup
@@ -1454,8 +1426,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
       refine' ⟨min ε δ, lt_min εpos δpos, _, _⟩
       · exact subset.trans (thickening_mono (min_le_left _ _) _) hε
       · exact subset.trans (ball_subset_ball (min_le_right _ _)) hδ
-    obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ g' '' t ⊆ closed_ball 0 C
-    exact ht.subset_ball_lt 0 0
+    obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ g' '' t ⊆ closed_ball 0 C; exact ht.subset_ball_lt 0 0
     refine' ⟨ε, C, εpos, Cpos.le, h'ε, fun p x hp => _⟩
     have hps : p ∈ s := h'ε (mem_ball_iff_norm.2 hp)
     by_cases hx : x ∈ k
@@ -1688,8 +1659,7 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
       ContinuousLinearEquiv.prod_apply]
     simp only [convolution, eL, coe_comp', ContinuousLinearEquiv.coe_coe, comp_app, eμ]
     rw [ClosedEmbedding.integral_map, ← isoF.integral_comp_comm]
-    swap
-    · exact isoG.symm.to_homeomorph.closed_embedding
+    swap; · exact isoG.symm.to_homeomorph.closed_embedding
     congr 1
     ext1 a
     simp only [ef, eg, comp_app, ContinuousLinearEquiv.apply_symm_apply, coe_comp',
@@ -1756,8 +1726,7 @@ theorem HasCompactSupport.contDiff_convolution_right {n : ℕ∞} (hcg : HasComp
 
 theorem HasCompactSupport.contDiff_convolution_left [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
     {n : ℕ∞} (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 n f) (hg : LocallyIntegrable g μ) :
-    ContDiff 𝕜 n (f ⋆[L, μ] g) := by
-  rw [← convolution_flip]
+    ContDiff 𝕜 n (f ⋆[L, μ] g) := by rw [← convolution_flip];
   exact hcf.cont_diff_convolution_right L.flip hg hf
 #align has_compact_support.cont_diff_convolution_left HasCompactSupport.contDiff_convolution_left
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/75e7fca56381d056096ce5d05e938f63a6567828

@@ -197,29 +197,29 @@ section Group
 
 variable [AddGroup G]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand' [MeasurableAdd₂ G]
-    [MeasurableNeg G] [SigmaFinite ν] (hf : AeStronglyMeasurable f ν)
-    (hg : AeStronglyMeasurable g <| map (fun p : G × G => p.1 - p.2) (μ.Prod ν)) :
-    AeStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
-  L.aeStronglyMeasurable_comp₂ hf.snd <| hg.comp_measurable measurable_sub
-#align measure_theory.ae_strongly_measurable.convolution_integrand' MeasureTheory.AeStronglyMeasurable.convolution_integrand'
+theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand' [MeasurableAdd₂ G]
+    [MeasurableNeg G] [SigmaFinite ν] (hf : AEStronglyMeasurable f ν)
+    (hg : AEStronglyMeasurable g <| map (fun p : G × G => p.1 - p.2) (μ.Prod ν)) :
+    AEStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
+  L.aestronglyMeasurable_comp₂ hf.snd <| hg.comp_measurable measurable_sub
+#align measure_theory.ae_strongly_measurable.convolution_integrand' MeasureTheory.AEStronglyMeasurable.convolution_integrand'
 
 section
 
 variable [MeasurableAdd G] [MeasurableNeg G]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd'
-    (hf : AeStronglyMeasurable f μ) {x : G}
-    (hg : AeStronglyMeasurable g <| map (fun t => x - t) μ) :
-    AeStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
-  L.aeStronglyMeasurable_comp₂ hf <| hg.comp_measurable <| measurable_id.const_sub x
-#align measure_theory.ae_strongly_measurable.convolution_integrand_snd' MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd'
+theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd'
+    (hf : AEStronglyMeasurable f μ) {x : G}
+    (hg : AEStronglyMeasurable g <| map (fun t => x - t) μ) :
+    AEStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
+  L.aestronglyMeasurable_comp₂ hf <| hg.comp_measurable <| measurable_id.const_sub x
+#align measure_theory.ae_strongly_measurable.convolution_integrand_snd' MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd'
 
-theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_swap_snd' {x : G}
-    (hf : AeStronglyMeasurable f <| map (fun t => x - t) μ) (hg : AeStronglyMeasurable g μ) :
-    AeStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
-  L.aeStronglyMeasurable_comp₂ (hf.comp_measurable <| measurable_id.const_sub x) hg
-#align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd' MeasureTheory.AeStronglyMeasurable.convolution_integrand_swap_snd'
+theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd' {x : G}
+    (hf : AEStronglyMeasurable f <| map (fun t => x - t) μ) (hg : AEStronglyMeasurable g μ) :
+    AEStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
+  L.aestronglyMeasurable_comp₂ (hf.comp_measurable <| measurable_id.const_sub x) hg
+#align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd' MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd'
 
 /-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
 We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
@@ -227,7 +227,7 @@ on `x₀ - s` (note that both properties hold if `g` is continuous with compact
 theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
     (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
     (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
-    (hmg : AeStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
+    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
     ConvolutionExistsAt f g x₀ L μ :=
   by
   rw [ConvolutionExistsAt, ← integrable_on_iff_integrable_of_support_subset h2s]
@@ -254,7 +254,7 @@ theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
 /-- If `‖f‖ *[μ] ‖g‖` exists, then `f *[L, μ] g` exists. -/
 theorem ConvolutionExistsAt.ofNorm' {x₀ : G}
     (h : ConvolutionExistsAt (fun x => ‖f x‖) (fun x => ‖g x‖) x₀ (mul ℝ ℝ) μ)
-    (hmf : AeStronglyMeasurable f μ) (hmg : AeStronglyMeasurable g <| map (fun t => x₀ - t) μ) :
+    (hmf : AEStronglyMeasurable f μ) (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) μ) :
     ConvolutionExistsAt f g x₀ L μ :=
   by
   refine'
@@ -269,26 +269,26 @@ section Left
 
 variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd (hf : AeStronglyMeasurable f μ)
-    (hg : AeStronglyMeasurable g μ) (x : G) :
-    AeStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
+theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd (hf : AEStronglyMeasurable f μ)
+    (hg : AEStronglyMeasurable g μ) (x : G) :
+    AEStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
   hf.convolution_integrand_snd' L <|
     hg.mono' <| (quasiMeasurePreserving_sub_left_of_right_invariant μ x).AbsolutelyContinuous
-#align measure_theory.ae_strongly_measurable.convolution_integrand_snd MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd
+#align measure_theory.ae_strongly_measurable.convolution_integrand_snd MeasureTheory.AEStronglyMeasurable.convolution_integrand_snd
 
-theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_swap_snd
-    (hf : AeStronglyMeasurable f μ) (hg : AeStronglyMeasurable g μ) (x : G) :
-    AeStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
+theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd
+    (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) (x : G) :
+    AEStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
   (hf.mono'
         (quasiMeasurePreserving_sub_left_of_right_invariant μ
             x).AbsolutelyContinuous).convolution_integrand_swap_snd'
     L hg
-#align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd MeasureTheory.AeStronglyMeasurable.convolution_integrand_swap_snd
+#align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd MeasureTheory.AEStronglyMeasurable.convolution_integrand_swap_snd
 
 /-- If `‖f‖ *[μ] ‖g‖` exists, then `f *[L, μ] g` exists. -/
 theorem ConvolutionExistsAt.ofNorm {x₀ : G}
     (h : ConvolutionExistsAt (fun x => ‖f x‖) (fun x => ‖g x‖) x₀ (mul ℝ ℝ) μ)
-    (hmf : AeStronglyMeasurable f μ) (hmg : AeStronglyMeasurable g μ) :
+    (hmf : AEStronglyMeasurable f μ) (hmg : AEStronglyMeasurable g μ) :
     ConvolutionExistsAt f g x₀ L μ :=
   h.ofNorm' L hmf <|
     hmg.mono' (quasiMeasurePreserving_sub_left_of_right_invariant μ x₀).AbsolutelyContinuous
@@ -301,12 +301,12 @@ section Right
 variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
   [SigmaFinite ν]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand (hf : AeStronglyMeasurable f ν)
-    (hg : AeStronglyMeasurable g μ) :
-    AeStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
+theorem MeasureTheory.AEStronglyMeasurable.convolution_integrand (hf : AEStronglyMeasurable f ν)
+    (hg : AEStronglyMeasurable g μ) :
+    AEStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
   hf.convolution_integrand' L <|
     hg.mono' (quasiMeasurePreserving_sub_of_right_invariant μ ν).AbsolutelyContinuous
-#align measure_theory.ae_strongly_measurable.convolution_integrand MeasureTheory.AeStronglyMeasurable.convolution_integrand
+#align measure_theory.ae_strongly_measurable.convolution_integrand MeasureTheory.AEStronglyMeasurable.convolution_integrand
 
 theorem MeasureTheory.Integrable.convolution_integrand (hf : Integrable f ν) (hg : Integrable g μ) :
     Integrable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
@@ -334,7 +334,7 @@ theorem MeasureTheory.Integrable.convolution_integrand (hf : Integrable f ν) (h
 theorem MeasureTheory.Integrable.ae_convolution_exists (hf : Integrable f ν) (hg : Integrable g μ) :
     ∀ᵐ x ∂μ, ConvolutionExistsAt f g x L ν :=
   ((integrable_prod_iff <|
-          hf.AeStronglyMeasurable.convolution_integrand L hg.AeStronglyMeasurable).mp <|
+          hf.AEStronglyMeasurable.convolution_integrand L hg.AEStronglyMeasurable).mp <|
       hf.convolution_integrand L hg).1
 #align measure_theory.integrable.ae_convolution_exists MeasureTheory.Integrable.ae_convolution_exists
 
@@ -354,10 +354,10 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
   have A :
     ae_strongly_measurable (g ∘ ⇑v) (μ.restrict (tsupport fun t : G => (L (f t)) (g (x₀ - t)))) :=
     by
-    apply (hg.comp v.continuous).ContinuousOn.aeStronglyMeasurable_of_isCompact h
+    apply (hg.comp v.continuous).ContinuousOn.aEStronglyMeasurable_of_isCompact h
     exact (isClosed_tsupport _).MeasurableSet
   convert((v.continuous.measurable.measure_preserving
-              (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aeStronglyMeasurable_comp_iff
+              (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aestronglyMeasurable_comp_iff
           v.to_measurable_equiv.measurable_embedding).1
       A
   ext x
@@ -406,7 +406,7 @@ measure. This allows us to state the boundedness and measurability of `g` in a m
 theorem BddAbove.convolutionExistsAt [MeasurableAdd₂ G] [SigmaFinite μ] {x₀ : G} {s : Set G}
     (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => x₀ - t) ⁻¹' s))) (hs : MeasurableSet s)
     (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
-    (hmg : AeStronglyMeasurable g μ) : ConvolutionExistsAt f g x₀ L μ :=
+    (hmg : AEStronglyMeasurable g μ) : ConvolutionExistsAt f g x₀ L μ :=
   by
   refine' BddAbove.convolutionExistsAt' L _ hs h2s hf _
   · simp_rw [← sub_eq_neg_add, hbg]
@@ -952,7 +952,7 @@ variable [IsAddLeftInvariant μ] [SigmaFinite μ]
 We can simplify the second argument of `dist` further if we add some extra type-classes on `E`
 and `𝕜` or if `L` is scalar multiplication. -/
 theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε) (hif : Integrable f μ)
-    (hf : support f ⊆ ball (0 : G) R) (hmg : AeStronglyMeasurable g μ)
+    (hf : support f ⊆ ball (0 : G) R) (hmg : AEStronglyMeasurable g μ)
     (hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
     dist ((f ⋆[L, μ] g : G → F) x₀) (∫ t, L (f t) z₀ ∂μ) ≤ (‖L‖ * ∫ x, ‖f x‖ ∂μ) * ε :=
   by
@@ -1008,7 +1008,7 @@ This is a special case of `dist_convolution_le'` where `L` is `(•)`, `f` has i
 nonnegative. -/
 theorem dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε)
     (hf : support f ⊆ ball (0 : G) R) (hnf : ∀ x, 0 ≤ f x) (hintf : (∫ x, f x ∂μ) = 1)
-    (hmg : AeStronglyMeasurable g μ) (hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
+    (hmg : AEStronglyMeasurable g μ) (hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
     dist ((f ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) z₀ ≤ ε :=
   by
   have hif : integrable f μ := by
@@ -1034,7 +1034,7 @@ theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x
     (hiφ : ∀ᶠ i in l, (∫ x, φ i x ∂μ) = 1)
     -- todo: we could weaken this to "the integral tends to 1"
     (hφ : Tendsto (fun n => support (φ n)) l (𝓝 0).smallSets)
-    (hmg : ∀ᶠ i in l, AeStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ᶠ 𝓝 x₀) (𝓝 z₀))
+    (hmg : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ᶠ 𝓝 x₀) (𝓝 z₀))
     (hk : Tendsto k l (𝓝 x₀)) :
     Tendsto (fun i : ι => (φ i ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀) :=
   by
@@ -1098,7 +1098,7 @@ variable [IsAddLeftInvariant μ]
 
 /-- If `φ` is a normed bump function, approximate `(φ ⋆ g) x₀` if `g` is near `g x₀` on a ball with
 radius `φ.R` around `x₀`. -/
-theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AeStronglyMeasurable g μ)
+theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AEStronglyMeasurable g μ)
     (hg : ∀ x ∈ ball x₀ φ.r, dist (g x) (g x₀) ≤ ε) :
     dist ((φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) (g x₀) ≤ ε :=
   dist_convolution_le (by simp_rw [← dist_self (g x₀), hg x₀ (mem_ball_self φ.R_pos)])
@@ -1112,7 +1112,7 @@ theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AeStronglyMeasur
 * `k i` tends to `x₀`. -/
 theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)} {g : ι → G → E'} {k : ι → G}
     {x₀ : G} {z₀ : E'} {l : Filter ι} (hφ : Tendsto (fun i => (φ i).r) l (𝓝 0))
-    (hig : ∀ᶠ i in l, AeStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ᶠ 𝓝 x₀) (𝓝 z₀))
+    (hig : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ᶠ 𝓝 x₀) (𝓝 z₀))
     (hk : Tendsto k l (𝓝 x₀)) :
     Tendsto (fun i => ((fun x => (φ i).normed μ x) ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀) :=
   convolution_tendsto_right (eventually_of_forall fun i => (φ i).nonneg_normed)
@@ -1125,7 +1125,7 @@ theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)} {g : 
 theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι}
     (hφ : Tendsto (fun i => (φ i).r) l (𝓝 0)) (hg : Continuous g) (x₀ : G) :
     Tendsto (fun i => ((fun x => (φ i).normed μ x) ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) l (𝓝 (g x₀)) :=
-  convolution_tendsto_right hφ (eventually_of_forall fun _ => hg.AeStronglyMeasurable)
+  convolution_tendsto_right hφ (eventually_of_forall fun _ => hg.AEStronglyMeasurable)
     ((hg.Tendsto x₀).comp tendsto_snd) tendsto_const_nhds
 #align cont_diff_bump.convolution_tendsto_right_of_continuous ContDiffBump.convolution_tendsto_right_of_continuous
 
@@ -1221,7 +1221,7 @@ theorem convolution_assoc' (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z
 * `‖g‖ ⋆[μ] ‖k‖` exists almost everywhere
 * `‖f‖ ⋆[ν] (‖g‖ ⋆[μ] ‖k‖)` exists at `x₀` -/
 theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z = L₃ x (L₄ y z)) {x₀ : G}
-    (hf : AeStronglyMeasurable f ν) (hg : AeStronglyMeasurable g μ) (hk : AeStronglyMeasurable k μ)
+    (hf : AEStronglyMeasurable f ν) (hg : AEStronglyMeasurable g μ) (hk : AEStronglyMeasurable k μ)
     (hfg : ∀ᵐ y ∂μ, ConvolutionExistsAt f g y L ν)
     (hgk : ∀ᵐ x ∂ν, ConvolutionExistsAt (fun x => ‖g x‖) (fun x => ‖k x‖) x (mul ℝ ℝ) μ)
     (hfgk :
@@ -1308,7 +1308,7 @@ theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport
       (hf.ae_strongly_measurable.convolution_integrand_snd L hg.continuous.ae_strongly_measurable)
   have h2 : ∀ x, ae_strongly_measurable (fun t => L' (f t) (fderiv 𝕜 g (x - t))) μ :=
     hf.ae_strongly_measurable.convolution_integrand_snd L'
-      (hg.continuous_fderiv le_rfl).AeStronglyMeasurable
+      (hg.continuous_fderiv le_rfl).AEStronglyMeasurable
   have h3 : ∀ x t, HasFDerivAt (fun x => g (x - t)) (fderiv 𝕜 g (x - t)) x :=
     by
     intro x t

mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952

@@ -1292,14 +1292,14 @@ variable [NormedSpace 𝕜 G] [SigmaFinite μ] [IsAddLeftInvariant μ]
 /-- Compute the total derivative of `f ⋆ g` if `g` is `C^1` with compact support and `f` is locally
 integrable. To write down the total derivative as a convolution, we use
 `continuous_linear_map.precompR`. -/
-theorem HasCompactSupport.hasFderivAt_convolution_right (hcg : HasCompactSupport g)
+theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport g)
     (hf : LocallyIntegrable f μ) (hg : ContDiff 𝕜 1 g) (x₀ : G) :
-    HasFderivAt (f ⋆[L, μ] g) ((f ⋆[L.precompR G, μ] fderiv 𝕜 g) x₀) x₀ :=
+    HasFDerivAt (f ⋆[L, μ] g) ((f ⋆[L.precompR G, μ] fderiv 𝕜 g) x₀) x₀ :=
   by
   rcases hcg.eq_zero_or_finite_dimensional 𝕜 hg.continuous with (rfl | fin_dim)
   · have : fderiv 𝕜 (0 : G → E') = 0 := fderiv_const (0 : E')
     simp only [this, convolution_zero, Pi.zero_apply]
-    exact hasFderivAt_const (0 : F) x₀
+    exact hasFDerivAt_const (0 : F) x₀
   skip
   have : ProperSpace G := FiniteDimensional.proper_isROrC 𝕜 G
   set L' := L.precompR G
@@ -1309,15 +1309,15 @@ theorem HasCompactSupport.hasFderivAt_convolution_right (hcg : HasCompactSupport
   have h2 : ∀ x, ae_strongly_measurable (fun t => L' (f t) (fderiv 𝕜 g (x - t))) μ :=
     hf.ae_strongly_measurable.convolution_integrand_snd L'
       (hg.continuous_fderiv le_rfl).AeStronglyMeasurable
-  have h3 : ∀ x t, HasFderivAt (fun x => g (x - t)) (fderiv 𝕜 g (x - t)) x :=
+  have h3 : ∀ x t, HasFDerivAt (fun x => g (x - t)) (fderiv 𝕜 g (x - t)) x :=
     by
     intro x t
     simpa using
-      (hg.differentiable le_rfl).DifferentiableAt.HasFderivAt.comp x
-        ((hasFderivAt_id x).sub (hasFderivAt_const t x))
+      (hg.differentiable le_rfl).DifferentiableAt.HasFDerivAt.comp x
+        ((hasFDerivAt_id x).sub (hasFDerivAt_const t x))
   let K' := -tsupport (fderiv 𝕜 g) + closed_ball x₀ 1
   have hK' : IsCompact K' := (hcg.fderiv 𝕜).neg.add (is_compact_closed_ball x₀ 1)
-  refine' hasFderivAt_integral_of_dominated_of_fderiv_le zero_lt_one h1 _ (h2 x₀) _ _ _
+  refine' hasFDerivAt_integral_of_dominated_of_fderiv_le zero_lt_one h1 _ (h2 x₀) _ _ _
   · exact K'.indicator fun t => ‖L'‖ * ‖f t‖ * ⨆ x, ‖fderiv 𝕜 g x‖
   · exact hcg.convolution_exists_right L hf hg.continuous x₀
   · refine' eventually_of_forall fun t x hx => _
@@ -1326,16 +1326,16 @@ theorem HasCompactSupport.hasFderivAt_convolution_right (hcg : HasCompactSupport
         (ball_subset_closed_ball hx)
   · rw [integrable_indicator_iff hK'.measurable_set]
     exact ((hf.integrable_on_is_compact hK').norm.const_mul _).mul_const _
-  · exact eventually_of_forall fun t x hx => (L _).HasFderivAt.comp x (h3 x t)
-#align has_compact_support.has_fderiv_at_convolution_right HasCompactSupport.hasFderivAt_convolution_right
+  · exact eventually_of_forall fun t x hx => (L _).HasFDerivAt.comp x (h3 x t)
+#align has_compact_support.has_fderiv_at_convolution_right HasCompactSupport.hasFDerivAt_convolution_right
 
-theorem HasCompactSupport.hasFderivAt_convolution_left [IsNegInvariant μ]
+theorem HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
     (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 1 f) (hg : LocallyIntegrable g μ) (x₀ : G) :
-    HasFderivAt (f ⋆[L, μ] g) ((fderiv 𝕜 f ⋆[L.precompL G, μ] g) x₀) x₀ :=
+    HasFDerivAt (f ⋆[L, μ] g) ((fderiv 𝕜 f ⋆[L.precompL G, μ] g) x₀) x₀ :=
   by
   simp (config := { singlePass := true }) only [← convolution_flip]
   exact hcf.has_fderiv_at_convolution_right L.flip hg hf x₀
-#align has_compact_support.has_fderiv_at_convolution_left HasCompactSupport.hasFderivAt_convolution_left
+#align has_compact_support.has_fderiv_at_convolution_left HasCompactSupport.hasFDerivAt_convolution_left
 
 end IsROrC
 
@@ -1403,11 +1403,11 @@ variable [IsROrC 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 
 and `g` is `C^1` and compactly supported. Version where `g` depends on an additional parameter in an
 open subset `s` of a parameter space `P` (and the compact support `k` is independent of the
 parameter in `s`). -/
-theorem hasFderivAt_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
+theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
     (hs : IsOpen s) (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
     (hf : LocallyIntegrable f μ) (hg : ContDiffOn 𝕜 1 (↿g) (s ×ˢ univ)) (q₀ : P × G)
     (hq₀ : q₀.1 ∈ s) :
-    HasFderivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2)
+    HasFDerivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2)
       ((f ⋆[L.precompR (P × G), μ] fun x : G => fderiv 𝕜 (↿g) (q₀.1, x)) q₀.2) q₀ :=
   by
   let g' := fderiv 𝕜 ↿g
@@ -1424,7 +1424,7 @@ theorem hasFderivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
   have g'_zero : ∀ p x, p ∈ s → x ∉ k → g' (p, x) = 0 :=
     by
     intro p x hp hx
-    refine' (hasFderivAt_zero_of_eventually_const 0 _).fderiv
+    refine' (hasFDerivAt_zero_of_eventually_const 0 _).fderiv
     have M2 : kᶜ ∈ 𝓝 x := IsOpen.mem_nhds hk.is_closed.is_open_compl hx
     have M1 : s ∈ 𝓝 p := hs.mem_nhds hp
     rw [nhds_prod_eq]
@@ -1541,27 +1541,27 @@ theorem hasFderivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     ∀ᵐ a : G ∂μ,
       ∀ x : P × G,
         dist x q₀ < δ →
-          HasFderivAt (fun x : P × G => L (f a) (g x.1 (x.2 - a)))
+          HasFDerivAt (fun x : P × G => L (f a) (g x.1 (x.2 - a)))
             ((L (f a)).comp (g' (x.fst, x.snd - a))) x :=
     by
     apply eventually_of_forall
     intro a x hx
-    apply (L _).HasFderivAt.comp x
+    apply (L _).HasFDerivAt.comp x
     have N : s ×ˢ univ ∈ 𝓝 (x.1, x.2 - a) := by
       apply A'
       apply h₀ε
       rw [Prod.dist_eq] at hx
       exact lt_of_lt_of_le (lt_of_le_of_lt (le_max_left _ _) hx) δε
-    have Z := ((hg.differentiable_on le_rfl).DifferentiableAt N).HasFderivAt
-    have Z' : HasFderivAt (fun x : P × G => (x.1, x.2 - a)) (ContinuousLinearMap.id 𝕜 (P × G)) x :=
+    have Z := ((hg.differentiable_on le_rfl).DifferentiableAt N).HasFDerivAt
+    have Z' : HasFDerivAt (fun x : P × G => (x.1, x.2 - a)) (ContinuousLinearMap.id 𝕜 (P × G)) x :=
       by
       have : (fun x : P × G => (x.1, x.2 - a)) = id - fun x => (0, a) := by
         ext x <;> simp only [Pi.sub_apply, id.def, Prod.fst_sub, sub_zero, Prod.snd_sub]
       simp_rw [this]
-      exact (hasFderivAt_id x).sub_const (0, a)
+      exact (hasFDerivAt_id x).sub_const (0, a)
     exact Z.comp x Z'
-  exact hasFderivAt_integral_of_dominated_of_fderiv_le δpos I1 I2 I3 I4 I5 I6
-#align has_fderiv_at_convolution_right_with_param hasFderivAt_convolution_right_with_param
+  exact hasFDerivAt_integral_of_dominated_of_fderiv_le δpos I1 I2 I3 I4 I5 I6
+#align has_fderiv_at_convolution_right_with_param hasFDerivAt_convolution_right_with_param
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -1592,8 +1592,8 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
       (f ⋆[L.precompR (P × G), μ] fun x : G => fderiv 𝕜 (uncurry g) (p, x)) a
     have A :
       ∀ q₀ : P × G,
-        q₀.1 ∈ s → HasFderivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (f' q₀.1 q₀.2) q₀ :=
-      hasFderivAt_convolution_right_with_param L hs hk hgs hf hg.one_of_succ
+        q₀.1 ∈ s → HasFDerivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (f' q₀.1 q₀.2) q₀ :=
+      hasFDerivAt_convolution_right_with_param L hs hk hgs hf hg.one_of_succ
     rw [contDiffOn_succ_iff_fderiv_of_open (hs.prod (@isOpen_univ G _))] at hg⊢
     constructor
     · rintro ⟨p, x⟩ ⟨hp, hx⟩
@@ -1605,7 +1605,7 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
       have B : ∀ (p : P) (x : G), p ∈ s → x ∉ k → fderiv 𝕜 (uncurry g) (p, x) = 0 :=
         by
         intro p x hp hx
-        apply (hasFderivAt_zero_of_eventually_const (0 : E') _).fderiv
+        apply (hasFDerivAt_zero_of_eventually_const (0 : E') _).fderiv
         have M2 : kᶜ ∈ 𝓝 x := IsOpen.mem_nhds hk.is_closed.is_open_compl hx
         have M1 : s ∈ 𝓝 p := hs.mem_nhds hp
         rw [nhds_prod_eq]

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

@@ -4,16 +4,17 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 
 ! This file was ported from Lean 3 source module analysis.convolution
-! leanprover-community/mathlib commit a75898643b2d774cced9ae7c0b28c21663b99666
+! leanprover-community/mathlib commit fd5edc43dc4f10b85abfe544b88f82cf13c5f844
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
+import Mathbin.Analysis.Calculus.BumpFunctionInner
+import Mathbin.Analysis.Calculus.ParametricIntegral
+import Mathbin.MeasureTheory.Constructions.Prod.Integral
+import Mathbin.MeasureTheory.Function.LocallyIntegrable
 import Mathbin.MeasureTheory.Group.Integration
 import Mathbin.MeasureTheory.Group.Prod
-import Mathbin.MeasureTheory.Function.LocallyIntegrable
-import Mathbin.Analysis.Calculus.BumpFunctionInner
 import Mathbin.MeasureTheory.Integral.IntervalIntegral
-import Mathbin.Analysis.Calculus.ParametricIntegral
 
 /-!
 # Convolution of functions

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

@@ -139,7 +139,7 @@ theorem HasCompactSupport.convolution_integrand_bound_right_of_subset (hcg : Has
     ‖L (f t) (g (x - t))‖ ≤ u.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖) t :=
   by
   apply convolution_integrand_bound_right_of_le_of_subset _ (fun i => _) hx hu
-  exact le_csupᵢ (hg.norm.bdd_above_range_of_has_compact_support hcg.norm) _
+  exact le_ciSup (hg.norm.bdd_above_range_of_has_compact_support hcg.norm) _
 #align has_compact_support.convolution_integrand_bound_right_of_subset HasCompactSupport.convolution_integrand_bound_right_of_subset
 
 theorem HasCompactSupport.convolution_integrand_bound_right (hcg : HasCompactSupport g)
@@ -239,7 +239,7 @@ theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
     refine' le_indicator (fun t ht => _) fun t ht => _
     · refine' (L.le_op_norm₂ _ _).trans _
       refine'
-        mul_le_mul_of_nonneg_left (le_csupᵢ_set hbg <| mem_preimage.mpr _)
+        mul_le_mul_of_nonneg_left (le_ciSup_set hbg <| mem_preimage.mpr _)
           (mul_nonneg (norm_nonneg _) (norm_nonneg _))
       rwa [neg_sub, sub_add_cancel]
     · have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
@@ -813,7 +813,7 @@ theorem BddAbove.continuous_convolution_right_of_integrable [SecondCountableTopo
     refine' eventually_of_forall fun x => eventually_of_forall fun t => _
     refine' (L.le_op_norm₂ _ _).trans _
     exact
-      mul_le_mul_of_nonneg_left (le_csupᵢ hbg <| x - t) (mul_nonneg (norm_nonneg _) (norm_nonneg _))
+      mul_le_mul_of_nonneg_left (le_ciSup hbg <| x - t) (mul_nonneg (norm_nonneg _) (norm_nonneg _))
   refine' continuous_at_of_dominated _ this _ _
   ·
     exact

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

@@ -196,8 +196,8 @@ section Group
 
 variable [AddGroup G]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand' [HasMeasurableAdd₂ G]
-    [HasMeasurableNeg G] [SigmaFinite ν] (hf : AeStronglyMeasurable f ν)
+theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand' [MeasurableAdd₂ G]
+    [MeasurableNeg G] [SigmaFinite ν] (hf : AeStronglyMeasurable f ν)
     (hg : AeStronglyMeasurable g <| map (fun p : G × G => p.1 - p.2) (μ.Prod ν)) :
     AeStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
   L.aeStronglyMeasurable_comp₂ hf.snd <| hg.comp_measurable measurable_sub
@@ -205,7 +205,7 @@ theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand' [HasMeasurable
 
 section
 
-variable [HasMeasurableAdd G] [HasMeasurableNeg G]
+variable [MeasurableAdd G] [MeasurableNeg G]
 
 theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd'
     (hf : AeStronglyMeasurable f μ) {x : G}
@@ -266,7 +266,7 @@ end
 
 section Left
 
-variable [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
 theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd (hf : AeStronglyMeasurable f μ)
     (hg : AeStronglyMeasurable g μ) (x : G) :
@@ -297,7 +297,7 @@ end Left
 
 section Right
 
-variable [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
   [SigmaFinite ν]
 
 theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand (hf : AeStronglyMeasurable f ν)
@@ -393,7 +393,7 @@ variable [AddCommGroup G]
 
 section MeasurableGroup
 
-variable [HasMeasurableNeg G] [IsAddLeftInvariant μ]
+variable [MeasurableNeg G] [IsAddLeftInvariant μ]
 
 /-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
 We assume that the integrand has compact support and `g` is bounded on this support (note that
@@ -402,7 +402,7 @@ integrable on the support of the integrand, and that both functions are strongly
 
 This is a variant of `bdd_above.convolution_exists_at'` in an abelian group with a left-invariant
 measure. This allows us to state the boundedness and measurability of `g` in a more natural way. -/
-theorem BddAbove.convolutionExistsAt [HasMeasurableAdd₂ G] [SigmaFinite μ] {x₀ : G} {s : Set G}
+theorem BddAbove.convolutionExistsAt [MeasurableAdd₂ G] [SigmaFinite μ] {x₀ : G} {s : Set G}
     (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => x₀ - t) ⁻¹' s))) (hs : MeasurableSet s)
     (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
     (hmg : AeStronglyMeasurable g μ) : ConvolutionExistsAt f g x₀ L μ :=
@@ -416,7 +416,7 @@ theorem BddAbove.convolutionExistsAt [HasMeasurableAdd₂ G] [SigmaFinite μ] {x
       map_mono_of_ae_measurable restrict_le_self (measurable_const.sub measurable_id').AEMeasurable
 #align bdd_above.convolution_exists_at BddAbove.convolutionExistsAt
 
-variable {L} [HasMeasurableAdd G] [IsNegInvariant μ]
+variable {L} [MeasurableAdd G] [IsNegInvariant μ]
 
 theorem convolutionExistsAt_flip :
     ConvolutionExistsAt g f x L.flip μ ↔ ConvolutionExistsAt f g x L μ := by
@@ -570,7 +570,7 @@ theorem convolution_mono_right_of_nonneg {f g g' : G → ℝ}
 
 variable (L)
 
-theorem convolution_congr [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [SigmaFinite μ]
+theorem convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ]
     [IsAddRightInvariant μ] (h1 : f =ᵐ[μ] f') (h2 : g =ᵐ[μ] g') : f ⋆[L, μ] g = f' ⋆[L, μ] g' :=
   by
   ext x
@@ -599,7 +599,7 @@ theorem support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g
 
 section
 
-variable [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
+variable [MeasurableAdd₂ G] [MeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
 theorem MeasureTheory.Integrable.integrable_convolution (hf : Integrable f μ)
     (hg : Integrable g μ) : Integrable (f ⋆[L, μ] g) μ :=
@@ -841,9 +841,9 @@ variable [IsAddLeftInvariant μ] [IsNegInvariant μ]
 
 section Measurable
 
-variable [HasMeasurableNeg G]
+variable [MeasurableNeg G]
 
-variable [HasMeasurableAdd G]
+variable [MeasurableAdd G]
 
 variable (L)
 
@@ -1174,7 +1174,7 @@ variable [AddGroup G]
 
 variable [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ]
 
-theorem integral_convolution [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [NormedSpace ℝ E]
+theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace ℝ E]
     [NormedSpace ℝ E'] [CompleteSpace E] [CompleteSpace E'] (hf : Integrable f ν)
     (hg : Integrable g μ) : (∫ x, (f ⋆[L, ν] g) x ∂μ) = L (∫ x, f x ∂ν) (∫ x, g x ∂μ) :=
   by
@@ -1183,7 +1183,7 @@ theorem integral_convolution [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [Norme
   exact (L.flip (∫ x, g x ∂μ)).integral_comp_comm hf
 #align integral_convolution integral_convolution
 
-variable [HasMeasurableAdd₂ G] [IsAddRightInvariant ν] [HasMeasurableNeg G]
+variable [MeasurableAdd₂ G] [IsAddRightInvariant ν] [MeasurableNeg G]
 
 /-- Convolution is associative. This has a weak but inconvenient integrability condition.
 See also `convolution_assoc`. -/

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

@@ -1081,7 +1081,7 @@ theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.r, g x = g
 
 variable [BorelSpace G]
 
-variable [LocallyFiniteMeasure μ] [IsOpenPosMeasure μ]
+variable [LocallyFiniteMeasure μ] [OpenPosMeasure μ]
 
 variable [FiniteDimensional ℝ G]
 

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

@@ -1081,7 +1081,7 @@ theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.r, g x = g
 
 variable [BorelSpace G]
 
-variable [IsLocallyFiniteMeasure μ] [IsOpenPosMeasure μ]
+variable [LocallyFiniteMeasure μ] [IsOpenPosMeasure μ]
 
 variable [FiniteDimensional ℝ G]
 
@@ -1775,7 +1775,7 @@ noncomputable def posConvolution (f : ℝ → E) (g : ℝ → E') (L : E →L[
 #align pos_convolution posConvolution
 
 theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E') (L : E →L[ℝ] E' →L[ℝ] F)
-    (ν : Measure ℝ := by exact MeasureTheory.MeasureSpace.volume) [HasNoAtoms ν] :
+    (ν : Measure ℝ := by exact MeasureTheory.MeasureSpace.volume) [NoAtoms ν] :
     posConvolution f g L ν = convolution (indicator (Ioi 0) f) (indicator (Ioi 0) g) L ν :=
   by
   ext1 x
@@ -1812,7 +1812,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
 #align pos_convolution_eq_convolution_indicator posConvolution_eq_convolution_indicator
 
 theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measure ℝ} [SigmaFinite μ]
-    [SigmaFinite ν] [IsAddRightInvariant μ] [HasNoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
+    [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
     (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     Integrable (posConvolution f g L ν) μ :=
   by
@@ -1824,7 +1824,7 @@ theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Meas
 /-- The integral over `Ioi 0` of a forward convolution of two functions is equal to the product
 of their integrals over this set. (Compare `integral_convolution` for the two-sided convolution.) -/
 theorem integral_pos_convolution [CompleteSpace E] [CompleteSpace E'] {μ ν : Measure ℝ}
-    [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ] [HasNoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
+    [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
     (hf : IntegrableOn f (Ioi 0) ν) (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     (∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0 ..x, L (f t) (g (x - t)) ∂ν ∂μ) =
       L (∫ x : ℝ in Ioi 0, f x ∂ν) (∫ x : ℝ in Ioi 0, g x ∂μ) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/92c69b77c5a7dc0f7eeddb552508633305157caa

@@ -196,28 +196,29 @@ section Group
 
 variable [AddGroup G]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolutionIntegrand' [HasMeasurableAdd₂ G]
+theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand' [HasMeasurableAdd₂ G]
     [HasMeasurableNeg G] [SigmaFinite ν] (hf : AeStronglyMeasurable f ν)
     (hg : AeStronglyMeasurable g <| map (fun p : G × G => p.1 - p.2) (μ.Prod ν)) :
     AeStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
-  L.aeStronglyMeasurableComp₂ hf.snd <| hg.compMeasurable measurable_sub
-#align measure_theory.ae_strongly_measurable.convolution_integrand' MeasureTheory.AeStronglyMeasurable.convolutionIntegrand'
+  L.aeStronglyMeasurable_comp₂ hf.snd <| hg.comp_measurable measurable_sub
+#align measure_theory.ae_strongly_measurable.convolution_integrand' MeasureTheory.AeStronglyMeasurable.convolution_integrand'
 
 section
 
 variable [HasMeasurableAdd G] [HasMeasurableNeg G]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolutionIntegrandSnd' (hf : AeStronglyMeasurable f μ)
-    {x : G} (hg : AeStronglyMeasurable g <| map (fun t => x - t) μ) :
+theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd'
+    (hf : AeStronglyMeasurable f μ) {x : G}
+    (hg : AeStronglyMeasurable g <| map (fun t => x - t) μ) :
     AeStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
-  L.aeStronglyMeasurableComp₂ hf <| hg.compMeasurable <| measurable_id.const_sub x
-#align measure_theory.ae_strongly_measurable.convolution_integrand_snd' MeasureTheory.AeStronglyMeasurable.convolutionIntegrandSnd'
+  L.aeStronglyMeasurable_comp₂ hf <| hg.comp_measurable <| measurable_id.const_sub x
+#align measure_theory.ae_strongly_measurable.convolution_integrand_snd' MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd'
 
-theorem MeasureTheory.AeStronglyMeasurable.convolutionIntegrandSwapSnd' {x : G}
+theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_swap_snd' {x : G}
     (hf : AeStronglyMeasurable f <| map (fun t => x - t) μ) (hg : AeStronglyMeasurable g μ) :
     AeStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
-  L.aeStronglyMeasurableComp₂ (hf.compMeasurable <| measurable_id.const_sub x) hg
-#align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd' MeasureTheory.AeStronglyMeasurable.convolutionIntegrandSwapSnd'
+  L.aeStronglyMeasurable_comp₂ (hf.comp_measurable <| measurable_id.const_sub x) hg
+#align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd' MeasureTheory.AeStronglyMeasurable.convolution_integrand_swap_snd'
 
 /-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
 We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
@@ -267,21 +268,21 @@ section Left
 
 variable [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolutionIntegrandSnd (hf : AeStronglyMeasurable f μ)
+theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd (hf : AeStronglyMeasurable f μ)
     (hg : AeStronglyMeasurable g μ) (x : G) :
     AeStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
-  hf.convolutionIntegrandSnd' L <|
-    hg.mono' <| (quasi_measure_preserving_sub_left_of_right_invariant μ x).AbsolutelyContinuous
-#align measure_theory.ae_strongly_measurable.convolution_integrand_snd MeasureTheory.AeStronglyMeasurable.convolutionIntegrandSnd
+  hf.convolution_integrand_snd' L <|
+    hg.mono' <| (quasiMeasurePreserving_sub_left_of_right_invariant μ x).AbsolutelyContinuous
+#align measure_theory.ae_strongly_measurable.convolution_integrand_snd MeasureTheory.AeStronglyMeasurable.convolution_integrand_snd
 
-theorem MeasureTheory.AeStronglyMeasurable.convolutionIntegrandSwapSnd
+theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand_swap_snd
     (hf : AeStronglyMeasurable f μ) (hg : AeStronglyMeasurable g μ) (x : G) :
     AeStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
   (hf.mono'
-        (quasi_measure_preserving_sub_left_of_right_invariant μ
-            x).AbsolutelyContinuous).convolutionIntegrandSwapSnd'
+        (quasiMeasurePreserving_sub_left_of_right_invariant μ
+            x).AbsolutelyContinuous).convolution_integrand_swap_snd'
     L hg
-#align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd MeasureTheory.AeStronglyMeasurable.convolutionIntegrandSwapSnd
+#align measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd MeasureTheory.AeStronglyMeasurable.convolution_integrand_swap_snd
 
 /-- If `‖f‖ *[μ] ‖g‖` exists, then `f *[L, μ] g` exists. -/
 theorem ConvolutionExistsAt.ofNorm {x₀ : G}
@@ -289,7 +290,7 @@ theorem ConvolutionExistsAt.ofNorm {x₀ : G}
     (hmf : AeStronglyMeasurable f μ) (hmg : AeStronglyMeasurable g μ) :
     ConvolutionExistsAt f g x₀ L μ :=
   h.ofNorm' L hmf <|
-    hmg.mono' (quasi_measure_preserving_sub_left_of_right_invariant μ x₀).AbsolutelyContinuous
+    hmg.mono' (quasiMeasurePreserving_sub_left_of_right_invariant μ x₀).AbsolutelyContinuous
 #align convolution_exists_at.of_norm ConvolutionExistsAt.ofNorm
 
 end Left
@@ -299,14 +300,14 @@ section Right
 variable [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
   [SigmaFinite ν]
 
-theorem MeasureTheory.AeStronglyMeasurable.convolutionIntegrand (hf : AeStronglyMeasurable f ν)
+theorem MeasureTheory.AeStronglyMeasurable.convolution_integrand (hf : AeStronglyMeasurable f ν)
     (hg : AeStronglyMeasurable g μ) :
     AeStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
-  hf.convolutionIntegrand' L <|
-    hg.mono' (quasi_measure_preserving_sub_of_right_invariant μ ν).AbsolutelyContinuous
-#align measure_theory.ae_strongly_measurable.convolution_integrand MeasureTheory.AeStronglyMeasurable.convolutionIntegrand
+  hf.convolution_integrand' L <|
+    hg.mono' (quasiMeasurePreserving_sub_of_right_invariant μ ν).AbsolutelyContinuous
+#align measure_theory.ae_strongly_measurable.convolution_integrand MeasureTheory.AeStronglyMeasurable.convolution_integrand
 
-theorem MeasureTheory.Integrable.convolutionIntegrand (hf : Integrable f ν) (hg : Integrable g μ) :
+theorem MeasureTheory.Integrable.convolution_integrand (hf : Integrable f ν) (hg : Integrable g μ) :
     Integrable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.Prod ν) :=
   by
   have h_meas : ae_strongly_measurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.prod ν) :=
@@ -327,13 +328,13 @@ theorem MeasureTheory.Integrable.convolutionIntegrand (hf : Integrable f ν) (hg
         integral_mono_of_nonneg (eventually_of_forall fun t => norm_nonneg _)
           ((hg.comp_sub_right t).norm.const_mul _) (eventually_of_forall fun t => L.le_op_norm₂ _ _)
     exact integral_nonneg fun x => norm_nonneg _
-#align measure_theory.integrable.convolution_integrand MeasureTheory.Integrable.convolutionIntegrand
+#align measure_theory.integrable.convolution_integrand MeasureTheory.Integrable.convolution_integrand
 
 theorem MeasureTheory.Integrable.ae_convolution_exists (hf : Integrable f ν) (hg : Integrable g μ) :
     ∀ᵐ x ∂μ, ConvolutionExistsAt f g x L ν :=
   ((integrable_prod_iff <|
-          hf.AeStronglyMeasurable.convolutionIntegrand L hg.AeStronglyMeasurable).mp <|
-      hf.convolutionIntegrand L hg).1
+          hf.AeStronglyMeasurable.convolution_integrand L hg.AeStronglyMeasurable).mp <|
+      hf.convolution_integrand L hg).1
 #align measure_theory.integrable.ae_convolution_exists MeasureTheory.Integrable.ae_convolution_exists
 
 end Right
@@ -352,7 +353,7 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
   have A :
     ae_strongly_measurable (g ∘ ⇑v) (μ.restrict (tsupport fun t : G => (L (f t)) (g (x₀ - t)))) :=
     by
-    apply (hg.comp v.continuous).ContinuousOn.aeStronglyMeasurableOfIsCompact h
+    apply (hg.comp v.continuous).ContinuousOn.aeStronglyMeasurable_of_isCompact h
     exact (isClosed_tsupport _).MeasurableSet
   convert((v.continuous.measurable.measure_preserving
               (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aeStronglyMeasurable_comp_iff
@@ -412,7 +413,7 @@ theorem BddAbove.convolutionExistsAt [HasMeasurableAdd₂ G] [SigmaFinite μ] {x
       hmg.mono' (quasi_measure_preserving_sub_left_of_right_invariant μ x₀).AbsolutelyContinuous
     apply this.mono_measure
     exact
-      map_mono_of_ae_measurable restrict_le_self (measurable_const.sub measurable_id').AeMeasurable
+      map_mono_of_ae_measurable restrict_le_self (measurable_const.sub measurable_id').AEMeasurable
 #align bdd_above.convolution_exists_at BddAbove.convolutionExistsAt
 
 variable {L} [HasMeasurableAdd G] [IsNegInvariant μ]
@@ -423,12 +424,12 @@ theorem convolutionExistsAt_flip :
     sub_sub_cancel, flip_apply]
 #align convolution_exists_at_flip convolutionExistsAt_flip
 
-theorem ConvolutionExistsAt.integrableSwap (h : ConvolutionExistsAt f g x L μ) :
+theorem ConvolutionExistsAt.integrable_swap (h : ConvolutionExistsAt f g x L μ) :
     Integrable (fun t => L (f (x - t)) (g t)) μ :=
   by
   convert h.comp_sub_left x
   simp_rw [sub_sub_self]
-#align convolution_exists_at.integrable_swap ConvolutionExistsAt.integrableSwap
+#align convolution_exists_at.integrable_swap ConvolutionExistsAt.integrable_swap
 
 theorem convolutionExistsAt_iff_integrable_swap :
     ConvolutionExistsAt f g x L μ ↔ Integrable (fun t => L (f (x - t)) (g t)) μ :=
@@ -600,10 +601,10 @@ section
 
 variable [HasMeasurableAdd₂ G] [HasMeasurableNeg G] [SigmaFinite μ] [IsAddRightInvariant μ]
 
-theorem MeasureTheory.Integrable.integrableConvolution (hf : Integrable f μ) (hg : Integrable g μ) :
-    Integrable (f ⋆[L, μ] g) μ :=
-  (hf.convolutionIntegrand L hg).integral_prod_left
-#align measure_theory.integrable.integrable_convolution MeasureTheory.Integrable.integrableConvolution
+theorem MeasureTheory.Integrable.integrable_convolution (hf : Integrable f μ)
+    (hg : Integrable g μ) : Integrable (f ⋆[L, μ] g) μ :=
+  (hf.convolution_integrand L hg).integral_prod_left
+#align measure_theory.integrable.integrable_convolution MeasureTheory.Integrable.integrable_convolution
 
 end
 
@@ -1234,7 +1235,7 @@ theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z =
     by
     refine' L₃.ae_strongly_measurable_comp₂ hf.snd _
     refine' L₄.ae_strongly_measurable_comp₂ hg.fst _
-    refine' (hk.mono' _).compMeasurable ((measurable_const.sub measurable_snd).sub measurable_fst)
+    refine' (hk.mono' _).comp_measurable ((measurable_const.sub measurable_snd).sub measurable_fst)
     refine' quasi_measure_preserving.absolutely_continuous _
     refine'
       quasi_measure_preserving.prod_of_left
@@ -1810,7 +1811,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
         ContinuousLinearMap.zero_apply]
 #align pos_convolution_eq_convolution_indicator posConvolution_eq_convolution_indicator
 
-theorem integrablePosConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measure ℝ} [SigmaFinite μ]
+theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measure ℝ} [SigmaFinite μ]
     [SigmaFinite ν] [IsAddRightInvariant μ] [HasNoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
     (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
     Integrable (posConvolution f g L ν) μ :=
@@ -1818,7 +1819,7 @@ theorem integrablePosConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measu
   rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg
   rw [posConvolution_eq_convolution_indicator f g L ν]
   exact (hf.convolution_integrand L hg).integral_prod_left
-#align integrable_pos_convolution integrablePosConvolution
+#align integrable_pos_convolution integrable_posConvolution
 
 /-- The integral over `Ioi 0` of a forward convolution of two functions is equal to the product
 of their integrals over this set. (Compare `integral_convolution` for the two-sided convolution.) -/

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

@@ -354,8 +354,7 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
     by
     apply (hg.comp v.continuous).ContinuousOn.aeStronglyMeasurableOfIsCompact h
     exact (isClosed_tsupport _).MeasurableSet
-  convert
-    ((v.continuous.measurable.measure_preserving
+  convert((v.continuous.measurable.measure_preserving
               (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aeStronglyMeasurable_comp_iff
           v.to_measurable_equiv.measurable_embedding).1
       A
@@ -1013,7 +1012,7 @@ theorem dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'}
   have hif : integrable f μ := by
     by_contra hif
     exact zero_ne_one ((integral_undef hif).symm.trans hintf)
-  convert (dist_convolution_le' _ hε hif hf hmg hg).trans _
+  convert(dist_convolution_le' _ hε hif hf hmg hg).trans _
   · simp_rw [lsmul_apply, integral_smul_const, hintf, one_smul]
   · simp_rw [Real.norm_of_nonneg (hnf _), hintf, mul_one]
     exact (mul_le_mul_of_nonneg_right op_norm_lsmul_le hε).trans_eq (one_mul ε)
@@ -1367,7 +1366,7 @@ theorem HasCompactSupport.hasDerivAt_convolution_right (hf : LocallyIntegrable f
     (hcg : HasCompactSupport g₀) (hg : ContDiff 𝕜 1 g₀) (x₀ : 𝕜) :
     HasDerivAt (f₀ ⋆[L, μ] g₀) ((f₀ ⋆[L, μ] deriv g₀) x₀) x₀ :=
   by
-  convert (hcg.has_fderiv_at_convolution_right L hf hg x₀).HasDerivAt
+  convert(hcg.has_fderiv_at_convolution_right L hf hg x₀).HasDerivAt
   rw [convolution_precompR_apply L hf (hcg.fderiv 𝕜) (hg.continuous_fderiv le_rfl)]
   rfl
 #align has_compact_support.has_deriv_at_convolution_right HasCompactSupport.hasDerivAt_convolution_right
@@ -1800,7 +1799,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
     ·
       rw [indicator_of_not_mem (not_mem_Ioo_of_ge ht),
         indicator_of_not_mem (not_mem_Ioi.mpr (sub_nonpos_of_le ht)), ContinuousLinearMap.map_zero]
-  · convert (integral_zero ℝ F).symm
+  · convert(integral_zero ℝ F).symm
     ext1 t
     by_cases ht : 0 < t
     · rw [indicator_of_not_mem (_ : x - t ∉ Ioi 0), ContinuousLinearMap.map_zero]

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

@@ -979,7 +979,7 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
       refine' ((L (f t)).dist_le_op_norm _ _).trans _
       exact mul_le_mul_of_nonneg_left (hg h2t) (norm_nonneg _)
     · rw [nmem_support] at ht
-      simp_rw [ht, L.map_zero₂, L.map_zero, norm_zero, zero_mul, dist_self]
+      simp_rw [ht, L.map_zero₂, L.map_zero, norm_zero, MulZeroClass.zero_mul, dist_self]
   simp_rw [convolution_def]
   simp_rw [dist_eq_norm] at h2⊢
   rw [← integral_sub hfg.integrable]

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

@@ -1195,7 +1195,7 @@ theorem convolution_assoc' (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z
   calc
     ((f ⋆[L, ν] g) ⋆[L₂, μ] k) x₀ = ∫ t, L₂ (∫ s, L (f s) (g (t - s)) ∂ν) (k (x₀ - t)) ∂μ := rfl
     _ = ∫ t, ∫ s, L₂ (L (f s) (g (t - s))) (k (x₀ - t)) ∂ν ∂μ :=
-      integral_congr_ae (hfg.mono fun t ht => ((L₂.flip (k (x₀ - t))).integral_comp_comm ht).symm)
+      (integral_congr_ae (hfg.mono fun t ht => ((L₂.flip (k (x₀ - t))).integral_comp_comm ht).symm))
     _ = ∫ t, ∫ s, L₃ (f s) (L₄ (g (t - s)) (k (x₀ - t))) ∂ν ∂μ := by simp_rw [hL]
     _ = ∫ s, ∫ t, L₃ (f s) (L₄ (g (t - s)) (k (x₀ - t))) ∂μ ∂ν := by rw [integral_integral_swap hi]
     _ = ∫ s, ∫ u, L₃ (f s) (L₄ (g u) (k (x₀ - s - u))) ∂μ ∂ν :=

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

@@ -148,7 +148,7 @@ theorem HasCompactSupport.convolution_integrand_bound_right (hcg : HasCompactSup
   hcg.convolution_integrand_bound_right_of_subset L hg hx Subset.rfl
 #align has_compact_support.convolution_integrand_bound_right HasCompactSupport.convolution_integrand_bound_right
 
-theorem Continuous.convolution_integrand_fst [HasContinuousSub G] (hg : Continuous g) (t : G) :
+theorem Continuous.convolution_integrand_fst [ContinuousSub G] (hg : Continuous g) (t : G) :
     Continuous fun x => L (f t) (g (x - t)) :=
   L.continuous₂.comp₂ continuous_const <| hg.comp <| continuous_id.sub continuous_const
 #align continuous.convolution_integrand_fst Continuous.convolution_integrand_fst
@@ -362,7 +362,7 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
   ext x
   simp only [Homeomorph.neg, sub_eq_add_neg, coe_toAddUnits, Homeomorph.trans_apply,
     Equiv.neg_apply, Equiv.toFun_as_coe, Homeomorph.homeomorph_mk_coe, Equiv.coe_fn_mk,
-    Homeomorph.coe_add_left]
+    Homeomorph.coe_addLeft]
 #align has_compact_support.convolution_exists_at HasCompactSupport.convolutionExistsAt
 
 theorem HasCompactSupport.convolutionExistsRight (hcg : HasCompactSupport g)

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

These are changes from #11997, the latest adaptation PR for nightly-2024-04-07, which can be made directly on master.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

@@ -652,7 +652,7 @@ theorem continuousOn_convolution_right_with_param_comp {s : Set P} {v : P → G}
   apply
     (continuousOn_convolution_right_with_param L hk hgs hf hg).comp (continuousOn_id.prod hv)
   intro x hx
-  simp only [hx, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, id.def]
+  simp only [hx, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, _root_.id]
 #align continuous_on_convolution_right_with_param_comp' continuousOn_convolution_right_with_param_comp
 #align continuous_on_convolution_right_with_param_comp continuousOn_convolution_right_with_param_comp
 
@@ -1237,7 +1237,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     have Z' :
         HasFDerivAt (fun x : P × G => (x.1, x.2 - a)) (ContinuousLinearMap.id 𝕜 (P × G)) x := by
       have : (fun x : P × G => (x.1, x.2 - a)) = _root_.id - fun x => (0, a) := by
-        ext x <;> simp only [Pi.sub_apply, id.def, Prod.fst_sub, sub_zero, Prod.snd_sub]
+        ext x <;> simp only [Pi.sub_apply, _root_.id, Prod.fst_sub, sub_zero, Prod.snd_sub]
       rw [this]
       exact (hasFDerivAt_id x).sub_const (0, a)
     exact Z.comp x Z'
@@ -1374,7 +1374,7 @@ theorem contDiffOn_convolution_right_with_param_comp {n : ℕ∞} (L : E →L[
     (hg : ContDiffOn 𝕜 n (↿g) (s ×ˢ univ)) : ContDiffOn 𝕜 n (fun x => (f ⋆[L, μ] g x) (v x)) s := by
   apply (contDiffOn_convolution_right_with_param L hs hk hgs hf hg).comp (contDiffOn_id.prod hv)
   intro x hx
-  simp only [hx, mem_preimage, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, id.def]
+  simp only [hx, mem_preimage, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, _root_.id]
 #align cont_diff_on_convolution_right_with_param_comp contDiffOn_convolution_right_with_param_comp
 
 /-- The convolution `g * f` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
@@ -1399,7 +1399,7 @@ theorem contDiffOn_convolution_left_with_param_comp [μ.IsAddLeftInvariant] [μ.
     (hg : ContDiffOn 𝕜 n (↿g) (s ×ˢ univ)) : ContDiffOn 𝕜 n (fun x => (g x ⋆[L, μ] f) (v x)) s := by
   apply (contDiffOn_convolution_left_with_param L hs hk hgs hf hg).comp (contDiffOn_id.prod hv)
   intro x hx
-  simp only [hx, mem_preimage, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, id.def]
+  simp only [hx, mem_preimage, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, _root_.id]
 #align cont_diff_on_convolution_left_with_param_comp contDiffOn_convolution_left_with_param_comp
 
 theorem HasCompactSupport.contDiff_convolution_right {n : ℕ∞} (hcg : HasCompactSupport g)

Quoting [@digama0](https://github.com/digama0):

These were actually never meant to go in the file, they are basically debugging information and only useful on significantly broken mathport files. You can safely remove all of them.

@@ -440,16 +440,13 @@ noncomputable def convolution [Sub G] (f : G → E) (g : G → E') (L : E →L[
   ∫ t, L (f t) (g (x - t)) ∂μ
 #align convolution convolution
 
--- mathport name: convolution
 /-- The convolution of two functions with respect to a bilinear operation `L` and a measure `μ`. -/
 scoped[Convolution] notation:67 f " ⋆[" L:67 ", " μ:67 "] " g:66 => convolution f g L μ
 
--- mathport name: convolution.volume
 /-- The convolution of two functions with respect to a bilinear operation `L` and the volume. -/
 scoped[Convolution]
   notation:67 f " ⋆[" L:67 "]" g:66 => convolution f g L MeasureTheory.MeasureSpace.volume
 
--- mathport name: convolution.lsmul
 /-- The convolution of two real-valued functions with respect to volume. -/
 scoped[Convolution]
   notation:67 f " ⋆ " g:66 =>

IsROrC contains data, which goes against the expectation that classes prefixed with Is are prop-valued. People have been complaining about this on and off, so this PR renames IsROrC to RCLike.

@@ -899,9 +899,8 @@ end NontriviallyNormedField
 
 open scoped Convolution
 
-section IsROrC
-
-variable [IsROrC 𝕜]
+section RCLike
+variable [RCLike 𝕜]
 variable [NormedSpace 𝕜 E]
 variable [NormedSpace 𝕜 E']
 variable [NormedSpace 𝕜 E'']
@@ -1031,7 +1030,7 @@ theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport
   · have : fderiv 𝕜 (0 : G → E') = 0 := fderiv_const (0 : E')
     simp only [this, convolution_zero, Pi.zero_apply]
     exact hasFDerivAt_const (0 : F) x₀
-  have : ProperSpace G := FiniteDimensional.proper_isROrC 𝕜 G
+  have : ProperSpace G := FiniteDimensional.proper_rclike 𝕜 G
   set L' := L.precompR G
   have h1 : ∀ᶠ x in 𝓝 x₀, AEStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
     eventually_of_forall
@@ -1065,12 +1064,13 @@ theorem HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
   exact hcf.hasFDerivAt_convolution_right L.flip hg hf x₀
 #align has_compact_support.has_fderiv_at_convolution_left HasCompactSupport.hasFDerivAt_convolution_left
 
-end IsROrC
+end RCLike
 
 section Real
 
 /-! The one-variable case -/
-variable [IsROrC 𝕜]
+
+variable [RCLike 𝕜]
 variable [NormedSpace 𝕜 E]
 variable [NormedSpace 𝕜 E']
 variable [NormedSpace ℝ F] [NormedSpace 𝕜 F]
@@ -1100,7 +1100,7 @@ end Real
 
 section WithParam
 
-variable [IsROrC 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 𝕜 E''] [NormedSpace ℝ F]
+variable [RCLike 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 𝕜 E''] [NormedSpace ℝ F]
   [NormedSpace 𝕜 F] [CompleteSpace F] [MeasurableSpace G] [NormedAddCommGroup G] [BorelSpace G]
   [NormedSpace 𝕜 G] [NormedAddCommGroup P] [NormedSpace 𝕜 P] {μ : MeasureTheory.Measure G}
   (L : E →L[𝕜] E' →L[𝕜] F)

Inspired by #10538 add a positivity extension for Bochner integrals.

@@ -308,10 +308,9 @@ theorem MeasureTheory.Integrable.convolution_integrand (hf : Integrable f ν) (h
   · simp only [integral_sub_right_eq_self (‖g ·‖)]
     exact (hf.norm.const_mul _).mul_const _
   · simp_rw [← integral_mul_left]
-    rw [Real.norm_of_nonneg]
-    · exact integral_mono_of_nonneg (eventually_of_forall fun t => norm_nonneg _)
-        ((hg.comp_sub_right t).norm.const_mul _) (eventually_of_forall fun t => L.le_opNorm₂ _ _)
-    exact integral_nonneg fun x => norm_nonneg _
+    rw [Real.norm_of_nonneg (by positivity)]
+    exact integral_mono_of_nonneg (eventually_of_forall fun t => norm_nonneg _)
+      ((hg.comp_sub_right t).norm.const_mul _) (eventually_of_forall fun t => L.le_opNorm₂ _ _)
 #align measure_theory.integrable.convolution_integrand MeasureTheory.Integrable.convolution_integrand
 
 theorem MeasureTheory.Integrable.ae_convolution_exists (hf : Integrable f ν) (hg : Integrable g μ) :
@@ -1000,12 +999,11 @@ theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z =
   refine' (hfgk.const_mul (‖L₃‖ * ‖L₄‖)).mono' h2_meas
     (((quasiMeasurePreserving_sub_left_of_right_invariant ν x₀).ae hgk).mono fun t ht => _)
   · simp_rw [convolution_def, mul_apply', mul_mul_mul_comm ‖L₃‖ ‖L₄‖, ← integral_mul_left]
-    rw [Real.norm_of_nonneg]
-    · refine' integral_mono_of_nonneg (eventually_of_forall fun t => norm_nonneg _)
-        ((ht.const_mul _).const_mul _) (eventually_of_forall fun s => _)
-      simp only [← mul_assoc ‖L₄‖]
-      apply_rules [ContinuousLinearMap.le_of_opNorm₂_le_of_le, le_rfl]
-    exact integral_nonneg fun x => norm_nonneg _
+    rw [Real.norm_of_nonneg (by positivity)]
+    refine' integral_mono_of_nonneg (eventually_of_forall fun t => norm_nonneg _)
+      ((ht.const_mul _).const_mul _) (eventually_of_forall fun s => _)
+    simp only [← mul_assoc ‖L₄‖]
+    apply_rules [ContinuousLinearMap.le_of_opNorm₂_le_of_le, le_rfl]
 #align convolution_assoc convolution_assoc
 
 end Assoc

This is presumably not exhaustive, but covers about a hundred instances.

Style opinions (e.g., why a particular change is great/not a good idea) are very welcome; I'm still forming my own.

@@ -227,7 +227,7 @@ theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
   set s' := (fun t => -t + x₀) ⁻¹' s
   have : ∀ᵐ t : G ∂μ.restrict s,
       ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t := by
-    refine' eventually_of_forall _
+    filter_upwards
     refine' le_indicator (fun t ht => _) fun t ht => _
     · apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl]
       refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
@@ -680,7 +680,7 @@ theorem BddAbove.continuous_convolution_right_of_integrable
     Continuous (f ⋆[L, μ] g) := by
   refine' continuous_iff_continuousAt.mpr fun x₀ => _
   have : ∀ᶠ x in 𝓝 x₀, ∀ᵐ t : G ∂μ, ‖L (f t) (g (x - t))‖ ≤ ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖ := by
-    refine' eventually_of_forall fun x => eventually_of_forall fun t => _
+    filter_upwards with x; filter_upwards with t
     apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl, le_ciSup hbg (x - t)]
   refine' continuousAt_of_dominated _ this _ _
   · exact eventually_of_forall fun x =>
@@ -1051,7 +1051,7 @@ theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport
   -- `refine' hasFDerivAt_integral_of_dominated_of_fderiv_le zero_lt_one h1 _ (h2 x₀) _ _ _`
   -- but it failed; surprisingly, `apply` works
   apply hasFDerivAt_integral_of_dominated_of_fderiv_le zero_lt_one h1 _ (h2 x₀)
-  · refine' eventually_of_forall fun t x hx =>
+  · filter_upwards with t x hx using
       (hcg.fderiv 𝕜).convolution_integrand_bound_right L' (hg.continuous_fderiv le_rfl)
         (ball_subset_closedBall hx)
   · rw [integrable_indicator_iff hK'.measurableSet]
@@ -1208,8 +1208,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
   let bound : G → ℝ := indicator U fun t => ‖(L.precompR (P × G))‖ * ‖f t‖ * C
   have I4 : ∀ᵐ a : G ∂μ, ∀ x : P × G, dist x q₀ < δ →
       ‖L.precompR (P × G) (f a) (g' (x.fst, x.snd - a))‖ ≤ bound a := by
-    apply eventually_of_forall
-    intro a x hx
+    filter_upwards with a x hx
     rw [Prod.dist_eq, dist_eq_norm, dist_eq_norm] at hx
     have : (-tsupport fun a => g' (x.1, a)) + ball q₀.2 δ ⊆ U := by
       apply Subset.trans _ hδ
@@ -1232,8 +1231,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
   have I6 : ∀ᵐ a : G ∂μ, ∀ x : P × G, dist x q₀ < δ →
       HasFDerivAt (fun x : P × G => L (f a) (g x.1 (x.2 - a)))
         ((L (f a)).comp (g' (x.fst, x.snd - a))) x := by
-    apply eventually_of_forall
-    intro a x hx
+    filter_upwards with a x hx
     apply (L _).hasFDerivAt.comp x
     have N : s ×ˢ univ ∈ 𝓝 (x.1, x.2 - a) := by
       apply A'

This is presumably not exhaustive, but covers about a hundred instances.

Style opinions (e.g., why a particular change is great/not a good idea) are very welcome; I'm still forming my own.

@@ -123,13 +123,12 @@ theorem ae_convolution_tendsto_right_of_locallyIntegrable
   have := (h₀.comp (Besicovitch.tendsto_filterAt μ x₀)).comp hφ'
   simp only [Function.comp] at this
   apply tendsto_integral_smul_of_tendsto_average_norm_sub (K ^ (FiniteDimensional.finrank ℝ G)) this
-  · apply eventually_of_forall (fun i ↦ ?_)
-    apply hg.integrableOn_isCompact
-    exact isCompact_closedBall _ _
+  · filter_upwards with i using
+      hg.integrableOn_isCompact (isCompact_closedBall _ _)
   · apply tendsto_const_nhds.congr (fun i ↦ ?_)
     rw [← integral_neg_eq_self]
     simp only [sub_neg_eq_add, integral_add_left_eq_self, integral_normed]
-  · apply eventually_of_forall (fun i ↦ ?_)
+  · filter_upwards with i
     change support ((ContDiffBump.normed (φ i) μ) ∘ (fun y ↦ x₀ - y)) ⊆ closedBall x₀ (φ i).rOut
     simp only [support_comp_eq_preimage, support_normed_eq]
     intro x hx

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -107,9 +107,7 @@ variable [NormedAddCommGroup E] [NormedAddCommGroup E'] [NormedAddCommGroup E'']
 section NontriviallyNormedField
 
 variable [NontriviallyNormedField 𝕜]
-
 variable [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 𝕜 E''] [NormedSpace 𝕜 F]
-
 variable (L : E →L[𝕜] E' →L[𝕜] F)
 
 section NoMeasurability
@@ -583,7 +581,6 @@ theorem MeasureTheory.Integrable.integrable_convolution (hf : Integrable f μ)
 end
 
 variable [TopologicalSpace G]
-
 variable [TopologicalAddGroup G]
 
 protected theorem HasCompactSupport.convolution [T2Space G] (hcf : HasCompactSupport f)
@@ -708,7 +705,6 @@ variable [IsAddLeftInvariant μ] [IsNegInvariant μ]
 section Measurable
 
 variable [MeasurableNeg G]
-
 variable [MeasurableAdd G]
 
 /-- Commutativity of convolution -/
@@ -752,9 +748,7 @@ theorem convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀
 end Measurable
 
 variable [TopologicalSpace G]
-
 variable [TopologicalAddGroup G]
-
 variable [BorelSpace G]
 
 theorem HasCompactSupport.continuous_convolution_left
@@ -798,7 +792,6 @@ theorem convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 :
 #align convolution_eq_right' convolution_eq_right'
 
 variable [BorelSpace G] [SecondCountableTopology G]
-
 variable [IsAddLeftInvariant μ] [SigmaFinite μ]
 
 /-- Approximate `(f ⋆ g) x₀` if the support of the `f` is bounded within a ball, and `g` is near
@@ -910,39 +903,24 @@ open scoped Convolution
 section IsROrC
 
 variable [IsROrC 𝕜]
-
 variable [NormedSpace 𝕜 E]
-
 variable [NormedSpace 𝕜 E']
-
 variable [NormedSpace 𝕜 E'']
-
 variable [NormedSpace ℝ F] [NormedSpace 𝕜 F]
-
 variable {n : ℕ∞}
-
 variable [CompleteSpace F]
-
 variable [MeasurableSpace G] {μ ν : MeasureTheory.Measure G}
-
 variable (L : E →L[𝕜] E' →L[𝕜] F)
 
 section Assoc
 
 variable [NormedAddCommGroup F'] [NormedSpace ℝ F'] [NormedSpace 𝕜 F'] [CompleteSpace F']
-
 variable [NormedAddCommGroup F''] [NormedSpace ℝ F''] [NormedSpace 𝕜 F''] [CompleteSpace F'']
-
 variable {k : G → E''}
-
 variable (L₂ : F →L[𝕜] E'' →L[𝕜] F')
-
 variable (L₃ : E →L[𝕜] F'' →L[𝕜] F')
-
 variable (L₄ : E' →L[𝕜] E'' →L[𝕜] F'')
-
 variable [AddGroup G]
-
 variable [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ]
 
 theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace ℝ E]
@@ -1094,25 +1072,15 @@ end IsROrC
 section Real
 
 /-! The one-variable case -/
-
 variable [IsROrC 𝕜]
-
 variable [NormedSpace 𝕜 E]
-
 variable [NormedSpace 𝕜 E']
-
 variable [NormedSpace ℝ F] [NormedSpace 𝕜 F]
-
 variable {f₀ : 𝕜 → E} {g₀ : 𝕜 → E'}
-
 variable {n : ℕ∞}
-
 variable (L : E →L[𝕜] E' →L[𝕜] F)
-
 variable [CompleteSpace F]
-
 variable {μ : MeasureTheory.Measure 𝕜}
-
 variable [IsAddLeftInvariant μ] [SigmaFinite μ]
 
 theorem HasCompactSupport.hasDerivAt_convolution_right (hf : LocallyIntegrable f₀ μ)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -58,7 +58,6 @@ theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x =
 
 variable [BorelSpace G]
 variable [IsLocallyFiniteMeasure μ] [μ.IsOpenPosMeasure]
-
 variable [FiniteDimensional ℝ G]
 
 /-- If `φ` is a normed bump function, compute `φ ⋆ g`

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -119,7 +119,7 @@ variable [AddGroup G] [TopologicalSpace G]
 theorem convolution_integrand_bound_right_of_le_of_subset {C : ℝ} (hC : ∀ i, ‖g i‖ ≤ C) {x t : G}
     {s u : Set G} (hx : x ∈ s) (hu : -tsupport g + s ⊆ u) :
     ‖L (f t) (g (x - t))‖ ≤ u.indicator (fun t => ‖L‖ * ‖f t‖ * C) t := by
-  -- porting note: had to add `f := _`
+  -- Porting note: had to add `f := _`
   refine' le_indicator (f := fun t ↦ ‖L (f t) (g (x - t))‖) (fun t _ => _) (fun t ht => _) t
   · apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl]
   · have : x - t ∉ support g := by
@@ -158,7 +158,7 @@ theorem HasCompactSupport.convolution_integrand_bound_left (hcf : HasCompactSupp
 end NoMeasurability
 
 section Measurability
--- porting note: throughout this file we use `MeasureTheory.Measure` instead of `Measure`.
+-- Porting note: throughout this file we use `MeasureTheory.Measure` instead of `Measure`.
 -- See https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Measure.20is.20overloaded
 variable [MeasurableSpace G] {μ ν : MeasureTheory.Measure G}
 
@@ -223,7 +223,7 @@ theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
     (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
     (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
     ConvolutionExistsAt f g x₀ L μ := by
-  -- porting note: can't `rw [ConvolutionExistsAt]`
+  -- Porting note: can't `rw [ConvolutionExistsAt]`
   unfold ConvolutionExistsAt
   rw [← integrableOn_iff_integrable_of_support_subset h2s]
   set s' := (fun t => -t + x₀) ⁻¹' s
@@ -399,7 +399,7 @@ variable {L} [MeasurableAdd G] [IsNegInvariant μ]
 theorem convolutionExistsAt_flip :
     ConvolutionExistsAt g f x L.flip μ ↔ ConvolutionExistsAt f g x L μ := by
   simp_rw [ConvolutionExistsAt,
-    -- porting note: added `(μ := μ)`
+    -- Porting note: added `(μ := μ)`
     ← integrable_comp_sub_left (μ := μ) (fun t => L (f t) (g (x - t))) x,
     sub_sub_cancel, flip_apply]
 #align convolution_exists_at_flip convolutionExistsAt_flip
@@ -1069,7 +1069,7 @@ theorem HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport
         ((hasFDerivAt_id x).sub (hasFDerivAt_const t x))
   let K' := -tsupport (fderiv 𝕜 g) + closedBall x₀ 1
   have hK' : IsCompact K' := (hcg.fderiv 𝕜).neg.add (isCompact_closedBall x₀ 1)
-  -- porting note: was
+  -- Porting note: was
   -- `refine' hasFDerivAt_integral_of_dominated_of_fderiv_le zero_lt_one h1 _ (h2 x₀) _ _ _`
   -- but it failed; surprisingly, `apply` works
   apply hasFDerivAt_integral_of_dominated_of_fderiv_le zero_lt_one h1 _ (h2 x₀)
@@ -1474,7 +1474,7 @@ theorem posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E')
     (ν : MeasureTheory.Measure ℝ := by volume_tac) [NoAtoms ν] :
     posConvolution f g L ν = convolution (indicator (Ioi 0) f) (indicator (Ioi 0) g) L ν := by
   ext1 x
-  -- porting note: was `rw [convolution, posConvolution, indicator]`, now `rw` can't do it
+  -- Porting note: was `rw [convolution, posConvolution, indicator]`, now `rw` can't do it
   -- the `rw` unfolded only one `indicator`; now we unfold it everywhere, so we need to adjust
   -- `rw`s below
   unfold convolution posConvolution indicator; simp only

This covers many instances, but is not exhaustive.

Independently of whether that syntax should be avoided (similar to #10534), I think all these changes are small improvements.

@@ -1179,14 +1179,13 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
         true_or_iff]
     obtain ⟨ε, εpos, hε, h'ε⟩ :
       ∃ ε : ℝ, 0 < ε ∧ thickening ε ({q₀.fst} ×ˢ k) ⊆ t ∧ ball q₀.1 ε ⊆ s := by
-      obtain ⟨ε, εpos, hε⟩ : ∃ ε : ℝ, 0 < ε ∧ thickening ε (({q₀.fst} : Set P) ×ˢ k) ⊆ t
-      · exact A.exists_thickening_subset_open t_open kt
-      obtain ⟨δ, δpos, hδ⟩ : ∃ δ : ℝ, 0 < δ ∧ ball q₀.1 δ ⊆ s
-      · exact Metric.isOpen_iff.1 hs _ hq₀
+      obtain ⟨ε, εpos, hε⟩ : ∃ ε : ℝ, 0 < ε ∧ thickening ε (({q₀.fst} : Set P) ×ˢ k) ⊆ t :=
+        A.exists_thickening_subset_open t_open kt
+      obtain ⟨δ, δpos, hδ⟩ : ∃ δ : ℝ, 0 < δ ∧ ball q₀.1 δ ⊆ s := Metric.isOpen_iff.1 hs _ hq₀
       refine' ⟨min ε δ, lt_min εpos δpos, _, _⟩
       · exact Subset.trans (thickening_mono (min_le_left _ _) _) hε
       · exact Subset.trans (ball_subset_ball (min_le_right _ _)) hδ
-    obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ g' '' t ⊆ closedBall 0 C; exact ht.subset_closedBall_lt 0 0
+    obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ g' '' t ⊆ closedBall 0 C := ht.subset_closedBall_lt 0 0
     refine' ⟨ε, C, εpos, h'ε, fun p x hp => _⟩
     have hps : p ∈ s := h'ε (mem_ball_iff_norm.2 hp)
     by_cases hx : x ∈ k
@@ -1227,8 +1226,8 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff] using hq₀
   set K' := (-k + {q₀.2} : Set G) with K'_def
   have hK' : IsCompact K' := hk.neg.add isCompact_singleton
-  obtain ⟨U, U_open, K'U, hU⟩ : ∃ U, IsOpen U ∧ K' ⊆ U ∧ IntegrableOn f U μ
-  exact hf.integrableOn_nhds_isCompact hK'
+  obtain ⟨U, U_open, K'U, hU⟩ : ∃ U, IsOpen U ∧ K' ⊆ U ∧ IntegrableOn f U μ :=
+    hf.integrableOn_nhds_isCompact hK'
   obtain ⟨δ, δpos, δε, hδ⟩ : ∃ δ, (0 : ℝ) < δ ∧ δ ≤ ε ∧ K' + ball 0 δ ⊆ U := by
     obtain ⟨V, V_mem, hV⟩ : ∃ V ∈ 𝓝 (0 : G), K' + V ⊆ U :=
       compact_open_separated_add_right hK' U_open K'U

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

@@ -342,7 +342,7 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
       (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aestronglyMeasurable_comp_iff
     v.measurableEmbedding).1 A
   ext x
-  simp only [Homeomorph.neg, sub_eq_add_neg, val_toAddUnits_apply, Homeomorph.trans_apply,
+  simp only [v, Homeomorph.neg, sub_eq_add_neg, val_toAddUnits_apply, Homeomorph.trans_apply,
     Equiv.neg_apply, Equiv.toFun_as_coe, Homeomorph.homeomorph_mk_coe, Equiv.coe_fn_mk,
     Homeomorph.coe_addLeft]
 #align has_compact_support.convolution_exists_at HasCompactSupport.convolutionExistsAt
@@ -635,7 +635,7 @@ theorem continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set
     rw [this]
     refine hg.comp (continuous_fst.fst.prod_mk (continuous_fst.snd.sub
       continuous_snd)).continuousOn ?_
-    simp (config := {contextual := true}) [MapsTo]
+    simp (config := {contextual := true}) [s', MapsTo]
   have B : ContinuousOn (fun a ↦ ∫ x, L (f x) (g' a x) ∂μ) s' := by
     apply continuousOn_integral_bilinear_of_locally_integrable_of_compact_support L k'_comp A _
       (hf.integrableOn_isCompact k'_comp)
@@ -1367,13 +1367,13 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
     have hes : IsOpen (isoP ⁻¹' s) := isoP.continuous.isOpen_preimage _ hs
     refine' contDiffOn_convolution_right_with_param_aux eL hes hek _ _ _
     · intro p x hp hx
-      simp only [(· ∘ ·), ContinuousLinearEquiv.prod_apply, LinearIsometryEquiv.coe_coe,
+      simp only [eg, (· ∘ ·), ContinuousLinearEquiv.prod_apply, LinearIsometryEquiv.coe_coe,
         ContinuousLinearEquiv.map_eq_zero_iff]
       exact hgs _ _ hp hx
     · apply (locallyIntegrable_map_homeomorph isoG.symm.toHomeomorph).2
       convert hf
       ext1 x
-      simp only [ContinuousLinearEquiv.coe_toHomeomorph, (· ∘ ·),
+      simp only [ef, ContinuousLinearEquiv.coe_toHomeomorph, (· ∘ ·),
         ContinuousLinearEquiv.apply_symm_apply]
     · apply isoE'.symm.contDiff.comp_contDiffOn
       apply hg.comp (isoP.prod isoG).contDiff.contDiffOn
@@ -1391,12 +1391,12 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
     rintro ⟨p, x⟩
     simp only [LinearIsometryEquiv.coe_coe, (· ∘ ·), ContinuousLinearEquiv.prod_symm,
       ContinuousLinearEquiv.prod_apply]
-    simp only [convolution, coe_comp', ContinuousLinearEquiv.coe_coe, (· ∘ ·)]
+    simp only [R, convolution, coe_comp', ContinuousLinearEquiv.coe_coe, (· ∘ ·)]
     rw [ClosedEmbedding.integral_map, ← isoF.integral_comp_comm]
     swap; · exact isoG.symm.toHomeomorph.closedEmbedding
     congr 1
     ext1 a
-    simp only [(· ∘ ·), ContinuousLinearEquiv.apply_symm_apply, coe_comp',
+    simp only [ef, eg, eL, (· ∘ ·), ContinuousLinearEquiv.apply_symm_apply, coe_comp',
       ContinuousLinearEquiv.prod_apply, ContinuousLinearEquiv.map_sub,
       ContinuousLinearEquiv.arrowCongr, ContinuousLinearEquiv.arrowCongrSL_symm_apply,
       ContinuousLinearEquiv.coe_coe, Function.comp_apply, ContinuousLinearEquiv.apply_symm_apply]

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>

@@ -228,8 +228,8 @@ theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
   rw [← integrableOn_iff_integrable_of_support_subset h2s]
   set s' := (fun t => -t + x₀) ⁻¹' s
   have : ∀ᵐ t : G ∂μ.restrict s,
-      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
-  · refine' eventually_of_forall _
+      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t := by
+    refine' eventually_of_forall _
     refine' le_indicator (fun t ht => _) fun t ht => _
     · apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl]
       refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
@@ -334,8 +334,9 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
   let v := (Homeomorph.neg G).trans (Homeomorph.addLeft x₀)
   apply ((u.isCompact_preimage.mpr h).bddAbove_image hg.norm.continuousOn).convolutionExistsAt' L
     isClosed_closure.measurableSet subset_closure (hf.integrableOn_isCompact h)
-  have A : AEStronglyMeasurable (g ∘ v) (μ.restrict (tsupport fun t : G => L (f t) (g (x₀ - t))))
-  · apply (hg.comp v.continuous).continuousOn.aestronglyMeasurable_of_isCompact h
+  have A : AEStronglyMeasurable (g ∘ v)
+      (μ.restrict (tsupport fun t : G => L (f t) (g (x₀ - t)))) := by
+    apply (hg.comp v.continuous).continuousOn.aestronglyMeasurable_of_isCompact h
     exact (isClosed_tsupport _).measurableSet
   convert ((v.continuous.measurable.measurePreserving
       (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aestronglyMeasurable_comp_iff
@@ -1314,8 +1315,8 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
     constructor
     · rintro ⟨p, x⟩ ⟨hp, -⟩
       exact (A (p, x) hp).differentiableAt.differentiableWithinAt
-    · suffices H : ContDiffOn 𝕜 n (↿f') (s ×ˢ univ)
-      · apply H.congr
+    · suffices H : ContDiffOn 𝕜 n (↿f') (s ×ˢ univ) by
+        apply H.congr
         rintro ⟨p, x⟩ ⟨hp, -⟩
         exact (A (p, x) hp).fderiv
       have B : ∀ (p : P) (x : G), p ∈ s → x ∉ k → fderiv 𝕜 (uncurry g) (p, x) = 0 := by

The subgroup of the type of units added in this PR is something we have in other guises, which are somewhat less useful for some forms of working. The intention is to provide different options depending on how you want to think about the group of units in a submonoid.

Co-authored-by: lines <34025592+linesthatinterlace@users.noreply.github.com> Co-authored-by: Johan Commelin <johan@commelin.net>

@@ -341,7 +341,7 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
       (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aestronglyMeasurable_comp_iff
     v.measurableEmbedding).1 A
   ext x
-  simp only [Homeomorph.neg, sub_eq_add_neg, coe_toAddUnits, Homeomorph.trans_apply,
+  simp only [Homeomorph.neg, sub_eq_add_neg, val_toAddUnits_apply, Homeomorph.trans_apply,
     Equiv.neg_apply, Equiv.toFun_as_coe, Homeomorph.homeomorph_mk_coe, Equiv.coe_fn_mk,
     Homeomorph.coe_addLeft]
 #align has_compact_support.convolution_exists_at HasCompactSupport.convolutionExistsAt

Co-authored-by: adomani <adomani@gmail.com>

@@ -121,7 +121,7 @@ theorem convolution_integrand_bound_right_of_le_of_subset {C : ℝ} (hC : ∀ i,
     ‖L (f t) (g (x - t))‖ ≤ u.indicator (fun t => ‖L‖ * ‖f t‖ * C) t := by
   -- porting note: had to add `f := _`
   refine' le_indicator (f := fun t ↦ ‖L (f t) (g (x - t))‖) (fun t _ => _) (fun t ht => _) t
-  · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
+  · apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl]
   · have : x - t ∉ support g := by
       refine mt (fun hxt => hu ?_) ht
       refine' ⟨_, Set.neg_mem_neg.mpr (subset_closure hxt), _, hx, _⟩
@@ -152,7 +152,7 @@ theorem HasCompactSupport.convolution_integrand_bound_left (hcf : HasCompactSupp
     ‖L (f (x - t)) (g t)‖ ≤
       (-tsupport f + s).indicator (fun t => (‖L‖ * ⨆ i, ‖f i‖) * ‖g t‖) t := by
   convert hcf.convolution_integrand_bound_right L.flip hf hx using 1
-  simp_rw [L.op_norm_flip, mul_right_comm]
+  simp_rw [L.opNorm_flip, mul_right_comm]
 #align has_compact_support.convolution_integrand_bound_left HasCompactSupport.convolution_integrand_bound_left
 
 end NoMeasurability
@@ -231,7 +231,7 @@ theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
       ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
   · refine' eventually_of_forall _
     refine' le_indicator (fun t ht => _) fun t ht => _
-    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
+    · apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl]
       refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
       rwa [neg_sub, sub_add_cancel]
     · have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
@@ -249,7 +249,7 @@ theorem ConvolutionExistsAt.ofNorm' {x₀ : G}
   refine'
     (h.const_mul ‖L‖).mono' (hmf.convolution_integrand_snd' L hmg) (eventually_of_forall fun x => _)
   rw [mul_apply', ← mul_assoc]
-  apply L.le_op_norm₂
+  apply L.le_opNorm₂
 #align convolution_exists_at.of_norm' ConvolutionExistsAt.ofNorm'
 
 end
@@ -312,7 +312,7 @@ theorem MeasureTheory.Integrable.convolution_integrand (hf : Integrable f ν) (h
   · simp_rw [← integral_mul_left]
     rw [Real.norm_of_nonneg]
     · exact integral_mono_of_nonneg (eventually_of_forall fun t => norm_nonneg _)
-        ((hg.comp_sub_right t).norm.const_mul _) (eventually_of_forall fun t => L.le_op_norm₂ _ _)
+        ((hg.comp_sub_right t).norm.const_mul _) (eventually_of_forall fun t => L.le_opNorm₂ _ _)
     exact integral_nonneg fun x => norm_nonneg _
 #align measure_theory.integrable.convolution_integrand MeasureTheory.Integrable.convolution_integrand
 
@@ -683,7 +683,7 @@ theorem BddAbove.continuous_convolution_right_of_integrable
   refine' continuous_iff_continuousAt.mpr fun x₀ => _
   have : ∀ᶠ x in 𝓝 x₀, ∀ᵐ t : G ∂μ, ‖L (f t) (g (x - t))‖ ≤ ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖ := by
     refine' eventually_of_forall fun x => eventually_of_forall fun t => _
-    apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl, le_ciSup hbg (x - t)]
+    apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl, le_ciSup hbg (x - t)]
   refine' continuousAt_of_dominated _ this _ _
   · exact eventually_of_forall fun x =>
       hf.aestronglyMeasurable.convolution_integrand_snd' L hg.aestronglyMeasurable
@@ -824,7 +824,7 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
       rw [mem_ball_zero_iff] at h2t
       specialize hg (x₀ - t)
       rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg
-      refine' ((L (f t)).dist_le_op_norm _ _).trans _
+      refine' ((L (f t)).dist_le_opNorm _ _).trans _
       exact mul_le_mul_of_nonneg_left (hg h2t) (norm_nonneg _)
     · rw [nmem_support] at ht
       simp_rw [ht, L.map_zero₂, L.map_zero, norm_zero, zero_mul, dist_self]
@@ -838,7 +838,7 @@ theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε
   refine' mul_le_mul_of_nonneg_right _ hε
   have h3 : ∀ t, ‖L (f t)‖ ≤ ‖L‖ * ‖f t‖ := by
     intro t
-    exact L.le_op_norm (f t)
+    exact L.le_opNorm (f t)
   refine' (integral_mono (L.integrable_comp hif).norm (hif.norm.const_mul _) h3).trans_eq _
   rw [integral_mul_left]
 #align dist_convolution_le' dist_convolution_le'
@@ -858,7 +858,7 @@ theorem dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'}
   convert (dist_convolution_le' (lsmul ℝ ℝ) hε hif hf hmg hg).trans _
   · simp_rw [lsmul_apply, integral_smul_const, hintf, one_smul]
   · simp_rw [Real.norm_of_nonneg (hnf _), hintf, mul_one]
-    exact (mul_le_mul_of_nonneg_right op_norm_lsmul_le hε).trans_eq (one_mul ε)
+    exact (mul_le_mul_of_nonneg_right opNorm_lsmul_le hε).trans_eq (one_mul ε)
 #align dist_convolution_le dist_convolution_le
 
 /-- `(φ i ⋆ g i) (k i)` tends to `z₀` as `i` tends to some filter `l` if
@@ -1025,7 +1025,7 @@ theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z =
     · refine' integral_mono_of_nonneg (eventually_of_forall fun t => norm_nonneg _)
         ((ht.const_mul _).const_mul _) (eventually_of_forall fun s => _)
       simp only [← mul_assoc ‖L₄‖]
-      apply_rules [ContinuousLinearMap.le_of_op_norm₂_le_of_le, le_rfl]
+      apply_rules [ContinuousLinearMap.le_of_opNorm₂_le_of_le, le_rfl]
     exact integral_nonneg fun x => norm_nonneg _
 #align convolution_assoc convolution_assoc
 

Fix minor typos in the following files:

• Mathlib/GroupTheory/GroupAction/Opposite.lean
• Mathlib/Init/Control/Lawful.lean
• Mathlib/ModelTheory/ElementarySubstructures.lean
• Mathlib/Algebra/Group/Defs.lean
• Mathlib/Algebra/Group/WithOne/Basic.lean
• Mathlib/Data/Int/Cast/Defs.lean
• Mathlib/LinearAlgebra/Dimension/Basic.lean
• Mathlib/NumberTheory/NumberField/CanonicalEmbedding.lean
• Mathlib/Algebra/Star/StarAlgHom.lean
• Mathlib/AlgebraicTopology/SimplexCategory.lean
• Mathlib/CategoryTheory/Abelian/Homology.lean
• Mathlib/CategoryTheory/Sites/Grothendieck.lean
• Mathlib/RingTheory/IsTensorProduct.lean
• Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean
• Mathlib/AlgebraicTopology/ExtraDegeneracy.lean
• Mathlib/AlgebraicTopology/Nerve.lean
• Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
• Mathlib/Analysis/ConstantSpeed.lean
• Mathlib/Analysis/Convolution.lean

@@ -27,7 +27,7 @@ For many applications we can take `L = ContinuousLinearMap.lsmul ℝ ℝ` or
 
 We also define `ConvolutionExists` and `ConvolutionExistsAt` to state that the convolution is
 well-defined (everywhere or at a single point). These conditions are needed for pointwise
-computations (e.g. `ConvolutionExistsAt.distrib_add`), but are generally not stong enough for any
+computations (e.g. `ConvolutionExistsAt.distrib_add`), but are generally not strong enough for any
 local (or global) properties of the convolution. For this we need stronger assumptions on `f`
 and/or `g`, and generally if we impose stronger conditions on one of the functions, we can impose
 weaker conditions on the other.

• Redefine Set.image2 to use ∃ a ∈ s, ∃ b ∈ t, f a b = c instead of ∃ a b, a ∈ s ∧ b ∈ t ∧ f a b = c.
• Redefine Set.seq as Set.image2. The new definition is equal to the old one but rw [Set.seq] gives a different result.
• Redefine Filter.map₂ to use ∃ u ∈ f, ∃ v ∈ g, image2 m u v ⊆ s instead of ∃ u v, u ∈ f ∧ v ∈ g ∧ ...
• Update lemmas like Set.mem_image2, Finset.mem_image₂, Set.mem_mul, Finset.mem_div etc

The two reasons to make the change are:

• ∃ a ∈ s, ∃ b ∈ t, _ is a simp-normal form, and
• it looks a bit nicer.

@@ -124,7 +124,7 @@ theorem convolution_integrand_bound_right_of_le_of_subset {C : ℝ} (hC : ∀ i,
   · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
   · have : x - t ∉ support g := by
       refine mt (fun hxt => hu ?_) ht
-      refine' ⟨_, _, Set.neg_mem_neg.mpr (subset_closure hxt), hx, _⟩
+      refine' ⟨_, Set.neg_mem_neg.mpr (subset_closure hxt), _, hx, _⟩
       simp only [neg_sub, sub_add_cancel]
     simp only [nmem_support.mp this, (L _).map_zero, norm_zero, le_rfl]
 #align convolution_integrand_bound_right_of_le_of_subset convolution_integrand_bound_right_of_le_of_subset
@@ -560,7 +560,7 @@ theorem support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g
   intro x h2x
   by_contra hx
   apply h2x
-  simp_rw [Set.mem_add, not_exists, not_and_or, nmem_support] at hx
+  simp_rw [Set.mem_add, ← exists_and_left, not_exists, not_and_or, nmem_support] at hx
   rw [convolution_def]
   convert integral_zero G F using 2
   ext t
@@ -641,7 +641,7 @@ theorem continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set
     rintro ⟨p, x⟩ y ⟨hp, hx⟩ hy
     apply hgs p _ hp
     contrapose! hy
-    exact ⟨y - x, x, by simpa using hy, hx, by simp⟩
+    exact ⟨y - x, by simpa using hy, x, hx, by simp⟩
   apply ContinuousWithinAt.mono_of_mem (B (q₀, x₀) ⟨hq₀, mem_of_mem_nhds ht⟩)
   exact mem_nhdsWithin_prod_iff.2 ⟨s, self_mem_nhdsWithin, t, nhdsWithin_le_nhds ht, Subset.rfl⟩
 #align continuous_on_convolution_right_with_param' continuousOn_convolution_right_with_param

@@ -29,7 +29,7 @@ We also provide estimates in the case if `g x` is close to `g x₀` on this ball
   If `(φ i).rOut` tends to zero along a filter `l`,
   then `((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀` tends to `g x₀` along the same filter.
 - `ContDiffBump.convolution_tendsto_right`: generalization of the above lemma.
-- `ContDiffBump.ae_convolution_tendsto_right_of_locally_integrable`: let `g` be a locally
+- `ContDiffBump.ae_convolution_tendsto_right_of_locallyIntegrable`: let `g` be a locally
   integrable function. Then the convolution of `g` with a family of bump functions with
   support tending to `0` converges almost everywhere to `g`.
 
@@ -108,7 +108,7 @@ theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (
 /-- If a function `g` is locally integrable, then the convolution `φ i * g` converges almost
 everywhere to `g` if `φ i` is a sequence of bump functions with support tending to `0`, provided
 that the ratio between the inner and outer radii of `φ i` remains bounded. -/
-theorem ae_convolution_tendsto_right_of_locally_integrable
+theorem ae_convolution_tendsto_right_of_locallyIntegrable
     {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι} {K : ℝ}
     (hφ : Tendsto (fun i ↦ (φ i).rOut) l (𝓝 0))
     (h'φ : ∀ᶠ i in l, (φ i).rOut ≤ K * (φ i).rIn) (hg : LocallyIntegrable g μ) : ∀ᵐ x₀ ∂μ,

Mostly, this means replacing "of_open" by "of_isOpen". A few lemmas names were misleading and are corrected differently. Zulip discussion.

@@ -1172,7 +1172,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     have A : IsCompact ({q₀.1} ×ˢ k) := isCompact_singleton.prod hk
     obtain ⟨t, kt, t_open, ht⟩ : ∃ t, {q₀.1} ×ˢ k ⊆ t ∧ IsOpen t ∧ IsBounded (g' '' t) := by
       have B : ContinuousOn g' (s ×ˢ univ) :=
-        hg.continuousOn_fderiv_of_open (hs.prod isOpen_univ) le_rfl
+        hg.continuousOn_fderiv_of_isOpen (hs.prod isOpen_univ) le_rfl
       apply exists_isOpen_isBounded_image_of_isCompact_of_continuousOn A (hs.prod isOpen_univ) _ B
       simp only [prod_subset_prod_iff, hq₀, singleton_subset_iff, subset_univ, and_self_iff,
         true_or_iff]
@@ -1220,7 +1220,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
       HasCompactSupport.intro hk fun x hx => g'_zero q₀.1 x hq₀ hx
     apply (HasCompactSupport.convolutionExists_right (L.precompR (P × G) : _) T hf _ q₀.2).1
     have : ContinuousOn g' (s ×ˢ univ) :=
-      hg.continuousOn_fderiv_of_open (hs.prod isOpen_univ) le_rfl
+      hg.continuousOn_fderiv_of_isOpen (hs.prod isOpen_univ) le_rfl
     apply this.comp_continuous (continuous_const.prod_mk continuous_id')
     intro x
     simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff] using hq₀
@@ -1310,7 +1310,7 @@ theorem contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP}
     have A : ∀ q₀ : P × G, q₀.1 ∈ s →
         HasFDerivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (f' q₀.1 q₀.2) q₀ :=
       hasFDerivAt_convolution_right_with_param L hs hk hgs hf hg.one_of_succ
-    rw [contDiffOn_succ_iff_fderiv_of_open (hs.prod (@isOpen_univ G _))] at hg ⊢
+    rw [contDiffOn_succ_iff_fderiv_of_isOpen (hs.prod (@isOpen_univ G _))] at hg ⊢
     constructor
     · rintro ⟨p, x⟩ ⟨hp, -⟩
       exact (A (p, x) hp).differentiableAt.differentiableWithinAt

We prove that two regular Haar measures in a locally compact group coincide up to scalar multiplication, and the same thing for inner regular Haar measures. This is implemented in a new file MeasureTheory.Measure.Haar.Unique. A few results that used to be in the MeasureTheory.Measure.Haar.Basic are moved to this file (and extended) so several imports have to be changed.

@@ -8,6 +8,7 @@ import Mathlib.Analysis.Calculus.BumpFunction.Normed
 import Mathlib.MeasureTheory.Integral.Average
 import Mathlib.MeasureTheory.Covering.Differentiation
 import Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace
+import Mathlib.MeasureTheory.Measure.Haar.Unique
 
 #align_import analysis.convolution from "leanprover-community/mathlib"@"8905e5ed90859939681a725b00f6063e65096d95"
 

PR contents

This is the supremum of

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

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

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

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

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

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

leanprover/lean4#2778

We can get rid of all the

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

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

leanprover/lean4#2722

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

leanprover/lean4#2783

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

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

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

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

@@ -1013,7 +1013,8 @@ theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z =
     rw [← h3] at this
     convert this.comp_measurable (measurable_sub.prod_mk measurable_snd)
     ext ⟨x, y⟩
-    simp_rw [uncurry, Function.comp_apply, sub_sub_sub_cancel_right]
+    simp (config := { unfoldPartialApp := true }) only [uncurry, Function.comp_apply,
+      sub_sub_sub_cancel_right]
   simp_rw [integrable_prod_iff' h_meas]
   refine' ⟨((quasiMeasurePreserving_sub_left_of_right_invariant ν x₀).ae hgk).mono fun t ht =>
     (L₃ (f t)).integrable_comp <| ht.ofNorm L₄ hg hk, _⟩

PR contents

This is the supremum of

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

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

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

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

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

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

leanprover/lean4#2778

We can get rid of all the

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

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

leanprover/lean4#2722

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

leanprover/lean4#2783

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

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

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

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

@@ -104,8 +104,6 @@ theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (
     ((hg.tendsto x₀).comp tendsto_snd) tendsto_const_nhds
 #align cont_diff_bump.convolution_tendsto_right_of_continuous ContDiffBump.convolution_tendsto_right_of_continuous
 
-local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue lean4#2220
-
 /-- If a function `g` is locally integrable, then the convolution `φ i * g` converges almost
 everywhere to `g` if `φ i` is a sequence of bump functions with support tending to `0`, provided
 that the ratio between the inner and outer radii of `φ i` remains bounded. -/

No changes to content, or splitting, just a rename so there is room for more files.

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

@@ -3,7 +3,7 @@ Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 -/
-import Mathlib.Analysis.Calculus.ContDiff
+import Mathlib.Analysis.Calculus.ContDiff.Basic
 import Mathlib.Analysis.Calculus.ParametricIntegral
 import Mathlib.MeasureTheory.Constructions.Prod.Integral
 import Mathlib.MeasureTheory.Function.LocallyIntegrable

The current version of continuity of parametric integrals assume a first countable topology, to apply the dominated convergence theorem. When one deals with continuous compactly supported functions, this is not necessary, and a direct elementary approach makes it possible to remove the first countable assumption.

@@ -433,7 +433,7 @@ end CommGroup
 
 end ConvolutionExists
 
-variable [NormedSpace ℝ F] [CompleteSpace F]
+variable [NormedSpace ℝ F]
 
 /-- The convolution of two functions `f` and `g` with respect to a continuous bilinear map `L` and
 measure `μ`. It is defined to be `(f ⋆[L, μ] g) x = ∫ t, L (f t) (g (x - t)) ∂μ`. -/
@@ -443,13 +443,16 @@ noncomputable def convolution [Sub G] (f : G → E) (g : G → E') (L : E →L[
 #align convolution convolution
 
 -- mathport name: convolution
+/-- The convolution of two functions with respect to a bilinear operation `L` and a measure `μ`. -/
 scoped[Convolution] notation:67 f " ⋆[" L:67 ", " μ:67 "] " g:66 => convolution f g L μ
 
 -- mathport name: convolution.volume
+/-- The convolution of two functions with respect to a bilinear operation `L` and the volume. -/
 scoped[Convolution]
   notation:67 f " ⋆[" L:67 "]" g:66 => convolution f g L MeasureTheory.MeasureSpace.volume
 
 -- mathport name: convolution.lsmul
+/-- The convolution of two real-valued functions with respect to volume. -/
 scoped[Convolution]
   notation:67 f " ⋆ " g:66 =>
     convolution f g (ContinuousLinearMap.lsmul ℝ ℝ) MeasureTheory.MeasureSpace.volume
@@ -590,136 +593,73 @@ protected theorem HasCompactSupport.convolution [T2Space G] (hcf : HasCompactSup
       (hcg.isCompact.add hcf).isClosed
 #align has_compact_support.convolution HasCompactSupport.convolution
 
-variable [BorelSpace G] [FirstCountableTopology G] [TopologicalSpace P] [FirstCountableTopology P]
+variable [BorelSpace G] [TopologicalSpace P]
 
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
 compactly supported. Version where `g` depends on an additional parameter in a subset `s` of
-a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
-not assuming `T2Space G`. -/
-theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set P} {k : Set G}
-    (hk : IsCompact k) (h'k : IsClosed k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
+a parameter space `P` (and the compact support `k` is independent of the parameter in `s`). -/
+theorem continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
+    (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
     (hf : LocallyIntegrable f μ) (hg : ContinuousOn (↿g) (s ×ˢ univ)) :
     ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) := by
-  intro q₀ hq₀
-  replace hq₀ : q₀.1 ∈ s; · simpa only [mem_prod, mem_univ, and_true] using hq₀
-  have A : ∀ p ∈ s, Continuous (g p) := fun p hp ↦ by
-    refine hg.comp_continuous (continuous_const.prod_mk continuous_id') fun x => ?_
-    simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true] using hp
-  have B : ∀ p ∈ s, tsupport (g p) ⊆ k := fun p hp =>
-    closure_minimal (support_subset_iff'.2 fun z hz => hgs _ _ hp hz) h'k
-  /- We find a small neighborhood of `{q₀.1} × k` on which the function is uniformly bounded.
-      This follows from the continuity at all points of the compact set `k`. -/
-  obtain ⟨w, C, w_open, q₀w, hw⟩ :
-    ∃ w C, IsOpen w ∧ q₀.1 ∈ w ∧ ∀ p x, p ∈ w ∩ s → ‖g p x‖ ≤ C := by
-    have A : IsCompact ({q₀.1} ×ˢ k) := isCompact_singleton.prod hk
-    obtain ⟨t, kt, t_open, ht⟩ :
-        ∃ t, {q₀.1} ×ˢ k ⊆ t ∧ IsOpen t ∧ IsBounded (↿g '' (t ∩ s ×ˢ univ)) := by
-      apply exists_isOpen_isBounded_image_inter_of_isCompact_of_continuousOn A _ hg
-      simp only [prod_subset_prod_iff, hq₀, singleton_subset_iff, subset_univ, and_self_iff,
-        true_or_iff]
-    obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ ↿g '' (t ∩ s ×ˢ univ) ⊆ closedBall (0 : E') C :=
-      ht.subset_closedBall_lt 0 0
-    obtain ⟨w, w_open, q₀w, hw⟩ : ∃ w, IsOpen w ∧ q₀.1 ∈ w ∧ w ×ˢ k ⊆ t
-    · obtain ⟨w, v, w_open, -, hw, hv, hvw⟩ :
-        ∃ (w : Set P) (v : Set G), IsOpen w ∧ IsOpen v ∧ {q₀.fst} ⊆ w ∧ k ⊆ v ∧ w ×ˢ v ⊆ t
-      exact generalized_tube_lemma isCompact_singleton hk t_open kt
-      exact ⟨w, w_open, singleton_subset_iff.1 hw, Subset.trans (Set.prod_mono Subset.rfl hv) hvw⟩
-    refine' ⟨w, C, w_open, q₀w, _⟩
-    rintro p x ⟨hp, hps⟩
-    by_cases hx : x ∈ k
-    · have H : (p, x) ∈ t := by
-        apply hw
-        simp only [prod_mk_mem_set_prod_eq, hp, hx, and_true_iff]
-      have H' : (p, x) ∈ (s ×ˢ univ : Set (P × G)) := by
-        simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff] using hps
-      have : g p x ∈ closedBall (0 : E') C := hC (mem_image_of_mem _ (mem_inter H H'))
-      rwa [mem_closedBall_zero_iff] at this
-    · have : g p x = 0 := hgs _ _ hps hx
-      rw [this]
-      simpa only [norm_zero] using Cpos.le
-  have I1 :
-    ∀ᶠ q : P × G in 𝓝[s ×ˢ univ] q₀,
-      AEStronglyMeasurable (fun a : G => L (f a) (g q.1 (q.2 - a))) μ := by
-    filter_upwards [self_mem_nhdsWithin]
+  /- First get rid of the case where the space is not locally compact. Then `g` vanishes everywhere
+  and the conclusion is trivial. -/
+  by_cases H : ∀ p ∈ s, ∀ x, g p x = 0
+  · apply (continuousOn_const (c := 0)).congr
     rintro ⟨p, x⟩ ⟨hp, -⟩
-    refine' (HasCompactSupport.convolutionExists_right L _ hf (A _ hp) _).1
-    exact hk.of_isClosed_subset (isClosed_tsupport _) (B p hp)
-  let K' := -k + {q₀.2}
-  have hK' : IsCompact K' := hk.neg.add isCompact_singleton
-  obtain ⟨U, U_open, K'U, hU⟩ : ∃ U, IsOpen U ∧ K' ⊆ U ∧ IntegrableOn f U μ :=
-    hf.integrableOn_nhds_isCompact hK'
-  let bound : G → ℝ := indicator U fun a => ‖L‖ * ‖f a‖ * C
-  have I2 : ∀ᶠ q : P × G in 𝓝[s ×ˢ univ] q₀, ∀ᵐ a ∂μ, ‖L (f a) (g q.1 (q.2 - a))‖ ≤ bound a := by
-    obtain ⟨V, V_mem, hV⟩ : ∃ V ∈ 𝓝 (0 : G), K' + V ⊆ U :=
-      compact_open_separated_add_right hK' U_open K'U
-    have : ((w ∩ s) ×ˢ ({q₀.2} + V) : Set (P × G)) ∈ 𝓝[s ×ˢ univ] q₀ := by
-      conv_rhs => rw [nhdsWithin_prod_eq, nhdsWithin_univ]
-      refine' Filter.prod_mem_prod _ (singleton_add_mem_nhds_of_nhds_zero q₀.2 V_mem)
-      exact mem_nhdsWithin_iff_exists_mem_nhds_inter.2 ⟨w, w_open.mem_nhds q₀w, Subset.rfl⟩
-    filter_upwards [this]
-    rintro ⟨p, x⟩ hpx
-    simp only [prod_mk_mem_set_prod_eq] at hpx
-    refine eventually_of_forall fun a => ?_
-    apply convolution_integrand_bound_right_of_le_of_subset _ _ hpx.2 _
-    · intro x
-      exact hw _ _ hpx.1
-    · rw [← add_assoc]
-      apply Subset.trans (add_subset_add_right (add_subset_add_right _)) hV
-      rw [neg_subset_neg]
-      exact B p hpx.1.2
-  have I3 : Integrable bound μ := by
-    rw [integrable_indicator_iff U_open.measurableSet]
-    exact (hU.norm.const_mul _).mul_const _
-  have I4 : ∀ᵐ a : G ∂μ,
-      ContinuousWithinAt (fun q : P × G => L (f a) (g q.1 (q.2 - a))) (s ×ˢ univ) q₀ := by
-    refine eventually_of_forall fun a => ?_
-    suffices H : ContinuousWithinAt (fun q : P × G => (f a, g q.1 (q.2 - a))) (s ×ˢ univ) q₀
-    exact L.continuous₂.continuousAt.comp_continuousWithinAt H
-    apply continuousWithinAt_const.prod
-    change ContinuousWithinAt (fun q : P × G => (↿g) (q.1, q.2 - a)) (s ×ˢ univ) q₀
-    have : ContinuousAt (fun q : P × G => (q.1, q.2 - a)) (q₀.1, q₀.2) :=
-      (continuous_fst.prod_mk (continuous_snd.sub continuous_const)).continuousAt
-    have h'q₀ : (q₀.1, q₀.2 - a) ∈ (s ×ˢ univ : Set (P × G)) := ⟨hq₀, mem_univ _⟩
-    refine' ContinuousWithinAt.comp (hg _ h'q₀) this.continuousWithinAt _
-    rintro ⟨q, x⟩ ⟨hq, -⟩
-    exact ⟨hq, mem_univ _⟩
-  exact continuousWithinAt_of_dominated I1 I2 I3 I4
-#align continuous_on_convolution_right_with_param' continuousOn_convolution_right_with_param'
-
-/-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
-compactly supported. Version where `g` depends on an additional parameter in a subset `s` of
-a parameter space `P` (and the compact support `k` is independent of the parameter in `s`). -/
-theorem continuousOn_convolution_right_with_param [T2Space G] {g : P → G → E'} {s : Set P}
-    {k : Set G} (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
-    (hf : LocallyIntegrable f μ) (hg : ContinuousOn (↿g) (s ×ˢ univ)) :
-    ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) :=
-  continuousOn_convolution_right_with_param' L hk hk.isClosed hgs hf hg
+    apply integral_eq_zero_of_ae (eventually_of_forall (fun y ↦ ?_))
+    simp [H p hp _]
+  have : LocallyCompactSpace G := by
+    push_neg at H
+    rcases H with ⟨p, hp, x, hx⟩
+    have A : support (g p) ⊆ k := support_subset_iff'.2 (fun y hy ↦ hgs p y hp hy)
+    have B : Continuous (g p) := by
+      refine hg.comp_continuous (continuous_const.prod_mk continuous_id') fun x => ?_
+      simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true] using hp
+    rcases eq_zero_or_locallyCompactSpace_of_support_subset_isCompact_of_addGroup hk A B with H|H
+    · simp [H] at hx
+    · exact H
+  /- Since `G` is locally compact, one may thicken `k` a little bit into a larger compact set
+  `(-k) + t`, outside of which all functions that appear in the convolution vanish. Then we can
+  apply a continuity statement for integrals depending on a parameter, with respect to
+  locally integrable functions and compactly supported continuous functions. -/
+  rintro ⟨q₀, x₀⟩ ⟨hq₀, -⟩
+  obtain ⟨t, t_comp, ht⟩ : ∃ t, IsCompact t ∧ t ∈ 𝓝 x₀ := exists_compact_mem_nhds x₀
+  let k' : Set G := (-k) +ᵥ t
+  have k'_comp : IsCompact k' := IsCompact.vadd_set hk.neg t_comp
+  let g' : (P × G) → G → E' := fun p x ↦ g p.1 (p.2 - x)
+  let s' : Set (P × G) := s ×ˢ t
+  have A : ContinuousOn g'.uncurry (s' ×ˢ univ) := by
+    have : g'.uncurry = g.uncurry ∘ (fun w ↦ (w.1.1, w.1.2 - w.2)) := by ext y; rfl
+    rw [this]
+    refine hg.comp (continuous_fst.fst.prod_mk (continuous_fst.snd.sub
+      continuous_snd)).continuousOn ?_
+    simp (config := {contextual := true}) [MapsTo]
+  have B : ContinuousOn (fun a ↦ ∫ x, L (f x) (g' a x) ∂μ) s' := by
+    apply continuousOn_integral_bilinear_of_locally_integrable_of_compact_support L k'_comp A _
+      (hf.integrableOn_isCompact k'_comp)
+    rintro ⟨p, x⟩ y ⟨hp, hx⟩ hy
+    apply hgs p _ hp
+    contrapose! hy
+    exact ⟨y - x, x, by simpa using hy, hx, by simp⟩
+  apply ContinuousWithinAt.mono_of_mem (B (q₀, x₀) ⟨hq₀, mem_of_mem_nhds ht⟩)
+  exact mem_nhdsWithin_prod_iff.2 ⟨s, self_mem_nhdsWithin, t, nhdsWithin_le_nhds ht, Subset.rfl⟩
+#align continuous_on_convolution_right_with_param' continuousOn_convolution_right_with_param
 #align continuous_on_convolution_right_with_param continuousOn_convolution_right_with_param
 
 /-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
 compactly supported. Version where `g` depends on an additional parameter in an open subset `s` of
 a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
-given in terms of compositions with an additional continuous map.
-Version not assuming `T2Space G`. -/
-theorem continuousOn_convolution_right_with_param_comp' {s : Set P} {v : P → G}
-    (hv : ContinuousOn v s) {g : P → G → E'} {k : Set G} (hk : IsCompact k) (h'k : IsClosed k)
+given in terms of compositions with an additional continuous map. -/
+theorem continuousOn_convolution_right_with_param_comp {s : Set P} {v : P → G}
+    (hv : ContinuousOn v s) {g : P → G → E'} {k : Set G} (hk : IsCompact k)
     (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
     (hg : ContinuousOn (↿g) (s ×ˢ univ)) : ContinuousOn (fun x => (f ⋆[L, μ] g x) (v x)) s := by
   apply
-    (continuousOn_convolution_right_with_param' L hk h'k hgs hf hg).comp (continuousOn_id.prod hv)
+    (continuousOn_convolution_right_with_param L hk hgs hf hg).comp (continuousOn_id.prod hv)
   intro x hx
   simp only [hx, prod_mk_mem_set_prod_eq, mem_univ, and_self_iff, id.def]
-#align continuous_on_convolution_right_with_param_comp' continuousOn_convolution_right_with_param_comp'
-
-/-- The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
-compactly supported. Version where `g` depends on an additional parameter in an open subset `s` of
-a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
-given in terms of compositions with an additional continuous map. -/
-theorem continuousOn_convolution_right_with_param_comp [T2Space G] {s : Set P} {v : P → G}
-    (hv : ContinuousOn v s) {g : P → G → E'} {k : Set G} (hk : IsCompact k)
-    (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
-    (hg : ContinuousOn (↿g) (s ×ˢ univ)) : ContinuousOn (fun x => (f ⋆[L, μ] g x) (v x)) s :=
-  continuousOn_convolution_right_with_param_comp' L hv hk hk.isClosed hgs hf hg
+#align continuous_on_convolution_right_with_param_comp' continuousOn_convolution_right_with_param_comp
 #align continuous_on_convolution_right_with_param_comp continuousOn_convolution_right_with_param_comp
 
 /-- The convolution is continuous if one function is locally integrable and the other has compact
@@ -729,14 +669,15 @@ theorem HasCompactSupport.continuous_convolution_right (hcg : HasCompactSupport
   rw [continuous_iff_continuousOn_univ]
   let g' : G → G → E' := fun _ q => g q
   have : ContinuousOn (↿g') (univ ×ˢ univ) := (hg.comp continuous_snd).continuousOn
-  exact continuousOn_convolution_right_with_param_comp' L
-    (continuous_iff_continuousOn_univ.1 continuous_id) hcg (isClosed_tsupport _)
+  exact continuousOn_convolution_right_with_param_comp L
+    (continuous_iff_continuousOn_univ.1 continuous_id) hcg
     (fun p x _ hx => image_eq_zero_of_nmem_tsupport hx) hf this
 #align has_compact_support.continuous_convolution_right HasCompactSupport.continuous_convolution_right
 
 /-- The convolution is continuous if one function is integrable and the other is bounded and
 continuous. -/
-theorem BddAbove.continuous_convolution_right_of_integrable [SecondCountableTopologyEither G E']
+theorem BddAbove.continuous_convolution_right_of_integrable
+    [FirstCountableTopology G] [SecondCountableTopologyEither G E']
     (hbg : BddAbove (range fun x => ‖g x‖)) (hf : Integrable f μ) (hg : Continuous g) :
     Continuous (f ⋆[L, μ] g) := by
   refine' continuous_iff_continuousAt.mpr fun x₀ => _
@@ -815,7 +756,7 @@ variable [TopologicalAddGroup G]
 
 variable [BorelSpace G]
 
-theorem HasCompactSupport.continuous_convolution_left [FirstCountableTopology G]
+theorem HasCompactSupport.continuous_convolution_left
     (hcf : HasCompactSupport f) (hf : Continuous f) (hg : LocallyIntegrable g μ) :
     Continuous (f ⋆[L, μ] g) := by
   rw [← convolution_flip]

Due to recent changes in core we can reduce or remove many set_option maxHeartbeats statements.

I have tried to be careful to not leave anything too close to the line, so don't be surprised if some of these can still be reduced further.

This reduces us from 96 maxHeartbeats statements to 44. (There are 10 false positives in meta or testing code.)

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

@@ -1196,8 +1196,6 @@ variable [IsROrC 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 
   [NormedSpace 𝕜 G] [NormedAddCommGroup P] [NormedSpace 𝕜 P] {μ : MeasureTheory.Measure G}
   (L : E →L[𝕜] E' →L[𝕜] F)
 
--- porting note: the lemma is slow, added `set_option maxHeartbeats 250000 in`
-set_option maxHeartbeats 250000 in
 /-- The derivative of the convolution `f * g` is given by `f * Dg`, when `f` is locally integrable
 and `g` is `C^1` and compactly supported. Version where `g` depends on an additional parameter in an
 open subset `s` of a parameter space `P` (and the compact support `k` is independent of the

@@ -339,7 +339,7 @@ theorem HasCompactSupport.convolutionExistsAt {x₀ : G}
     exact (isClosed_tsupport _).measurableSet
   convert ((v.continuous.measurable.measurePreserving
       (μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aestronglyMeasurable_comp_iff
-    v.toMeasurableEquiv.measurableEmbedding).1 A
+    v.measurableEmbedding).1 A
   ext x
   simp only [Homeomorph.neg, sub_eq_add_neg, coe_toAddUnits, Homeomorph.trans_apply,
     Equiv.neg_apply, Equiv.toFun_as_coe, Homeomorph.homeomorph_mk_coe, Equiv.coe_fn_mk,

And fix some names in comments where this revealed issues

@@ -1051,7 +1051,7 @@ theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z =
         (mul ℝ ℝ) ν) :
     ((f ⋆[L, ν] g) ⋆[L₂, μ] k) x₀ = (f ⋆[L₃, ν] g ⋆[L₄, μ] k) x₀ := by
   refine' convolution_assoc' L L₂ L₃ L₄ hL hfg (hgk.mono fun x hx => hx.ofNorm L₄ hg hk) _
-  -- the following is similar to `integrable.convolution_integrand`
+  -- the following is similar to `Integrable.convolution_integrand`
   have h_meas :
     AEStronglyMeasurable (uncurry fun x y => L₃ (f y) (L₄ (g x) (k (x₀ - y - x))))
       (μ.prod ν) := by

As discussed on Zulip.

Co-authored-by: grunweg <grunweg@posteo.de>

@@ -584,7 +584,7 @@ variable [TopologicalAddGroup G]
 
 protected theorem HasCompactSupport.convolution [T2Space G] (hcf : HasCompactSupport f)
     (hcg : HasCompactSupport g) : HasCompactSupport (f ⋆[L, μ] g) :=
-  isCompact_of_isClosed_subset (hcg.isCompact.add hcf) isClosed_closure <|
+  (hcg.isCompact.add hcf).of_isClosed_subset isClosed_closure <|
     closure_minimal
       ((support_convolution_subset_swap L).trans <| add_subset_add subset_closure subset_closure)
       (hcg.isCompact.add hcf).isClosed
@@ -643,7 +643,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     filter_upwards [self_mem_nhdsWithin]
     rintro ⟨p, x⟩ ⟨hp, -⟩
     refine' (HasCompactSupport.convolutionExists_right L _ hf (A _ hp) _).1
-    exact isCompact_of_isClosed_subset hk (isClosed_tsupport _) (B p hp)
+    exact hk.of_isClosed_subset (isClosed_tsupport _) (B p hp)
   let K' := -k + {q₀.2}
   have hK' : IsCompact K' := hk.neg.add isCompact_singleton
   obtain ⟨U, U_open, K'U, hU⟩ : ∃ U, IsOpen U ∧ K' ⊆ U ∧ IntegrableOn f U μ :=
@@ -1270,7 +1270,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
     filter_upwards [A' q₀ hq₀]
     rintro ⟨p, x⟩ ⟨hp, -⟩
     refine' (HasCompactSupport.convolutionExists_right L _ hf (A _ hp) _).1
-    apply isCompact_of_isClosed_subset hk (isClosed_tsupport _)
+    apply hk.of_isClosed_subset (isClosed_tsupport _)
     exact closure_minimal (support_subset_iff'.2 fun z hz => hgs _ _ hp hz) hk.isClosed
   have I2 : Integrable (fun a : G => L (f a) (g q₀.1 (q₀.2 - a))) μ := by
     have M : HasCompactSupport (g q₀.1) := HasCompactSupport.intro hk fun x hx => hgs q₀.1 x hq₀ hx

Use Bornology.IsBounded instead.

@@ -92,7 +92,7 @@ The following notations are localized in the locale `convolution`:
 -/
 open Set Function Filter MeasureTheory MeasureTheory.Measure TopologicalSpace
 
-open ContinuousLinearMap Metric
+open ContinuousLinearMap Metric Bornology
 
 open scoped Pointwise Topology NNReal Filter
 
@@ -613,12 +613,12 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     ∃ w C, IsOpen w ∧ q₀.1 ∈ w ∧ ∀ p x, p ∈ w ∩ s → ‖g p x‖ ≤ C := by
     have A : IsCompact ({q₀.1} ×ˢ k) := isCompact_singleton.prod hk
     obtain ⟨t, kt, t_open, ht⟩ :
-        ∃ t, {q₀.1} ×ˢ k ⊆ t ∧ IsOpen t ∧ Bounded (↿g '' (t ∩ s ×ˢ univ)) := by
-      apply exists_isOpen_bounded_image_inter_of_isCompact_of_continuousOn A _ hg
+        ∃ t, {q₀.1} ×ˢ k ⊆ t ∧ IsOpen t ∧ IsBounded (↿g '' (t ∩ s ×ˢ univ)) := by
+      apply exists_isOpen_isBounded_image_inter_of_isCompact_of_continuousOn A _ hg
       simp only [prod_subset_prod_iff, hq₀, singleton_subset_iff, subset_univ, and_self_iff,
         true_or_iff]
     obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ ↿g '' (t ∩ s ×ˢ univ) ⊆ closedBall (0 : E') C :=
-      ht.subset_ball_lt 0 0
+      ht.subset_closedBall_lt 0 0
     obtain ⟨w, w_open, q₀w, hw⟩ : ∃ w, IsOpen w ∧ q₀.1 ∈ w ∧ w ×ˢ k ⊆ t
     · obtain ⟨w, v, w_open, -, hw, hv, hvw⟩ :
         ∃ (w : Set P) (v : Set G), IsOpen w ∧ IsOpen v ∧ {q₀.fst} ⊆ w ∧ k ⊆ v ∧ w ×ˢ v ⊆ t
@@ -1230,10 +1230,10 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
   obtain ⟨ε, C, εpos, h₀ε, hε⟩ :
       ∃ ε C, 0 < ε ∧ ball q₀.1 ε ⊆ s ∧ ∀ p x, ‖p - q₀.1‖ < ε → ‖g' (p, x)‖ ≤ C := by
     have A : IsCompact ({q₀.1} ×ˢ k) := isCompact_singleton.prod hk
-    obtain ⟨t, kt, t_open, ht⟩ : ∃ t, {q₀.1} ×ˢ k ⊆ t ∧ IsOpen t ∧ Bounded (g' '' t) := by
+    obtain ⟨t, kt, t_open, ht⟩ : ∃ t, {q₀.1} ×ˢ k ⊆ t ∧ IsOpen t ∧ IsBounded (g' '' t) := by
       have B : ContinuousOn g' (s ×ˢ univ) :=
         hg.continuousOn_fderiv_of_open (hs.prod isOpen_univ) le_rfl
-      apply exists_isOpen_bounded_image_of_isCompact_of_continuousOn A (hs.prod isOpen_univ) _ B
+      apply exists_isOpen_isBounded_image_of_isCompact_of_continuousOn A (hs.prod isOpen_univ) _ B
       simp only [prod_subset_prod_iff, hq₀, singleton_subset_iff, subset_univ, and_self_iff,
         true_or_iff]
     obtain ⟨ε, εpos, hε, h'ε⟩ :
@@ -1245,7 +1245,7 @@ theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P
       refine' ⟨min ε δ, lt_min εpos δpos, _, _⟩
       · exact Subset.trans (thickening_mono (min_le_left _ _) _) hε
       · exact Subset.trans (ball_subset_ball (min_le_right _ _)) hδ
-    obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ g' '' t ⊆ closedBall 0 C; exact ht.subset_ball_lt 0 0
+    obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ g' '' t ⊆ closedBall 0 C; exact ht.subset_closedBall_lt 0 0
     refine' ⟨ε, C, εpos, h'ε, fun p x hp => _⟩
     have hps : p ∈ s := h'ε (mem_ball_iff_norm.2 hp)
     by_cases hx : x ∈ k

We clean up heart beat bumps after #6474.

@@ -1196,8 +1196,8 @@ variable [IsROrC 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 E'] [NormedSpace 
   [NormedSpace 𝕜 G] [NormedAddCommGroup P] [NormedSpace 𝕜 P] {μ : MeasureTheory.Measure G}
   (L : E →L[𝕜] E' →L[𝕜] F)
 
--- porting note: the lemma is slow, added `set_option maxHeartbeats 300000 in`
-set_option maxHeartbeats 300000 in
+-- porting note: the lemma is slow, added `set_option maxHeartbeats 250000 in`
+set_option maxHeartbeats 250000 in
 /-- The derivative of the convolution `f * g` is given by `f * Dg`, when `f` is locally integrable
 and `g` is `C^1` and compactly supported. Version where `g` depends on an additional parameter in an
 open subset `s` of a parameter space `P` (and the compact support `k` is independent of the

Removing from Mathlib.Init.Data.Prod from the early parts of the import hierarchy.

While at it, remove unnecessary uses of Prod.mk.eta across the library.

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

@@ -653,7 +653,7 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     obtain ⟨V, V_mem, hV⟩ : ∃ V ∈ 𝓝 (0 : G), K' + V ⊆ U :=
       compact_open_separated_add_right hK' U_open K'U
     have : ((w ∩ s) ×ˢ ({q₀.2} + V) : Set (P × G)) ∈ 𝓝[s ×ˢ univ] q₀ := by
-      conv_rhs => rw [← @Prod.mk.eta _ _ q₀, nhdsWithin_prod_eq, nhdsWithin_univ]
+      conv_rhs => rw [nhdsWithin_prod_eq, nhdsWithin_univ]
       refine' Filter.prod_mem_prod _ (singleton_add_mem_nhds_of_nhds_zero q₀.2 V_mem)
       exact mem_nhdsWithin_iff_exists_mem_nhds_inter.2 ⟨w, w_open.mem_nhds q₀w, Subset.rfl⟩
     filter_upwards [this]
@@ -679,7 +679,6 @@ theorem continuousOn_convolution_right_with_param' {g : P → G → E'} {s : Set
     change ContinuousWithinAt (fun q : P × G => (↿g) (q.1, q.2 - a)) (s ×ˢ univ) q₀
     have : ContinuousAt (fun q : P × G => (q.1, q.2 - a)) (q₀.1, q₀.2) :=
       (continuous_fst.prod_mk (continuous_snd.sub continuous_const)).continuousAt
-    rw [← @Prod.mk.eta _ _ q₀]
     have h'q₀ : (q₀.1, q₀.2 - a) ∈ (s ×ˢ univ : Set (P × G)) := ⟨hq₀, mem_univ _⟩
     refine' ContinuousWithinAt.comp (hg _ h'q₀) this.continuousWithinAt _
     rintro ⟨q, x⟩ ⟨hq, -⟩

I want to use the lemma lintegral_add_right_eq_self in a file that doesn't import Bochner integration.

@@ -7,7 +7,7 @@ import Mathlib.Analysis.Calculus.ContDiff
 import Mathlib.Analysis.Calculus.ParametricIntegral
 import Mathlib.MeasureTheory.Constructions.Prod.Integral
 import Mathlib.MeasureTheory.Function.LocallyIntegrable
-import Mathlib.MeasureTheory.Group.Integration
+import Mathlib.MeasureTheory.Group.Integral
 import Mathlib.MeasureTheory.Group.Prod
 import Mathlib.MeasureTheory.Integral.IntervalIntegral
 

We have currently that the product of two Borel spaces is Borel when both of them are second-countable. It is in fact sufficient to assume that only one of them is second-countable. We prove this in this PR.

Also move the definition of SecondCountableEither from Function.StronglyMeasurable to BorelSpace.Basic to be able to use it in the statement of the above theorem.

@@ -737,7 +737,7 @@ theorem HasCompactSupport.continuous_convolution_right (hcg : HasCompactSupport
 
 /-- The convolution is continuous if one function is integrable and the other is bounded and
 continuous. -/
-theorem BddAbove.continuous_convolution_right_of_integrable [SecondCountableTopology G]
+theorem BddAbove.continuous_convolution_right_of_integrable [SecondCountableTopologyEither G E']
     (hbg : BddAbove (range fun x => ‖g x‖)) (hf : Integrable f μ) (hg : Continuous g) :
     Continuous (f ⋆[L, μ] g) := by
   refine' continuous_iff_continuousAt.mpr fun x₀ => _
@@ -823,7 +823,8 @@ theorem HasCompactSupport.continuous_convolution_left [FirstCountableTopology G]
   exact hcf.continuous_convolution_right L.flip hg hf
 #align has_compact_support.continuous_convolution_left HasCompactSupport.continuous_convolution_left
 
-theorem BddAbove.continuous_convolution_left_of_integrable [SecondCountableTopology G]
+theorem BddAbove.continuous_convolution_left_of_integrable
+    [FirstCountableTopology G] [SecondCountableTopologyEither G E]
     (hbf : BddAbove (range fun x => ‖f x‖)) (hf : Continuous f) (hg : Integrable g μ) :
     Continuous (f ⋆[L, μ] g) := by
   rw [← convolution_flip]

@@ -104,7 +104,7 @@ theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (
     ((hg.tendsto x₀).comp tendsto_snd) tendsto_const_nhds
 #align cont_diff_bump.convolution_tendsto_right_of_continuous ContDiffBump.convolution_tendsto_right_of_continuous
 
-local macro_rules | `($x ^ $y)   => `(HPow.hPow $x $y) -- Porting note: See issue #2220
+local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue lean4#2220
 
 /-- If a function `g` is locally integrable, then the convolution `φ i * g` converges almost
 everywhere to `g` if `φ i` is a sequence of bump functions with support tending to `0`, provided

@@ -5,11 +5,14 @@ Authors: Floris van Doorn
 -/
 import Mathlib.Analysis.Convolution
 import Mathlib.Analysis.Calculus.BumpFunction.Normed
+import Mathlib.MeasureTheory.Integral.Average
+import Mathlib.MeasureTheory.Covering.Differentiation
+import Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace
 
 #align_import analysis.convolution from "leanprover-community/mathlib"@"8905e5ed90859939681a725b00f6063e65096d95"
 
 /-!
-# Convolution of a bump function
+# Convolution with a bump function
 
 In this file we prove lemmas about convolutions `(φ.normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀`,
 where `φ : ContDiffBump 0` is a smooth bump function.
@@ -25,6 +28,9 @@ We also provide estimates in the case if `g x` is close to `g x₀` on this ball
   If `(φ i).rOut` tends to zero along a filter `l`,
   then `((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀` tends to `g x₀` along the same filter.
 - `ContDiffBump.convolution_tendsto_right`: generalization of the above lemma.
+- `ContDiffBump.ae_convolution_tendsto_right_of_locally_integrable`: let `g` be a locally
+  integrable function. Then the convolution of `g` with a family of bump functions with
+  support tending to `0` converges almost everywhere to `g`.
 
 ## Keywords
 
@@ -33,7 +39,7 @@ convolution, smooth function, bump function
 
 universe uG uE'
 
-open ContinuousLinearMap Metric MeasureTheory Filter Function
+open ContinuousLinearMap Metric MeasureTheory Filter Function Measure Set
 open scoped Convolution Topology
 
 namespace ContDiffBump
@@ -83,7 +89,7 @@ nonrec theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)}
     {k : ι → G} {x₀ : G} {z₀ : E'} {l : Filter ι} (hφ : Tendsto (fun i => (φ i).rOut) l (𝓝 0))
     (hig : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ˢ 𝓝 x₀) (𝓝 z₀))
     (hk : Tendsto k l (𝓝 x₀)) :
-    Tendsto (fun i => ((fun x => (φ i).normed μ x) ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀) :=
+    Tendsto (fun i => ((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g i) (k i)) l (𝓝 z₀) :=
   convolution_tendsto_right (eventually_of_forall fun i => (φ i).nonneg_normed)
     (eventually_of_forall fun i => (φ i).integral_normed) (tendsto_support_normed_smallSets hφ) hig
     hcg hk
@@ -93,9 +99,46 @@ nonrec theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)}
   and the limit is taken only in the first function. -/
 theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι}
     (hφ : Tendsto (fun i => (φ i).rOut) l (𝓝 0)) (hg : Continuous g) (x₀ : G) :
-    Tendsto (fun i => ((fun x => (φ i).normed μ x) ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) l (𝓝 (g x₀)) :=
+    Tendsto (fun i => ((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀) l (𝓝 (g x₀)) :=
   convolution_tendsto_right hφ (eventually_of_forall fun _ => hg.aestronglyMeasurable)
     ((hg.tendsto x₀).comp tendsto_snd) tendsto_const_nhds
 #align cont_diff_bump.convolution_tendsto_right_of_continuous ContDiffBump.convolution_tendsto_right_of_continuous
 
+local macro_rules | `($x ^ $y)   => `(HPow.hPow $x $y) -- Porting note: See issue #2220
+
+/-- If a function `g` is locally integrable, then the convolution `φ i * g` converges almost
+everywhere to `g` if `φ i` is a sequence of bump functions with support tending to `0`, provided
+that the ratio between the inner and outer radii of `φ i` remains bounded. -/
+theorem ae_convolution_tendsto_right_of_locally_integrable
+    {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι} {K : ℝ}
+    (hφ : Tendsto (fun i ↦ (φ i).rOut) l (𝓝 0))
+    (h'φ : ∀ᶠ i in l, (φ i).rOut ≤ K * (φ i).rIn) (hg : LocallyIntegrable g μ) : ∀ᵐ x₀ ∂μ,
+    Tendsto (fun i ↦ ((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀) l (𝓝 (g x₀)) := by
+  have : IsAddHaarMeasure μ := ⟨⟩
+  -- By Lebesgue differentiation theorem, the average of `g` on a small ball converges
+  -- almost everywhere to the value of `g` as the radius shrinks to zero.
+  -- We will see that this set of points satisfies the desired conclusion.
+  filter_upwards [(Besicovitch.vitaliFamily μ).ae_tendsto_average_norm_sub hg] with x₀ h₀
+  simp only [convolution_eq_swap, lsmul_apply]
+  have hφ' : Tendsto (fun i ↦ (φ i).rOut) l (𝓝[>] 0) :=
+    tendsto_nhdsWithin_iff.2 ⟨hφ, eventually_of_forall (fun i ↦ (φ i).rOut_pos)⟩
+  have := (h₀.comp (Besicovitch.tendsto_filterAt μ x₀)).comp hφ'
+  simp only [Function.comp] at this
+  apply tendsto_integral_smul_of_tendsto_average_norm_sub (K ^ (FiniteDimensional.finrank ℝ G)) this
+  · apply eventually_of_forall (fun i ↦ ?_)
+    apply hg.integrableOn_isCompact
+    exact isCompact_closedBall _ _
+  · apply tendsto_const_nhds.congr (fun i ↦ ?_)
+    rw [← integral_neg_eq_self]
+    simp only [sub_neg_eq_add, integral_add_left_eq_self, integral_normed]
+  · apply eventually_of_forall (fun i ↦ ?_)
+    change support ((ContDiffBump.normed (φ i) μ) ∘ (fun y ↦ x₀ - y)) ⊆ closedBall x₀ (φ i).rOut
+    simp only [support_comp_eq_preimage, support_normed_eq]
+    intro x hx
+    simp only [mem_preimage, mem_ball, dist_zero_right] at hx
+    simpa [dist_eq_norm_sub'] using hx.le
+  · filter_upwards [h'φ] with i hi x
+    rw [abs_of_nonneg (nonneg_normed _ _), addHaar_closedBall_center]
+    exact (φ i).normed_le_div_measure_closedBall_rOut _ _ hi _
+
 end ContDiffBump

@@ -12,7 +12,7 @@ import Mathlib.Analysis.Calculus.BumpFunction.Normed
 # Convolution of a bump function
 
 In this file we prove lemmas about convolutions `(φ.normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀`,
-where `φ : ContDiffBump 0` is an smooth bump function.
+where `φ : ContDiffBump 0` is a smooth bump function.
 
 We prove that this convolution is equal to `g x₀`
 if `g` is a constant on `Metric.ball x₀ φ.rOut`.

• Mathlib/Analysis/Calculus/BumpFunction/Convolution.lean was extracted from Mathlib/Analysis/Convolution.lean in #5940
• Mathlib/Geometry/Euclidean/PerpBisector.lean has lemmas moved from Mathlib/Geometry/Euclidean/Basic.lean in #5627

@@ -6,6 +6,8 @@ Authors: Floris van Doorn
 import Mathlib.Analysis.Convolution
 import Mathlib.Analysis.Calculus.BumpFunction.Normed
 
+#align_import analysis.convolution from "leanprover-community/mathlib"@"8905e5ed90859939681a725b00f6063e65096d95"
+
 /-!
 # Convolution of a bump function
 

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2022 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
-
-! This file was ported from Lean 3 source module analysis.convolution
-! leanprover-community/mathlib commit 8905e5ed90859939681a725b00f6063e65096d95
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Calculus.ContDiff
 import Mathlib.Analysis.Calculus.ParametricIntegral
@@ -16,6 +11,8 @@ import Mathlib.MeasureTheory.Group.Integration
 import Mathlib.MeasureTheory.Group.Prod
 import Mathlib.MeasureTheory.Integral.IntervalIntegral
 
+#align_import analysis.convolution from "leanprover-community/mathlib"@"8905e5ed90859939681a725b00f6063e65096d95"
+
 /-!
 # Convolution of functions
 

Fixes #4755

@@ -8,7 +8,7 @@ Authors: Floris van Doorn
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
-import Mathlib.Analysis.Calculus.BumpFunctionInner
+import Mathlib.Analysis.Calculus.ContDiff
 import Mathlib.Analysis.Calculus.ParametricIntegral
 import Mathlib.MeasureTheory.Constructions.Prod.Integral
 import Mathlib.MeasureTheory.Function.LocallyIntegrable
@@ -962,74 +962,6 @@ theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x
 
 end NormedAddCommGroup
 
-namespace ContDiffBump
-
-variable {n : ℕ∞}
-
-variable [NormedSpace ℝ E']
-
-variable [NormedAddCommGroup G] [NormedSpace ℝ G] [HasContDiffBump G]
-
-variable [CompleteSpace E']
-
-variable {a : G} {φ : ContDiffBump (0 : G)}
-
-/-- If `φ` is a bump function, compute `(φ ⋆ g) x₀` if `g` is constant on `Metric.ball x₀ φ.R`. -/
-theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :
-    (φ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = integral μ φ • g x₀ := by
-  simp_rw [convolution_eq_right' _ φ.support_eq.subset hg, lsmul_apply, integral_smul_const]
-#align cont_diff_bump.convolution_eq_right ContDiffBump.convolution_eq_right
-
-variable [BorelSpace G]
-
-variable [IsLocallyFiniteMeasure μ] [IsOpenPosMeasure μ]
-
-variable [FiniteDimensional ℝ G]
-
-/-- If `φ` is a normed bump function, compute `φ ⋆ g` if `g` is constant on `Metric.ball x₀ φ.R`. -/
-theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :
-    (φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = g x₀ := by
-  rw [convolution_eq_right' _ φ.support_normed_eq.subset hg]
-  exact integral_normed_smul φ μ (g x₀)
-#align cont_diff_bump.normed_convolution_eq_right ContDiffBump.normed_convolution_eq_right
-
-variable [IsAddLeftInvariant μ]
-
-/-- If `φ` is a normed bump function, approximate `(φ ⋆ g) x₀` if `g` is near `g x₀` on a ball with
-radius `φ.R` around `x₀`. -/
-theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AEStronglyMeasurable g μ)
-    (hg : ∀ x ∈ ball x₀ φ.rOut, dist (g x) (g x₀) ≤ ε) :
-    dist ((φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) (g x₀) ≤ ε :=
-  dist_convolution_le (by simp_rw [← dist_self (g x₀), hg x₀ (mem_ball_self φ.rOut_pos)])
-    φ.support_normed_eq.subset φ.nonneg_normed φ.integral_normed hmg hg
-#align cont_diff_bump.dist_normed_convolution_le ContDiffBump.dist_normed_convolution_le
-
-/-- `(φ i ⋆ g i) (k i)` tends to `z₀` as `i` tends to some filter `l` if
-* `φ` is a sequence of normed bump functions such that `(φ i).R` tends to `0` as `i` tends to `l`;
-* `g i` is `mu`-a.e. strongly measurable as `i` tends to `l`;
-* `g i x` tends to `z₀` as `(i, x)` tends to `l ×ˢ 𝓝 x₀`;
-* `k i` tends to `x₀`. -/
-nonrec theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)} {g : ι → G → E'}
-    {k : ι → G} {x₀ : G} {z₀ : E'} {l : Filter ι} (hφ : Tendsto (fun i => (φ i).rOut) l (𝓝 0))
-    (hig : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ˢ 𝓝 x₀) (𝓝 z₀))
-    (hk : Tendsto k l (𝓝 x₀)) :
-    Tendsto (fun i => ((fun x => (φ i).normed μ x) ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀) :=
-  convolution_tendsto_right (eventually_of_forall fun i => (φ i).nonneg_normed)
-    (eventually_of_forall fun i => (φ i).integral_normed) (tendsto_support_normed_smallSets hφ) hig
-    hcg hk
-#align cont_diff_bump.convolution_tendsto_right ContDiffBump.convolution_tendsto_right
-
-/-- Special case of `ContDiffBump.convolution_tendsto_right` where `g` is continuous,
-  and the limit is taken only in the first function. -/
-theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι}
-    (hφ : Tendsto (fun i => (φ i).rOut) l (𝓝 0)) (hg : Continuous g) (x₀ : G) :
-    Tendsto (fun i => ((fun x => (φ i).normed μ x) ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) l (𝓝 (g x₀)) :=
-  convolution_tendsto_right hφ (eventually_of_forall fun _ => hg.aestronglyMeasurable)
-    ((hg.tendsto x₀).comp tendsto_snd) tendsto_const_nhds
-#align cont_diff_bump.convolution_tendsto_right_of_continuous ContDiffBump.convolution_tendsto_right_of_continuous
-
-end ContDiffBump
-
 end Measurability
 
 end NontriviallyNormedField

The notion of Bochner integral of a function taking values in a normed space E requires that E is complete. This means that whenever we write down an integral, the term contains the assertion that E is complete.

In this PR, we remove the completeness requirement from the definition, using the junk value 0 when the space is not complete. Mathematically this does not make any difference, as all reasonable applications will be with a complete E. But it means that terms involving integrals become a little bit simpler and that completeness will not have to be checked by the system when applying a bunch of basic lemmas on integrals.

@@ -471,7 +471,7 @@ theorem convolution_lsmul [Sub G] {f : G → 𝕜} {g : G → F} :
 #align convolution_lsmul convolution_lsmul
 
 /-- The definition of convolution where the bilinear operator is multiplication. -/
-theorem convolution_mul [Sub G] [NormedSpace ℝ 𝕜] [CompleteSpace 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
+theorem convolution_mul [Sub G] [NormedSpace ℝ 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
     (f ⋆[mul 𝕜 𝕜, μ] g) x = ∫ t, f t * g (x - t) ∂μ :=
   rfl
 #align convolution_mul convolution_mul
@@ -793,7 +793,7 @@ theorem convolution_lsmul_swap {f : G → 𝕜} {g : G → F} :
 #align convolution_lsmul_swap convolution_lsmul_swap
 
 /-- The symmetric definition of convolution where the bilinear operator is multiplication. -/
-theorem convolution_mul_swap [NormedSpace ℝ 𝕜] [CompleteSpace 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
+theorem convolution_mul_swap [NormedSpace ℝ 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
     (f ⋆[mul 𝕜 𝕜, μ] g) x = ∫ t, f (x - t) * g t ∂μ :=
   convolution_eq_swap _
 #align convolution_mul_swap convolution_mul_swap

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 
 ! This file was ported from Lean 3 source module analysis.convolution
-! leanprover-community/mathlib commit f7ebde7ee0d1505dfccac8644ae12371aa3c1c9f
+! leanprover-community/mathlib commit 8905e5ed90859939681a725b00f6063e65096d95
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -1529,8 +1529,7 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
     simp only [(· ∘ ·), ContinuousLinearEquiv.apply_symm_apply, coe_comp',
       ContinuousLinearEquiv.prod_apply, ContinuousLinearEquiv.map_sub,
       ContinuousLinearEquiv.arrowCongr, ContinuousLinearEquiv.arrowCongrSL_symm_apply,
-      ContinuousLinearEquiv.coe_coe, Function.comp_apply, ContinuousLinearEquiv.apply_symm_apply,
-      LinearEquiv.invFun_eq_symm, ContinuousLinearEquiv.arrowCongrₛₗ_symm_apply, eq_self_iff_true]
+      ContinuousLinearEquiv.coe_coe, Function.comp_apply, ContinuousLinearEquiv.apply_symm_apply]
   simp_rw [this] at A
   exact A
 #align cont_diff_on_convolution_right_with_param contDiffOn_convolution_right_with_param

@@ -1528,7 +1528,7 @@ theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L :
     ext1 a
     simp only [(· ∘ ·), ContinuousLinearEquiv.apply_symm_apply, coe_comp',
       ContinuousLinearEquiv.prod_apply, ContinuousLinearEquiv.map_sub,
-      ContinuousLinearEquiv.arrowCongr, ContinuousLinearEquiv.arrowCongrSL_symm_apply_toFun,
+      ContinuousLinearEquiv.arrowCongr, ContinuousLinearEquiv.arrowCongrSL_symm_apply,
       ContinuousLinearEquiv.coe_coe, Function.comp_apply, ContinuousLinearEquiv.apply_symm_apply,
       LinearEquiv.invFun_eq_symm, ContinuousLinearEquiv.arrowCongrₛₗ_symm_apply, eq_self_iff_true]
   simp_rw [this] at A

@@ -88,7 +88,7 @@ The following notations are localized in the locale `convolution`:
   This might require a generalization of `MeasureTheory.Memℒp.smul` where `smul` is generalized
   to a continuous bilinear map.
   (see e.g. [Fremlin, *Measure Theory* (volume 2)][fremlin_vol2], 255K)
-* The convolution is a `AEStronglyMeasurable` function
+* The convolution is an `AEStronglyMeasurable` function
   (see e.g. [Fremlin, *Measure Theory* (volume 2)][fremlin_vol2], 255I).
 * Prove properties about the convolution if both functions are rapidly decreasing.
 * Use `@[to_additive]` everywhere
@@ -843,7 +843,7 @@ variable [SeminormedAddCommGroup G]
 on `Metric.ball x₀ R`.
 
 We can simplify the RHS further if we assume `f` is integrable, but also if `L = (•)` or more
-generally if `L` has a `AntilipschitzWith`-condition. -/
+generally if `L` has an `AntilipschitzWith`-condition. -/
 theorem convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 : G) R)
     (hg : ∀ x ∈ ball x₀ R, g x = g x₀) : (f ⋆[L, μ] g) x₀ = ∫ t, L (f t) (g x₀) ∂μ := by
   have h2 : ∀ t, L (f t) (g (x₀ - t)) = L (f t) (g x₀) := fun t ↦ by

@@ -802,7 +802,7 @@ theorem convolution_mul_swap [NormedSpace ℝ 𝕜] [CompleteSpace 𝕜] {f : G
 theorem convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀ᵐ x ∂μ, g (-x) = g x) :
     (f ⋆[L, μ] g) (-x) = (f ⋆[L, μ] g) x :=
   calc
-    (∫ t : G, (L (f t)) (g (-x - t)) ∂μ) = ∫ t : G, (L (f (-t))) (g (x + t)) ∂μ := by
+    ∫ t : G, (L (f t)) (g (-x - t)) ∂μ = ∫ t : G, (L (f (-t))) (g (x + t)) ∂μ := by
       apply integral_congr_ae
       filter_upwards [h1, (eventually_add_left_iff μ x).2 h2] with t ht h't
       simp_rw [ht, ← h't, neg_add']
@@ -913,7 +913,7 @@ on a ball with the same radius around `x₀`.
 This is a special case of `dist_convolution_le'` where `L` is `(•)`, `f` has integral 1 and `f` is
 nonnegative. -/
 theorem dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε)
-    (hf : support f ⊆ ball (0 : G) R) (hnf : ∀ x, 0 ≤ f x) (hintf : (∫ x, f x ∂μ) = 1)
+    (hf : support f ⊆ ball (0 : G) R) (hnf : ∀ x, 0 ≤ f x) (hintf : ∫ x, f x ∂μ = 1)
     (hmg : AEStronglyMeasurable g μ) (hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
     dist ((f ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) z₀ ≤ ε := by
   have hif : Integrable f μ := integrable_of_integral_eq_one hintf
@@ -934,7 +934,7 @@ See also `ContDiffBump.convolution_tendsto_right`.
 -/
 theorem convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x₀ : G} {z₀ : E'}
     {φ : ι → G → ℝ} {k : ι → G} (hnφ : ∀ᶠ i in l, ∀ x, 0 ≤ φ i x)
-    (hiφ : ∀ᶠ i in l, (∫ x, φ i x ∂μ) = 1)
+    (hiφ : ∀ᶠ i in l, ∫ x, φ i x ∂μ = 1)
     -- todo: we could weaken this to "the integral tends to 1"
     (hφ : Tendsto (fun n => support (φ n)) l (𝓝 0).smallSets)
     (hmg : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ˢ 𝓝 x₀) (𝓝 z₀))
@@ -1076,7 +1076,7 @@ variable [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ]
 
 theorem integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace ℝ E]
     [NormedSpace ℝ E'] [CompleteSpace E] [CompleteSpace E'] (hf : Integrable f ν)
-    (hg : Integrable g μ) : (∫ x, (f ⋆[L, ν] g) x ∂μ) = L (∫ x, f x ∂ν) (∫ x, g x ∂μ) := by
+    (hg : Integrable g μ) : ∫ x, (f ⋆[L, ν] g) x ∂μ = L (∫ x, f x ∂ν) (∫ x, g x ∂μ) := by
   refine' (integral_integral_swap (by apply hf.convolution_integrand L hg)).trans _
   simp_rw [integral_comp_comm _ (hg.comp_sub_right _), integral_sub_right_eq_self]
   exact (L.flip (∫ x, g x ∂μ)).integral_comp_comm hf
@@ -1666,7 +1666,7 @@ theorem integral_posConvolution [CompleteSpace E] [CompleteSpace E']
     {μ ν : MeasureTheory.Measure ℝ}
     [SigmaFinite μ] [SigmaFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
     (hf : IntegrableOn f (Ioi 0) ν) (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
-    (∫ x : ℝ in Ioi 0, ∫ t : ℝ in (0)..x, L (f t) (g (x - t)) ∂ν ∂μ) =
+    ∫ x : ℝ in Ioi 0, ∫ t : ℝ in (0)..x, L (f t) (g (x - t)) ∂ν ∂μ =
       L (∫ x : ℝ in Ioi 0, f x ∂ν) (∫ x : ℝ in Ioi 0, g x ∂μ) := by
   rw [← integrable_indicator_iff measurableSet_Ioi] at hf hg
   simp_rw [← integral_indicator measurableSet_Ioi]

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>