analysis.fourier.fourier_transform ⟷ Mathlib.Analysis.Fourier.FourierTransform

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 -/
 import Analysis.Complex.Circle
-import MeasureTheory.Group.Integration
+import MeasureTheory.Group.Integral
 import MeasureTheory.Measure.Haar.OfBasis
 
 #align_import analysis.fourier.fourier_transform from "leanprover-community/mathlib"@"fd4551cfe4b7484b81c2c9ba3405edae27659676"
@@ -110,7 +110,7 @@ theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 
   by
   ext1 w
   dsimp only [fourier_integral, Function.comp_apply]
-  conv in L _ => rw [← add_sub_cancel v v₀]
+  conv in L _ => rw [← add_sub_cancel_right v v₀]
   rw [integral_add_right_eq_self fun v : V => e[-L (v - v₀) w] • f v]
   swap; infer_instance
   dsimp only
@@ -134,9 +134,9 @@ section Continuous
 variable [TopologicalSpace 𝕜] [TopologicalRing 𝕜] [TopologicalSpace V] [BorelSpace V]
   [TopologicalSpace W] {e : Multiplicative 𝕜 →* 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
 
-#print VectorFourier.fourier_integral_convergent_iff /-
+#print VectorFourier.fourierIntegral_convergent_iff /-
 /-- For any `w`, the Fourier integral is convergent iff `f` is integrable. -/
-theorem fourier_integral_convergent_iff (he : Continuous e)
+theorem fourierIntegral_convergent_iff (he : Continuous e)
     (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (w : W) :
     Integrable f μ ↔ Integrable (fun v : V => e[-L v w] • f v) μ :=
   by
@@ -160,7 +160,7 @@ theorem fourier_integral_convergent_iff (he : Continuous e)
   rw [← smul_assoc, smul_eq_mul, ← Submonoid.coe_mul, ← MonoidHom.map_mul, ← ofAdd_add,
     LinearMap.map_neg, neg_neg, ← sub_eq_add_neg, sub_self, ofAdd_zero, MonoidHom.map_one,
     Submonoid.coe_one, one_smul]
-#align vector_fourier.fourier_integral_convergent_iff VectorFourier.fourier_integral_convergent_iff
+#align vector_fourier.fourier_integral_convergent_iff VectorFourier.fourierIntegral_convergent_iff
 -/
 
 variable [CompleteSpace E]

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

@@ -191,7 +191,7 @@ theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e
     · exact fun v => ‖f v‖
     · rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
   · exact hf.norm
-  · rw [continuous_induced_rng] at he 
+  · rw [continuous_induced_rng] at he
     refine' ae_of_all _ fun v => (he.comp (continuous_of_add.comp _)).smul continuous_const
     refine' (hL.comp (continuous_prod_mk.mpr ⟨continuous_const, continuous_id⟩)).neg
 #align vector_fourier.fourier_integral_continuous VectorFourier.fourierIntegral_continuous

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

@@ -303,21 +303,21 @@ def fourierIntegral (f : ℝ → E) (w : ℝ) :=
 #align real.fourier_integral Real.fourierIntegral
 -/
 
-#print Real.fourierIntegral_def /-
-theorem fourierIntegral_def (f : ℝ → E) (w : ℝ) :
+#print Real.fourierIntegral_real_eq /-
+theorem fourierIntegral_real_eq (f : ℝ → E) (w : ℝ) :
     fourierIntegral f w = ∫ v : ℝ, fourierChar[-(v * w)] • f v :=
   rfl
-#align real.fourier_integral_def Real.fourierIntegral_def
+#align real.fourier_integral_def Real.fourierIntegral_real_eq
 -/
 
 scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
 
-#print Real.fourierIntegral_eq_integral_exp_smul /-
-theorem fourierIntegral_eq_integral_exp_smul {E : Type _} [NormedAddCommGroup E] [CompleteSpace E]
-    [NormedSpace ℂ E] (f : ℝ → E) (w : ℝ) :
+#print Real.fourierIntegral_real_eq_integral_exp_smul /-
+theorem fourierIntegral_real_eq_integral_exp_smul {E : Type _} [NormedAddCommGroup E]
+    [CompleteSpace E] [NormedSpace ℂ E] (f : ℝ → E) (w : ℝ) :
     𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v := by
   simp_rw [fourier_integral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
-#align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_eq_integral_exp_smul
+#align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_real_eq_integral_exp_smul
 -/
 
 end Real

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

@@ -181,7 +181,7 @@ theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W
 
 #print VectorFourier.fourierIntegral_continuous /-
 /-- The Fourier integral of an `L^1` function is a continuous function. -/
-theorem fourierIntegral_continuous [TopologicalSpace.FirstCountableTopology W] (he : Continuous e)
+theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e)
     (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (hf : Integrable f μ) :
     Continuous (fourierIntegral e μ L f) :=
   by

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

@@ -3,9 +3,9 @@ Copyright (c) 2023 David Loeffler. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 -/
-import Mathbin.Analysis.Complex.Circle
-import Mathbin.MeasureTheory.Group.Integration
-import Mathbin.MeasureTheory.Measure.Haar.OfBasis
+import Analysis.Complex.Circle
+import MeasureTheory.Group.Integration
+import MeasureTheory.Measure.Haar.OfBasis
 
 #align_import analysis.fourier.fourier_transform from "leanprover-community/mathlib"@"fd4551cfe4b7484b81c2c9ba3405edae27659676"
 

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

@@ -2,16 +2,13 @@
 Copyright (c) 2023 David Loeffler. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
-
-! This file was ported from Lean 3 source module analysis.fourier.fourier_transform
-! leanprover-community/mathlib commit fd4551cfe4b7484b81c2c9ba3405edae27659676
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.Complex.Circle
 import Mathbin.MeasureTheory.Group.Integration
 import Mathbin.MeasureTheory.Measure.Haar.OfBasis
 
+#align_import analysis.fourier.fourier_transform from "leanprover-community/mathlib"@"fd4551cfe4b7484b81c2c9ba3405edae27659676"
+
 /-!
 # The Fourier transform
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/0723536a0522d24fc2f159a096fb3304bef77472

@@ -207,7 +207,7 @@ end VectorFourier
 /-! ## Fourier theory for functions on `𝕜` -/
 
 
-namespace Fourier
+namespace fourier
 
 variable {𝕜 : Type _} [CommRing 𝕜] [MeasurableSpace 𝕜] {E : Type _} [NormedAddCommGroup E]
   [NormedSpace ℂ E]
@@ -257,7 +257,7 @@ theorem fourierIntegral_comp_add_right [MeasurableAdd 𝕜] (e : Multiplicative
 
 end Defs
 
-end Fourier
+end fourier
 
 open scoped Real
 

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

@@ -55,14 +55,12 @@ Fourier transform of an integrable function is continuous (under mild assumption
 
 noncomputable section
 
--- mathport name: expr𝕊
 local notation "𝕊" => circle
 
 open MeasureTheory Filter
 
 open scoped Topology
 
--- mathport name: «expr [ ]»
 -- To avoid messing around with multiplicative vs. additive characters, we make a notation.
 scoped[FourierTransform] notation e "[" x "]" => (e (Multiplicative.ofAdd x) : ℂ)
 
@@ -78,13 +76,16 @@ section Defs
 
 variable [CompleteSpace E]
 
+#print VectorFourier.fourierIntegral /-
 /-- The Fourier transform integral for `f : V → E`, with respect to a bilinear form `L : V × W → 𝕜`
 and an additive character `e`. -/
 def fourierIntegral (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V) (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E)
     (w : W) : E :=
   ∫ v, e[-L v w] • f v ∂μ
 #align vector_fourier.fourier_integral VectorFourier.fourierIntegral
+-/
 
+#print VectorFourier.fourierIntegral_smul_const /-
 theorem fourierIntegral_smul_const (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
     (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (r : ℂ) :
     fourierIntegral e μ L (r • f) = r • fourierIntegral e μ L f :=
@@ -92,7 +93,9 @@ theorem fourierIntegral_smul_const (e : Multiplicative 𝕜 →* 𝕊) (μ : Mea
   ext1 w
   simp only [Pi.smul_apply, fourier_integral, smul_comm _ r, integral_smul]
 #align vector_fourier.fourier_integral_smul_const VectorFourier.fourierIntegral_smul_const
+-/
 
+#print VectorFourier.norm_fourierIntegral_le_integral_norm /-
 /-- The uniform norm of the Fourier integral of `f` is bounded by the `L¹` norm of `f`. -/
 theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
     (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (w : W) : ‖fourierIntegral e μ L f w‖ ≤ ∫ v : V, ‖f v‖ ∂μ :=
@@ -100,7 +103,9 @@ theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊
   refine' (norm_integral_le_integral_norm _).trans (le_of_eq _)
   simp_rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
 #align vector_fourier.norm_fourier_integral_le_integral_norm VectorFourier.norm_fourierIntegral_le_integral_norm
+-/
 
+#print VectorFourier.fourierIntegral_comp_add_right /-
 /-- The Fourier integral converts right-translation into scalar multiplication by a phase factor.-/
 theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
     [μ.IsAddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
@@ -117,6 +122,7 @@ theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 
   rw [← smul_assoc, smul_eq_mul, ← Submonoid.coe_mul, ← e.map_mul, ← ofAdd_add, ←
     LinearMap.neg_apply, ← sub_eq_add_neg, ← LinearMap.sub_apply, LinearMap.map_sub, neg_sub]
 #align vector_fourier.fourier_integral_comp_add_right VectorFourier.fourierIntegral_comp_add_right
+-/
 
 end Defs
 
@@ -131,6 +137,7 @@ section Continuous
 variable [TopologicalSpace 𝕜] [TopologicalRing 𝕜] [TopologicalSpace V] [BorelSpace V]
   [TopologicalSpace W] {e : Multiplicative 𝕜 →* 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
 
+#print VectorFourier.fourier_integral_convergent_iff /-
 /-- For any `w`, the Fourier integral is convergent iff `f` is integrable. -/
 theorem fourier_integral_convergent_iff (he : Continuous e)
     (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (w : W) :
@@ -157,9 +164,11 @@ theorem fourier_integral_convergent_iff (he : Continuous e)
     LinearMap.map_neg, neg_neg, ← sub_eq_add_neg, sub_self, ofAdd_zero, MonoidHom.map_one,
     Submonoid.coe_one, one_smul]
 #align vector_fourier.fourier_integral_convergent_iff VectorFourier.fourier_integral_convergent_iff
+-/
 
 variable [CompleteSpace E]
 
+#print VectorFourier.fourierIntegral_add /-
 theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W => L p.1 p.2)
     {f g : V → E} (hf : Integrable f μ) (hg : Integrable g μ) :
     fourierIntegral e μ L f + fourierIntegral e μ L g = fourierIntegral e μ L (f + g) :=
@@ -171,7 +180,9 @@ theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W
   · exact (fourier_integral_convergent_iff he hL w).mp hf
   · exact (fourier_integral_convergent_iff he hL w).mp hg
 #align vector_fourier.fourier_integral_add VectorFourier.fourierIntegral_add
+-/
 
+#print VectorFourier.fourierIntegral_continuous /-
 /-- The Fourier integral of an `L^1` function is a continuous function. -/
 theorem fourierIntegral_continuous [TopologicalSpace.FirstCountableTopology W] (he : Continuous e)
     (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (hf : Integrable f μ) :
@@ -187,6 +198,7 @@ theorem fourierIntegral_continuous [TopologicalSpace.FirstCountableTopology W] (
     refine' ae_of_all _ fun v => (he.comp (continuous_of_add.comp _)).smul continuous_const
     refine' (hL.comp (continuous_prod_mk.mpr ⟨continuous_const, continuous_id⟩)).neg
 #align vector_fourier.fourier_integral_continuous VectorFourier.fourierIntegral_continuous
+-/
 
 end Continuous
 
@@ -204,34 +216,44 @@ section Defs
 
 variable [CompleteSpace E]
 
+#print Fourier.fourierIntegral /-
 /-- The Fourier transform integral for `f : 𝕜 → E`, with respect to the measure `μ` and additive
 character `e`. -/
 def fourierIntegral (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (w : 𝕜) : E :=
   VectorFourier.fourierIntegral e μ (LinearMap.mul 𝕜 𝕜) f w
 #align fourier.fourier_integral Fourier.fourierIntegral
+-/
 
+#print Fourier.fourierIntegral_def /-
 theorem fourierIntegral_def (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (w : 𝕜) :
     fourierIntegral e μ f w = ∫ v : 𝕜, e[-(v * w)] • f v ∂μ :=
   rfl
 #align fourier.fourier_integral_def Fourier.fourierIntegral_def
+-/
 
+#print Fourier.fourierIntegral_smul_const /-
 theorem fourierIntegral_smul_const (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (r : ℂ) :
     fourierIntegral e μ (r • f) = r • fourierIntegral e μ f :=
   VectorFourier.fourierIntegral_smul_const _ _ _ _ _
 #align fourier.fourier_integral_smul_const Fourier.fourierIntegral_smul_const
+-/
 
+#print Fourier.norm_fourierIntegral_le_integral_norm /-
 /-- The uniform norm of the Fourier transform of `f` is bounded by the `L¹` norm of `f`. -/
 theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜)
     (f : 𝕜 → E) (w : 𝕜) : ‖fourierIntegral e μ f w‖ ≤ ∫ x : 𝕜, ‖f x‖ ∂μ :=
   VectorFourier.norm_fourierIntegral_le_integral_norm _ _ _ _ _
 #align fourier.norm_fourier_integral_le_integral_norm Fourier.norm_fourierIntegral_le_integral_norm
+-/
 
+#print Fourier.fourierIntegral_comp_add_right /-
 /-- The Fourier transform converts right-translation into scalar multiplication by a phase factor.-/
 theorem fourierIntegral_comp_add_right [MeasurableAdd 𝕜] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜)
     [μ.IsAddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
     fourierIntegral e μ (f ∘ fun v => v + v₀) = fun w => e[v₀ * w] • fourierIntegral e μ f w :=
   VectorFourier.fourierIntegral_comp_add_right _ _ _ _ _
 #align fourier.fourier_integral_comp_add_right Fourier.fourierIntegral_comp_add_right
+-/
 
 end Defs
 
@@ -241,6 +263,7 @@ open scoped Real
 
 namespace Real
 
+#print Real.fourierChar /-
 /-- The standard additive character of `ℝ`, given by `λ x, exp (2 * π * x * I)`. -/
 def fourierChar : Multiplicative ℝ →* 𝕊
     where
@@ -248,18 +271,24 @@ def fourierChar : Multiplicative ℝ →* 𝕊
   map_one' := by rw [toAdd_one, MulZeroClass.mul_zero, expMapCircle_zero]
   map_mul' x y := by rw [toAdd_mul, mul_add, expMapCircle_add]
 #align real.fourier_char Real.fourierChar
+-/
 
+#print Real.fourierChar_apply /-
 theorem fourierChar_apply (x : ℝ) : Real.fourierChar[x] = Complex.exp (↑(2 * π * x) * Complex.I) :=
   by rfl
 #align real.fourier_char_apply Real.fourierChar_apply
+-/
 
+#print Real.continuous_fourierChar /-
 @[continuity]
 theorem continuous_fourierChar : Continuous Real.fourierChar :=
   (map_continuous expMapCircle).comp (continuous_const.mul continuous_toAdd)
 #align real.continuous_fourier_char Real.continuous_fourierChar
+-/
 
 variable {E : Type _} [NormedAddCommGroup E] [CompleteSpace E] [NormedSpace ℂ E]
 
+#print Real.vector_fourierIntegral_eq_integral_exp_smul /-
 theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type _} [AddCommGroup V] [Module ℝ V]
     [MeasurableSpace V] {W : Type _} [AddCommGroup W] [Module ℝ W] (L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ)
     (μ : Measure V) (f : V → E) (w : W) :
@@ -267,26 +296,32 @@ theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type _} [AddCommGroup V
       ∫ v : V, Complex.exp (↑(-2 * π * L v w) * Complex.I) • f v ∂μ :=
   by simp_rw [VectorFourier.fourierIntegral, Real.fourierChar_apply, mul_neg, neg_mul]
 #align real.vector_fourier_integral_eq_integral_exp_smul Real.vector_fourierIntegral_eq_integral_exp_smul
+-/
 
+#print Real.fourierIntegral /-
 /-- The Fourier integral for `f : ℝ → E`, with respect to the standard additive character and
 measure on `ℝ`. -/
 def fourierIntegral (f : ℝ → E) (w : ℝ) :=
   Fourier.fourierIntegral fourierChar volume f w
 #align real.fourier_integral Real.fourierIntegral
+-/
 
+#print Real.fourierIntegral_def /-
 theorem fourierIntegral_def (f : ℝ → E) (w : ℝ) :
     fourierIntegral f w = ∫ v : ℝ, fourierChar[-(v * w)] • f v :=
   rfl
 #align real.fourier_integral_def Real.fourierIntegral_def
+-/
 
--- mathport name: fourier_integral
 scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
 
+#print Real.fourierIntegral_eq_integral_exp_smul /-
 theorem fourierIntegral_eq_integral_exp_smul {E : Type _} [NormedAddCommGroup E] [CompleteSpace E]
     [NormedSpace ℂ E] (f : ℝ → E) (w : ℝ) :
     𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v := by
   simp_rw [fourier_integral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
 #align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_eq_integral_exp_smul
+-/
 
 end Real
 

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 
 ! This file was ported from Lean 3 source module analysis.fourier.fourier_transform
-! leanprover-community/mathlib commit fd5edc43dc4f10b85abfe544b88f82cf13c5f844
+! leanprover-community/mathlib commit fd4551cfe4b7484b81c2c9ba3405edae27659676
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.MeasureTheory.Measure.Haar.OfBasis
 /-!
 # The Fourier transform
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We set up the Fourier transform for complex-valued functions on finite-dimensional spaces.
 
 ## Design choices

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

@@ -100,7 +100,7 @@ theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊
 
 /-- The Fourier integral converts right-translation into scalar multiplication by a phase factor.-/
 theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
-    [μ.AddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
+    [μ.IsAddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
     fourierIntegral e μ L (f ∘ fun v => v + v₀) = fun w => e[L v₀ w] • fourierIntegral e μ L f w :=
   by
   ext1 w
@@ -225,7 +225,7 @@ theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊
 
 /-- The Fourier transform converts right-translation into scalar multiplication by a phase factor.-/
 theorem fourierIntegral_comp_add_right [MeasurableAdd 𝕜] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜)
-    [μ.AddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
+    [μ.IsAddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
     fourierIntegral e μ (f ∘ fun v => v + v₀) = fun w => e[v₀ * w] • fourierIntegral e μ f w :=
   VectorFourier.fourierIntegral_comp_add_right _ _ _ _ _
 #align fourier.fourier_integral_comp_add_right Fourier.fourierIntegral_comp_add_right

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

@@ -180,7 +180,7 @@ theorem fourierIntegral_continuous [TopologicalSpace.FirstCountableTopology W] (
     · exact fun v => ‖f v‖
     · rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
   · exact hf.norm
-  · rw [continuous_induced_rng] at he
+  · rw [continuous_induced_rng] at he 
     refine' ae_of_all _ fun v => (he.comp (continuous_of_add.comp _)).smul continuous_const
     refine' (hL.comp (continuous_prod_mk.mpr ⟨continuous_const, continuous_id⟩)).neg
 #align vector_fourier.fourier_integral_continuous VectorFourier.fourierIntegral_continuous

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

@@ -100,7 +100,7 @@ theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊
 
 /-- The Fourier integral converts right-translation into scalar multiplication by a phase factor.-/
 theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
-    [μ.IsAddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
+    [μ.AddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
     fourierIntegral e μ L (f ∘ fun v => v + v₀) = fun w => e[L v₀ w] • fourierIntegral e μ L f w :=
   by
   ext1 w
@@ -225,7 +225,7 @@ theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊
 
 /-- The Fourier transform converts right-translation into scalar multiplication by a phase factor.-/
 theorem fourierIntegral_comp_add_right [MeasurableAdd 𝕜] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜)
-    [μ.IsAddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
+    [μ.AddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
     fourierIntegral e μ (f ∘ fun v => v + v₀) = fun w => e[v₀ * w] • fourierIntegral e μ f w :=
   VectorFourier.fourierIntegral_comp_add_right _ _ _ _ _
 #align fourier.fourier_integral_comp_add_right Fourier.fourierIntegral_comp_add_right

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

@@ -57,7 +57,7 @@ local notation "𝕊" => circle
 
 open MeasureTheory Filter
 
-open Topology
+open scoped Topology
 
 -- mathport name: «expr [ ]»
 -- To avoid messing around with multiplicative vs. additive characters, we make a notation.
@@ -234,7 +234,7 @@ end Defs
 
 end Fourier
 
-open Real
+open scoped Real
 
 namespace Real
 

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

@@ -4,13 +4,13 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 
 ! This file was ported from Lean 3 source module analysis.fourier.fourier_transform
-! leanprover-community/mathlib commit 8f9fea08977f7e450770933ee6abb20733b47c92
+! 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.Complex.Circle
 import Mathbin.MeasureTheory.Group.Integration
-import Mathbin.MeasureTheory.Measure.HaarOfBasis
+import Mathbin.MeasureTheory.Measure.Haar.OfBasis
 
 /-!
 # The Fourier transform

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -4,10 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 
 ! This file was ported from Lean 3 source module analysis.fourier.fourier_transform
-! leanprover-community/mathlib commit f0c8bf9245297a541f468be517f1bde6195105e9
+! leanprover-community/mathlib commit 8f9fea08977f7e450770933ee6abb20733b47c92
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
+import Mathbin.Analysis.Complex.Circle
 import Mathbin.MeasureTheory.Group.Integration
 import Mathbin.MeasureTheory.Measure.HaarOfBasis
 

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

@@ -98,8 +98,8 @@ theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊
 #align vector_fourier.norm_fourier_integral_le_integral_norm VectorFourier.norm_fourierIntegral_le_integral_norm
 
 /-- The Fourier integral converts right-translation into scalar multiplication by a phase factor.-/
-theorem fourierIntegral_comp_add_right [HasMeasurableAdd V] (e : Multiplicative 𝕜 →* 𝕊)
-    (μ : Measure V) [μ.IsAddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
+theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
+    [μ.IsAddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
     fourierIntegral e μ L (f ∘ fun v => v + v₀) = fun w => e[L v₀ w] • fourierIntegral e μ L f w :=
   by
   ext1 w
@@ -223,8 +223,8 @@ theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊
 #align fourier.norm_fourier_integral_le_integral_norm Fourier.norm_fourierIntegral_le_integral_norm
 
 /-- The Fourier transform converts right-translation into scalar multiplication by a phase factor.-/
-theorem fourierIntegral_comp_add_right [HasMeasurableAdd 𝕜] (e : Multiplicative 𝕜 →* 𝕊)
-    (μ : Measure 𝕜) [μ.IsAddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
+theorem fourierIntegral_comp_add_right [MeasurableAdd 𝕜] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜)
+    [μ.IsAddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
     fourierIntegral e μ (f ∘ fun v => v + v₀) = fun w => e[v₀ * w] • fourierIntegral e μ f w :=
   VectorFourier.fourierIntegral_comp_add_right _ _ _ _ _
 #align fourier.fourier_integral_comp_add_right Fourier.fourierIntegral_comp_add_right

mathlib commit https://github.com/leanprover-community/mathlib/commit/738054fa93d43512da144ec45ce799d18fd44248

@@ -4,13 +4,12 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 
 ! This file was ported from Lean 3 source module analysis.fourier.fourier_transform
-! leanprover-community/mathlib commit 9425b6f8220e53b059f5a4904786c3c4b50fc057
+! leanprover-community/mathlib commit f0c8bf9245297a541f468be517f1bde6195105e9
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
-import Mathbin.Analysis.SpecialFunctions.Complex.Circle
 import Mathbin.MeasureTheory.Group.Integration
-import Mathbin.MeasureTheory.Integral.IntegralEqImproper
+import Mathbin.MeasureTheory.Measure.HaarOfBasis
 
 /-!
 # The Fourier transform

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 
 ! This file was ported from Lean 3 source module analysis.fourier.fourier_transform
-! leanprover-community/mathlib commit 3353f3371120058977ce1e20bf7fc8986c0fb042
+! leanprover-community/mathlib commit 9425b6f8220e53b059f5a4904786c3c4b50fc057
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -91,13 +91,12 @@ theorem fourierIntegral_smul_const (e : Multiplicative 𝕜 →* 𝕊) (μ : Mea
 #align vector_fourier.fourier_integral_smul_const VectorFourier.fourierIntegral_smul_const
 
 /-- The uniform norm of the Fourier integral of `f` is bounded by the `L¹` norm of `f`. -/
-theorem fourierIntegral_norm_le (e : Multiplicative 𝕜 →* 𝕊) {μ : Measure V} (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜)
-    {f : V → E} (hf : Integrable f μ) (w : W) : ‖fourierIntegral e μ L f w‖ ≤ ‖hf.toL1 f‖ :=
+theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
+    (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (w : W) : ‖fourierIntegral e μ L f w‖ ≤ ∫ v : V, ‖f v‖ ∂μ :=
   by
-  rw [L1.norm_of_fun_eq_integral_norm]
   refine' (norm_integral_le_integral_norm _).trans (le_of_eq _)
   simp_rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
-#align vector_fourier.fourier_integral_norm_le VectorFourier.fourierIntegral_norm_le
+#align vector_fourier.norm_fourier_integral_le_integral_norm VectorFourier.norm_fourierIntegral_le_integral_norm
 
 /-- The Fourier integral converts right-translation into scalar multiplication by a phase factor.-/
 theorem fourierIntegral_comp_add_right [HasMeasurableAdd V] (e : Multiplicative 𝕜 →* 𝕊)
@@ -129,20 +128,32 @@ section Continuous
 variable [TopologicalSpace 𝕜] [TopologicalRing 𝕜] [TopologicalSpace V] [BorelSpace V]
   [TopologicalSpace W] {e : Multiplicative 𝕜 →* 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
 
-/-- If `f` is integrable, then the Fourier integral is convergent for all `w`. -/
-theorem fourierIntegralConvergent (he : Continuous e) (hL : Continuous fun p : V × W => L p.1 p.2)
-    {f : V → E} (hf : Integrable f μ) (w : W) : Integrable (fun v : V => e[-L v w] • f v) μ :=
+/-- For any `w`, the Fourier integral is convergent iff `f` is integrable. -/
+theorem fourier_integral_convergent_iff (he : Continuous e)
+    (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (w : W) :
+    Integrable f μ ↔ Integrable (fun v : V => e[-L v w] • f v) μ :=
   by
-  rw [continuous_induced_rng] at he
-  have c : Continuous fun v => e[-L v w] :=
+  -- first prove one-way implication
+  have aux :
+    ∀ {g : V → E} (hg : integrable g μ) (x : W), integrable (fun v : V => e[-L v x] • g v) μ :=
     by
-    refine' he.comp (continuous_of_add.comp (Continuous.neg _))
-    exact hL.comp (continuous_prod_mk.mpr ⟨continuous_id, continuous_const⟩)
-  rw [← integrable_norm_iff (c.ae_strongly_measurable.smul hf.1)]
-  convert hf.norm
+    intro g hg x
+    have c : Continuous fun v => e[-L v x] :=
+      by
+      refine' (continuous_induced_rng.mp he).comp (continuous_of_add.comp (Continuous.neg _))
+      exact hL.comp (continuous_prod_mk.mpr ⟨continuous_id, continuous_const⟩)
+    rw [← integrable_norm_iff (c.ae_strongly_measurable.smul hg.1)]
+    convert hg.norm
+    ext1 v
+    rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
+  -- then use it for both directions
+  refine' ⟨fun hf => aux hf w, fun hf => _⟩
+  convert aux hf (-w)
   ext1 v
-  rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
-#align vector_fourier.fourier_integral_convergent VectorFourier.fourierIntegralConvergent
+  rw [← smul_assoc, smul_eq_mul, ← Submonoid.coe_mul, ← MonoidHom.map_mul, ← ofAdd_add,
+    LinearMap.map_neg, neg_neg, ← sub_eq_add_neg, sub_self, ofAdd_zero, MonoidHom.map_one,
+    Submonoid.coe_one, one_smul]
+#align vector_fourier.fourier_integral_convergent_iff VectorFourier.fourier_integral_convergent_iff
 
 variable [CompleteSpace E]
 
@@ -154,8 +165,8 @@ theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W
   dsimp only [Pi.add_apply, fourier_integral]
   simp_rw [smul_add]
   rw [integral_add]
-  · exact fourier_integral_convergent he hL hf w
-  · exact fourier_integral_convergent he hL hg w
+  · exact (fourier_integral_convergent_iff he hL w).mp hf
+  · exact (fourier_integral_convergent_iff he hL w).mp hg
 #align vector_fourier.fourier_integral_add VectorFourier.fourierIntegral_add
 
 /-- The Fourier integral of an `L^1` function is a continuous function. -/
@@ -164,7 +175,7 @@ theorem fourierIntegral_continuous [TopologicalSpace.FirstCountableTopology W] (
     Continuous (fourierIntegral e μ L f) :=
   by
   apply continuous_of_dominated
-  · exact fun w => (fourier_integral_convergent he hL hf w).1
+  · exact fun w => ((fourier_integral_convergent_iff he hL w).mp hf).1
   · refine' fun w => ae_of_all _ fun v => _
     · exact fun v => ‖f v‖
     · rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
@@ -207,10 +218,10 @@ theorem fourierIntegral_smul_const (e : Multiplicative 𝕜 →* 𝕊) (μ : Mea
 #align fourier.fourier_integral_smul_const Fourier.fourierIntegral_smul_const
 
 /-- The uniform norm of the Fourier transform of `f` is bounded by the `L¹` norm of `f`. -/
-theorem fourierIntegral_norm_le (e : Multiplicative 𝕜 →* 𝕊) {μ : Measure 𝕜} {f : 𝕜 → E}
-    (hf : Integrable f μ) (w : 𝕜) : ‖fourierIntegral e μ f w‖ ≤ ‖hf.toL1 f‖ :=
-  VectorFourier.fourierIntegral_norm_le _ _ _ _
-#align fourier.fourier_integral_norm_le Fourier.fourierIntegral_norm_le
+theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜)
+    (f : 𝕜 → E) (w : 𝕜) : ‖fourierIntegral e μ f w‖ ≤ ∫ x : 𝕜, ‖f x‖ ∂μ :=
+  VectorFourier.norm_fourierIntegral_le_integral_norm _ _ _ _ _
+#align fourier.norm_fourier_integral_le_integral_norm Fourier.norm_fourierIntegral_le_integral_norm
 
 /-- The Fourier transform converts right-translation into scalar multiplication by a phase factor.-/
 theorem fourierIntegral_comp_add_right [HasMeasurableAdd 𝕜] (e : Multiplicative 𝕜 →* 𝕊)

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

@@ -231,7 +231,7 @@ namespace Real
 def fourierChar : Multiplicative ℝ →* 𝕊
     where
   toFun z := expMapCircle (2 * π * z.toAdd)
-  map_one' := by rw [toAdd_one, mul_zero, expMapCircle_zero]
+  map_one' := by rw [toAdd_one, MulZeroClass.mul_zero, expMapCircle_zero]
   map_mul' x y := by rw [toAdd_mul, mul_add, expMapCircle_add]
 #align real.fourier_char Real.fourierChar
 

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

@@ -235,7 +235,7 @@ def fourierChar : Multiplicative ℝ →* 𝕊
   map_mul' x y := by rw [toAdd_mul, mul_add, expMapCircle_add]
 #align real.fourier_char Real.fourierChar
 
-theorem fourierChar_apply (x : ℝ) : Real.fourierChar[x] = Complex.exp (↑(2 * π * x) * Complex.i) :=
+theorem fourierChar_apply (x : ℝ) : Real.fourierChar[x] = Complex.exp (↑(2 * π * x) * Complex.I) :=
   by rfl
 #align real.fourier_char_apply Real.fourierChar_apply
 
@@ -250,7 +250,7 @@ theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type _} [AddCommGroup V
     [MeasurableSpace V] {W : Type _} [AddCommGroup W] [Module ℝ W] (L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ)
     (μ : Measure V) (f : V → E) (w : W) :
     VectorFourier.fourierIntegral fourierChar μ L f w =
-      ∫ v : V, Complex.exp (↑(-2 * π * L v w) * Complex.i) • f v ∂μ :=
+      ∫ v : V, Complex.exp (↑(-2 * π * L v w) * Complex.I) • f v ∂μ :=
   by simp_rw [VectorFourier.fourierIntegral, Real.fourierChar_apply, mul_neg, neg_mul]
 #align real.vector_fourier_integral_eq_integral_exp_smul Real.vector_fourierIntegral_eq_integral_exp_smul
 
@@ -270,7 +270,7 @@ scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
 
 theorem fourierIntegral_eq_integral_exp_smul {E : Type _} [NormedAddCommGroup E] [CompleteSpace E]
     [NormedSpace ℂ E] (f : ℝ → E) (w : ℝ) :
-    𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.i) • f v := by
+    𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v := by
   simp_rw [fourier_integral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
 #align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_eq_integral_exp_smul
 

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 
 ! This file was ported from Lean 3 source module analysis.fourier.fourier_transform
-! leanprover-community/mathlib commit a231f964b9ec8d1e12a28326b556123258a52829
+! leanprover-community/mathlib commit 3353f3371120058977ce1e20bf7fc8986c0fb042
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -265,9 +265,12 @@ theorem fourierIntegral_def (f : ℝ → E) (w : ℝ) :
   rfl
 #align real.fourier_integral_def Real.fourierIntegral_def
 
+-- mathport name: fourier_integral
+scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
+
 theorem fourierIntegral_eq_integral_exp_smul {E : Type _} [NormedAddCommGroup E] [CompleteSpace E]
     [NormedSpace ℂ E] (f : ℝ → E) (w : ℝ) :
-    fourierIntegral f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.i) • f v := by
+    𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.i) • f v := by
   simp_rw [fourier_integral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
 #align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_eq_integral_exp_smul
 

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

• consistently use the YYYY-MM-DD format
• when easily possible, put the date on the same line as the deprecated attribute
• when easily possible, format the entire declaration on the same line

Why these changes?

• consistency makes it easier for tools to parse this information
• compactness: I don't see a good reason for these declarations taking up more space than needed; as I understand it, deprecated lemmas are not supposed to be used in mathlib anyway
• putting the date on the same line as the attribute makes it easier to discover un-dated deprecations; they also ease writing a tool to replace these by a machine-readable version using leanprover/lean4#3968

@@ -147,8 +147,8 @@ theorem fourierIntegral_convergent_iff (he : Continuous e)
   exact this
 #align vector_fourier.fourier_integral_convergent_iff VectorFourier.fourierIntegral_convergent_iff
 
-@[deprecated] alias fourier_integral_convergent_iff :=
-  VectorFourier.fourierIntegral_convergent_iff -- 2024-03-29
+@[deprecated] -- 2024-03-29
+alias fourier_integral_convergent_iff := VectorFourier.fourierIntegral_convergent_iff
 
 variable [CompleteSpace E]
 
@@ -463,8 +463,8 @@ theorem fourierIntegral_real_eq_integral_exp_smul (f : ℝ → E) (w : ℝ) :
     mul_assoc]
 #align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_real_eq_integral_exp_smul
 
-@[deprecated] alias fourierIntegral_eq_integral_exp_smul :=
-  fourierIntegral_real_eq_integral_exp_smul -- deprecated on 2024-02-21
+@[deprecated] -- deprecated on 2024-02-21
+alias fourierIntegral_eq_integral_exp_smul := fourierIntegral_real_eq_integral_exp_smul
 
 @[simp] theorem fourierIntegral_convergent_iff {μ : Measure V} {f : V → E} (w : V) :
     Integrable (fun v : V ↦ 𝐞 (- ⟪v, w⟫) • f v) μ ↔ Integrable f μ :=

The statements in this PR are mostly straightforward variations around already existing statements, which have proved useful down the road.

@@ -120,7 +120,7 @@ section Continuous
 
 /-! In this section we assume 𝕜, `V`, `W` have topologies,
   and `L`, `e` are continuous (but `f` needn't be).
-   This is used to ensure that `e [-L v w]` is (a.e. strongly) measurable. We could get away with
+   This is used to ensure that `e (-L v w)` is (a.e. strongly) measurable. We could get away with
    imposing only a measurable-space structure on 𝕜 (it doesn't have to be the Borel sigma-algebra of
    a topology); but it seems hard to imagine cases where this extra generality would be useful, and
    allowing it would complicate matters in the most important use cases.
@@ -241,6 +241,38 @@ end Fubini
 
 end VectorFourier
 
+namespace VectorFourier
+
+variable {𝕜 ι E F V W : Type*} [Fintype ι] [NontriviallyNormedField 𝕜]
+  [NormedAddCommGroup V] [NormedSpace 𝕜 V] [MeasurableSpace V] [BorelSpace V]
+  [NormedAddCommGroup W] [NormedSpace 𝕜 W] [MeasurableSpace W] [BorelSpace W]
+  {e : AddChar 𝕜 𝕊} {μ : Measure V} {L : V →L[𝕜] W →L[𝕜] 𝕜}
+  [NormedAddCommGroup F] [NormedSpace ℝ F]
+  [NormedAddCommGroup E] [NormedSpace ℂ E]
+  {M : ι → Type*} [∀ i, NormedAddCommGroup (M i)] [∀ i, NormedSpace ℝ (M i)]
+
+theorem fourierIntegral_continuousLinearMap_apply
+    {f : V → (F →L[ℝ] E)} {a : F} {w : W} (he : Continuous e) (hf : Integrable f μ) :
+    fourierIntegral e μ L.toLinearMap₂ f w a =
+      fourierIntegral e μ L.toLinearMap₂ (fun x ↦ f x a) w := by
+  rw [fourierIntegral, ContinuousLinearMap.integral_apply]
+  · rfl
+  · apply (fourierIntegral_convergent_iff he _ _).2 hf
+    exact L.continuous₂
+
+theorem fourierIntegral_continuousMultilinearMap_apply
+    {f : V → (ContinuousMultilinearMap ℝ M E)} {m : (i : ι) → M i} {w : W} (he : Continuous e)
+    (hf : Integrable f μ) :
+    fourierIntegral e μ L.toLinearMap₂ f w m =
+      fourierIntegral e μ L.toLinearMap₂ (fun x ↦ f x m) w := by
+  rw [fourierIntegral, ContinuousMultilinearMap.integral_apply]
+  · rfl
+  · apply (fourierIntegral_convergent_iff he _ _).2 hf
+    exact L.continuous₂
+
+end VectorFourier
+
+
 /-! ## Fourier theory for functions on `𝕜` -/
 
 
@@ -333,8 +365,31 @@ theorem fourierIntegral_convergent_iff' {V W : Type*} [NormedAddCommGroup V] [No
   VectorFourier.fourierIntegral_convergent_iff (E := E) (L := L.toLinearMap₂)
     continuous_fourierChar L.continuous₂ _
 
-variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
-  {V : Type*} [NormedAddCommGroup V]
+section Apply
+
+variable {ι F V W : Type*} [Fintype ι]
+  [NormedAddCommGroup V] [NormedSpace ℝ V] [MeasurableSpace V] [BorelSpace V]
+  [NormedAddCommGroup W] [NormedSpace ℝ W] [MeasurableSpace W] [BorelSpace W]
+  {μ : Measure V} {L : V →L[ℝ] W →L[ℝ] ℝ}
+  [NormedAddCommGroup F] [NormedSpace ℝ F]
+  [NormedAddCommGroup E] [NormedSpace ℂ E]
+  {M : ι → Type*} [∀ i, NormedAddCommGroup (M i)] [∀ i, NormedSpace ℝ (M i)]
+
+theorem fourierIntegral_continuousLinearMap_apply'
+    {f : V → (F →L[ℝ] E)} {a : F} {w : W} (hf : Integrable f μ) :
+    VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f w a =
+      VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ (fun x ↦ f x a) w :=
+  VectorFourier.fourierIntegral_continuousLinearMap_apply continuous_fourierChar hf
+
+theorem fourierIntegral_continuousMultilinearMap_apply'
+    {f : V → ContinuousMultilinearMap ℝ M E} {m : (i : ι) → M i} {w : W} (hf : Integrable f μ) :
+    VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f w m =
+      VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ (fun x ↦ f x m) w :=
+  VectorFourier.fourierIntegral_continuousMultilinearMap_apply continuous_fourierChar hf
+
+end Apply
+
+variable {V : Type*} [NormedAddCommGroup V]
   [InnerProductSpace ℝ V] [MeasurableSpace V] [BorelSpace V] [FiniteDimensional ℝ V]
   {W : Type*} [NormedAddCommGroup W]
   [InnerProductSpace ℝ W] [MeasurableSpace W] [BorelSpace W] [FiniteDimensional ℝ W]
@@ -370,15 +425,27 @@ lemma fourierIntegralInv_eq' (f : V → E) (w : V) :
     𝓕⁻ f w = ∫ v, Complex.exp ((↑(2 * π * ⟪v, w⟫) * Complex.I)) • f v := by
   simp_rw [fourierIntegralInv_eq, Submonoid.smul_def, Real.fourierChar_apply]
 
-lemma fourierIntegralInv_eq_fourierIntegral_neg (f : V → E) (w : V) :
-    𝓕⁻ f w = 𝓕 f (-w) := by
-  simp [fourierIntegral_eq, fourierIntegralInv_eq]
-
 lemma fourierIntegral_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
     𝓕 (f ∘ A) w = (𝓕 f) (A w) := by
   simp only [fourierIntegral_eq, ← A.inner_map_map, Function.comp_apply, ←
     MeasurePreserving.integral_comp A.measurePreserving A.toHomeomorph.measurableEmbedding]
 
+lemma fourierIntegralInv_eq_fourierIntegral_neg (f : V → E) (w : V) :
+    𝓕⁻ f w = 𝓕 f (-w) := by
+  simp [fourierIntegral_eq, fourierIntegralInv_eq]
+
+lemma fourierIntegralInv_eq_fourierIntegral_comp_neg (f : V → E) :
+    𝓕⁻ f = 𝓕 (fun x ↦ f (-x)) := by
+  ext y
+  rw [fourierIntegralInv_eq_fourierIntegral_neg]
+  change 𝓕 f (LinearIsometryEquiv.neg ℝ y) = 𝓕 (f ∘ LinearIsometryEquiv.neg ℝ) y
+  exact (fourierIntegral_comp_linearIsometry _ _ _).symm
+
+lemma fourierIntegralInv_comm (f : V → E) :
+    𝓕 (𝓕⁻ f) = 𝓕⁻ (𝓕 f) := by
+  conv_rhs => rw [fourierIntegralInv_eq_fourierIntegral_comp_neg]
+  simp_rw [← fourierIntegralInv_eq_fourierIntegral_neg]
+
 lemma fourierIntegralInv_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
     𝓕⁻ (f ∘ A) w = (𝓕⁻ f) (A w) := by
   simp [fourierIntegralInv_eq_fourierIntegral_neg, fourierIntegral_comp_linearIsometry]
@@ -403,4 +470,16 @@ theorem fourierIntegral_real_eq_integral_exp_smul (f : ℝ → E) (w : ℝ) :
     Integrable (fun v : V ↦ 𝐞 (- ⟪v, w⟫) • f v) μ ↔ Integrable f μ :=
   fourierIntegral_convergent_iff' (innerSL ℝ) w
 
+theorem fourierIntegral_continuousLinearMap_apply
+    {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {f : V → (F →L[ℝ] E)} {a : F} {v : V} (hf : Integrable f) :
+    𝓕 f v a = 𝓕 (fun x ↦ f x a) v :=
+  fourierIntegral_continuousLinearMap_apply' (L := innerSL ℝ) hf
+
+theorem fourierIntegral_continuousMultilinearMap_apply {ι : Type*} [Fintype ι]
+    {M : ι → Type*} [∀ i, NormedAddCommGroup (M i)] [∀ i, NormedSpace ℝ (M i)]
+    {f : V → ContinuousMultilinearMap ℝ M E} {m : (i : ι) → M i} {v : V} (hf : Integrable f) :
+    𝓕 f v m = 𝓕 (fun x ↦ f x m) v :=
+  fourierIntegral_continuousMultilinearMap_apply' (L := innerSL ℝ) hf
+
 end Real

All of these changes appear to be oversights to me.

@@ -118,8 +118,9 @@ end Defs
 
 section Continuous
 
-/- In this section we assume 𝕜, V, W have topologies, and L, e are continuous (but f needn't be).
-   This is used to ensure that `e [-L v w]` is (ae strongly) measurable. We could get away with
+/-! In this section we assume 𝕜, `V`, `W` have topologies,
+  and `L`, `e` are continuous (but `f` needn't be).
+   This is used to ensure that `e [-L v w]` is (a.e. strongly) measurable. We could get away with
    imposing only a measurable-space structure on 𝕜 (it doesn't have to be the Borel sigma-algebra of
    a topology); but it seems hard to imagine cases where this extra generality would be useful, and
    allowing it would complicate matters in the most important use cases.

Purely automatic replacement. If this is in any way controversial; I'm happy to just close this PR.

@@ -100,7 +100,7 @@ theorem norm_fourierIntegral_le_integral_norm (e : AddChar 𝕜 𝕊) (μ : Meas
   simp_rw [norm_circle_smul]
 #align vector_fourier.norm_fourier_integral_le_integral_norm VectorFourier.norm_fourierIntegral_le_integral_norm
 
-/-- The Fourier integral converts right-translation into scalar multiplication by a phase factor.-/
+/-- The Fourier integral converts right-translation into scalar multiplication by a phase factor. -/
 theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : AddChar 𝕜 𝕊) (μ : Measure V)
     [μ.IsAddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
     fourierIntegral e μ L (f ∘ fun v ↦ v + v₀) =
@@ -274,7 +274,8 @@ theorem norm_fourierIntegral_le_integral_norm (e : AddChar 𝕜 𝕊) (μ : Meas
   VectorFourier.norm_fourierIntegral_le_integral_norm _ _ _ _ _
 #align fourier.norm_fourier_integral_le_integral_norm Fourier.norm_fourierIntegral_le_integral_norm
 
-/-- The Fourier transform converts right-translation into scalar multiplication by a phase factor.-/
+/-- The Fourier transform converts right-translation into scalar multiplication by a phase
+factor. -/
 theorem fourierIntegral_comp_add_right [MeasurableAdd 𝕜] (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜)
     [μ.IsAddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
     fourierIntegral e μ (f ∘ fun v ↦ v + v₀) = fun w ↦ e (v₀ * w) • fourierIntegral e μ f w :=

Rename mul_L to fourierSMulRight for predictability, expand the file-level docstring, extract a few lemmas from proofs, change fourier_integral to fourierIntegral in a few lemma names. There is essentially no new mathematical content. This is a preparation for the study of higher order derivatives in #11776.

@@ -128,9 +128,9 @@ variable [TopologicalSpace 𝕜] [TopologicalRing 𝕜] [TopologicalSpace V] [Bo
   [TopologicalSpace W] {e : AddChar 𝕜 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
 
 /-- For any `w`, the Fourier integral is convergent iff `f` is integrable. -/
-theorem fourier_integral_convergent_iff (he : Continuous e)
+theorem fourierIntegral_convergent_iff (he : Continuous e)
     (hL : Continuous fun p : V × W ↦ L p.1 p.2) {f : V → E} (w : W) :
-    Integrable f μ ↔ Integrable (fun v : V ↦ e (-L v w) • f v) μ := by
+    Integrable (fun v : V ↦ e (-L v w) • f v) μ ↔ Integrable f μ := by
   -- first prove one-way implication
   have aux {g : V → E} (hg : Integrable g μ) (x : W) :
       Integrable (fun v : V ↦ e (-L v x) • g v) μ := by
@@ -139,12 +139,15 @@ theorem fourier_integral_convergent_iff (he : Continuous e)
     simp_rw [← integrable_norm_iff (c.aestronglyMeasurable.smul hg.1), norm_circle_smul]
     exact hg.norm
   -- then use it for both directions
-  refine ⟨fun hf ↦ aux hf w, fun hf ↦ ?_⟩
+  refine ⟨fun hf ↦ ?_, fun hf ↦ aux hf w⟩
   have := aux hf (-w)
   simp_rw [← mul_smul (e _) (e _) (f _), ← e.map_add_mul, LinearMap.map_neg, neg_add_self,
     e.map_zero_one, one_smul] at this -- the `(e _)` speeds up elaboration considerably
   exact this
-#align vector_fourier.fourier_integral_convergent_iff VectorFourier.fourier_integral_convergent_iff
+#align vector_fourier.fourier_integral_convergent_iff VectorFourier.fourierIntegral_convergent_iff
+
+@[deprecated] alias fourier_integral_convergent_iff :=
+  VectorFourier.fourierIntegral_convergent_iff -- 2024-03-29
 
 variable [CompleteSpace E]
 
@@ -155,8 +158,8 @@ theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W
   dsimp only [Pi.add_apply, fourierIntegral]
   simp_rw [smul_add]
   rw [integral_add]
-  · exact (fourier_integral_convergent_iff he hL w).mp hf
-  · exact (fourier_integral_convergent_iff he hL w).mp hg
+  · exact (fourierIntegral_convergent_iff he hL w).2 hf
+  · exact (fourierIntegral_convergent_iff he hL w).2 hg
 #align vector_fourier.fourier_integral_add VectorFourier.fourierIntegral_add
 
 /-- The Fourier integral of an `L^1` function is a continuous function. -/
@@ -164,7 +167,7 @@ theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e
     (hL : Continuous fun p : V × W ↦ L p.1 p.2) {f : V → E} (hf : Integrable f μ) :
     Continuous (fourierIntegral e μ L f) := by
   apply continuous_of_dominated
-  · exact fun w ↦ ((fourier_integral_convergent_iff he hL w).mp hf).1
+  · exact fun w ↦ ((fourierIntegral_convergent_iff he hL w).2 hf).1
   · exact fun w ↦ ae_of_all _ fun v ↦ le_of_eq (norm_circle_smul _ _)
   · exact hf.norm
   · refine ae_of_all _ fun v ↦ (he.comp ?_).smul continuous_const
@@ -195,7 +198,7 @@ theorem integral_bilin_fourierIntegral_eq_flip
   _ = ∫ ξ, (∫ x, M.flip (g ξ) (e (-L x ξ) • f x) ∂μ) ∂ν := by
     congr with ξ
     apply (ContinuousLinearMap.integral_comp_comm _ _).symm
-    exact (fourier_integral_convergent_iff he hL _).1 hf
+    exact (fourierIntegral_convergent_iff he hL _).2 hf
   _ = ∫ x, (∫ ξ, M.flip (g ξ) (e (-L x ξ) • f x) ∂ν) ∂μ := by
     rw [integral_integral_swap]
     have : Integrable (fun (p : W × V) ↦ ‖M‖ * (‖g p.1‖ * ‖f p.2‖)) (ν.prod μ) :=
@@ -222,7 +225,7 @@ theorem integral_bilin_fourierIntegral_eq_flip
   _ = ∫ x, M (f x) (∫ ξ, e (-L.flip ξ x) • g ξ ∂ν) ∂μ := by
     congr with x
     apply ContinuousLinearMap.integral_comp_comm
-    apply (fourier_integral_convergent_iff he _ _).1 hg
+    apply (fourierIntegral_convergent_iff he _ _).2 hg
     exact hL.comp continuous_swap
 
 /-- The Fourier transform satisfies `∫ 𝓕 f * g = ∫ f * 𝓕 g`, i.e., it is self-adjoint. -/
@@ -317,6 +320,16 @@ theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type*} [AddCommGroup V]
     neg_mul]
 #align real.vector_fourier_integral_eq_integral_exp_smul Real.vector_fourierIntegral_eq_integral_exp_smul
 
+/-- The Fourier integral is well defined iff the function is integrable. Version with a general
+continuous bilinear function `L`. For the specialization to the inner product in an inner product
+space, see `Real.fourierIntegral_convergent_iff`. -/
+@[simp]
+theorem fourierIntegral_convergent_iff' {V W : Type*} [NormedAddCommGroup V] [NormedSpace ℝ V]
+    [NormedAddCommGroup W] [NormedSpace ℝ W] [MeasurableSpace V] [BorelSpace V] {μ : Measure V}
+    {f : V → E} (L : V →L[ℝ] W →L[ℝ] ℝ) (w : W) :
+    Integrable (fun v : V ↦ 𝐞 (- L v w) • f v) μ ↔ Integrable f μ :=
+  VectorFourier.fourierIntegral_convergent_iff (E := E) (L := L.toLinearMap₂)
+    continuous_fourierChar L.continuous₂ _
 
 variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
   {V : Type*} [NormedAddCommGroup V]
@@ -384,4 +397,8 @@ theorem fourierIntegral_real_eq_integral_exp_smul (f : ℝ → E) (w : ℝ) :
 @[deprecated] alias fourierIntegral_eq_integral_exp_smul :=
   fourierIntegral_real_eq_integral_exp_smul -- deprecated on 2024-02-21
 
+@[simp] theorem fourierIntegral_convergent_iff {μ : Measure V} {f : V → E} (w : V) :
+    Integrable (fun v : V ↦ 𝐞 (- ⟪v, w⟫) • f v) μ ↔ Integrable f μ :=
+  fourierIntegral_convergent_iff' (innerSL ℝ) w
+
 end Real

The file Analysis/Fourier/FourierTransform.lean predates the general approach to additive characters elsewhere in the library; this merges the two (getting rid of the rather kludgy notation e [x] in the process). I also rejigged some slow proofs, to make them compile slightly faster.

@@ -9,6 +9,7 @@ import Mathlib.MeasureTheory.Integral.SetIntegral
 import Mathlib.MeasureTheory.Measure.Haar.OfBasis
 import Mathlib.MeasureTheory.Constructions.Prod.Integral
 import Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace
+import Mathlib.Algebra.Group.AddChar
 
 #align_import analysis.fourier.fourier_transform from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
 
@@ -22,7 +23,7 @@ We set up the Fourier transform for complex-valued functions on finite-dimension
 In namespace `VectorFourier`, we define the Fourier integral in the following context:
 * `𝕜` is a commutative ring.
 * `V` and `W` are `𝕜`-modules.
-* `e` is a unitary additive character of `𝕜`, i.e. a homomorphism `(Multiplicative 𝕜) →* circle`.
+* `e` is a unitary additive character of `𝕜`, i.e. an `AddChar 𝕜 circle`.
 * `μ` is a measure on `V`.
 * `L` is a `𝕜`-bilinear form `V × W → 𝕜`.
 * `E` is a complete normed `ℂ`-vector space.
@@ -30,11 +31,10 @@ In namespace `VectorFourier`, we define the Fourier integral in the following co
 With these definitions, we define `fourierIntegral` to be the map from functions `V → E` to
 functions `W → E` that sends `f` to
 
-`fun w ↦ ∫ v in V, e [-L v w] • f v ∂μ`,
+`fun w ↦ ∫ v in V, e (-L v w) • f v ∂μ`,
 
-where `e [x]` is notational sugar for `(e (Multiplicative.ofAdd x) : ℂ)` (available in locale
-`fourier_transform`). This includes the cases `W` is the dual of `V` and `L` is the canonical
-pairing, or `W = V` and `L` is a bilinear form (e.g. an inner product).
+This includes the cases `W` is the dual of `V` and `L` is the canonical pairing, or `W = V` and `L`
+is a bilinear form (e.g. an inner product).
 
 In namespace `Fourier`, we consider the more familiar special case when `V = W = 𝕜` and `L` is the
 multiplication map (but still allowing `𝕜` to be an arbitrary ring equipped with a measure).
@@ -63,15 +63,8 @@ open MeasureTheory Filter
 
 open scoped Topology
 
--- To avoid messing around with multiplicative vs. additive characters, we make a notation.
-/-- Notation for multiplicative character applied in an additive setting. -/
-scoped[FourierTransform] notation e "[" x "]" => (e (Multiplicative.ofAdd x) : ℂ)
-
-open FourierTransform
-
 /-! ## Fourier theory for functions on general vector spaces -/
 
-
 namespace VectorFourier
 
 variable {𝕜 : Type*} [CommRing 𝕜] {V : Type*} [AddCommGroup V] [Module 𝕜 V] [MeasurableSpace V]
@@ -83,42 +76,42 @@ section Defs
 
 /-- The Fourier transform integral for `f : V → E`, with respect to a bilinear form `L : V × W → 𝕜`
 and an additive character `e`. -/
-def fourierIntegral (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V) (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E)
+def fourierIntegral (e : AddChar 𝕜 𝕊) (μ : Measure V) (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E)
     (w : W) : E :=
-  ∫ v, e[-L v w] • f v ∂μ
+  ∫ v, e (-L v w) • f v ∂μ
 #align vector_fourier.fourier_integral VectorFourier.fourierIntegral
 
-theorem fourierIntegral_smul_const (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
+theorem fourierIntegral_smul_const (e : AddChar 𝕜 𝕊) (μ : Measure V)
     (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (r : ℂ) :
     fourierIntegral e μ L (r • f) = r • fourierIntegral e μ L f := by
   ext1 w
   -- Porting note: was
   -- simp only [Pi.smul_apply, fourierIntegral, smul_comm _ r, integral_smul]
   simp only [Pi.smul_apply, fourierIntegral, ← integral_smul]
-  congr; funext
+  congr 1 with v
   rw [smul_comm]
 #align vector_fourier.fourier_integral_smul_const VectorFourier.fourierIntegral_smul_const
 
 /-- The uniform norm of the Fourier integral of `f` is bounded by the `L¹` norm of `f`. -/
-theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
+theorem norm_fourierIntegral_le_integral_norm (e : AddChar 𝕜 𝕊) (μ : Measure V)
     (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (w : W) :
     ‖fourierIntegral e μ L f w‖ ≤ ∫ v : V, ‖f v‖ ∂μ := by
-  refine' (norm_integral_le_integral_norm _).trans (le_of_eq _)
-  simp_rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
+  refine (norm_integral_le_integral_norm _).trans (le_of_eq ?_)
+  simp_rw [norm_circle_smul]
 #align vector_fourier.norm_fourier_integral_le_integral_norm VectorFourier.norm_fourierIntegral_le_integral_norm
 
 /-- The Fourier integral converts right-translation into scalar multiplication by a phase factor.-/
-theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V)
+theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : AddChar 𝕜 𝕊) (μ : Measure V)
     [μ.IsAddRightInvariant] (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (v₀ : V) :
-    fourierIntegral e μ L (f ∘ fun v => v + v₀) =
-      fun w => e[L v₀ w] • fourierIntegral e μ L f w := by
+    fourierIntegral e μ L (f ∘ fun v ↦ v + v₀) =
+      fun w ↦ e (L v₀ w) • fourierIntegral e μ L f w := by
   ext1 w
-  dsimp only [fourierIntegral, Function.comp_apply]
+  dsimp only [fourierIntegral, Function.comp_apply, Submonoid.smul_def]
   conv in L _ => rw [← add_sub_cancel_right v v₀]
-  rw [integral_add_right_eq_self fun v : V => e[-L (v - v₀) w] • f v, ← integral_smul]
+  rw [integral_add_right_eq_self fun v : V ↦ (e (-L (v - v₀) w) : ℂ) • f v, ← integral_smul]
   congr 1 with v
-  rw [← smul_assoc, smul_eq_mul, ← Submonoid.coe_mul, ← e.map_mul, ← ofAdd_add, ←
-    LinearMap.neg_apply, ← sub_eq_add_neg, ← LinearMap.sub_apply, LinearMap.map_sub, neg_sub]
+  rw [← smul_assoc, smul_eq_mul, ← Submonoid.coe_mul, ← e.map_add_mul, ← LinearMap.neg_apply,
+    ← sub_eq_add_neg, ← LinearMap.sub_apply, LinearMap.map_sub, neg_sub]
 #align vector_fourier.fourier_integral_comp_add_right VectorFourier.fourierIntegral_comp_add_right
 
 end Defs
@@ -132,33 +125,30 @@ section Continuous
    allowing it would complicate matters in the most important use cases.
 -/
 variable [TopologicalSpace 𝕜] [TopologicalRing 𝕜] [TopologicalSpace V] [BorelSpace V]
-  [TopologicalSpace W] {e : Multiplicative 𝕜 →* 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
+  [TopologicalSpace W] {e : AddChar 𝕜 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
 
 /-- For any `w`, the Fourier integral is convergent iff `f` is integrable. -/
 theorem fourier_integral_convergent_iff (he : Continuous e)
-    (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (w : W) :
-    Integrable f μ ↔ Integrable (fun v : V => e[-L v w] • f v) μ := by
+    (hL : Continuous fun p : V × W ↦ L p.1 p.2) {f : V → E} (w : W) :
+    Integrable f μ ↔ Integrable (fun v : V ↦ e (-L v w) • f v) μ := by
   -- first prove one-way implication
-  have aux :
-    ∀ {g : V → E} (_ : Integrable g μ) (x : W), Integrable (fun v : V => e[-L v x] • g v) μ := by
-    intro g hg x
-    have c : Continuous fun v => e[-L v x] := by
-      refine' (continuous_induced_rng.mp he).comp (continuous_ofAdd.comp (Continuous.neg _))
-      exact hL.comp (continuous_prod_mk.mpr ⟨continuous_id, continuous_const⟩)
-    rw [← integrable_norm_iff (c.aestronglyMeasurable.smul hg.1)]
-    convert hg.norm using 2
-    rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
+  have aux {g : V → E} (hg : Integrable g μ) (x : W) :
+      Integrable (fun v : V ↦ e (-L v x) • g v) μ := by
+    have c : Continuous fun v ↦ e (-L v x) :=
+      he.comp (hL.comp (continuous_prod_mk.mpr ⟨continuous_id, continuous_const⟩)).neg
+    simp_rw [← integrable_norm_iff (c.aestronglyMeasurable.smul hg.1), norm_circle_smul]
+    exact hg.norm
   -- then use it for both directions
-  refine' ⟨fun hf => aux hf w, fun hf => _⟩
-  convert aux hf (-w)
-  rw [← smul_assoc, smul_eq_mul, ← Submonoid.coe_mul, ← MonoidHom.map_mul, ← ofAdd_add,
-    LinearMap.map_neg, neg_neg, ← sub_eq_add_neg, sub_self, ofAdd_zero, MonoidHom.map_one,
-    Submonoid.coe_one, one_smul]
+  refine ⟨fun hf ↦ aux hf w, fun hf ↦ ?_⟩
+  have := aux hf (-w)
+  simp_rw [← mul_smul (e _) (e _) (f _), ← e.map_add_mul, LinearMap.map_neg, neg_add_self,
+    e.map_zero_one, one_smul] at this -- the `(e _)` speeds up elaboration considerably
+  exact this
 #align vector_fourier.fourier_integral_convergent_iff VectorFourier.fourier_integral_convergent_iff
 
 variable [CompleteSpace E]
 
-theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W => L p.1 p.2)
+theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W ↦ L p.1 p.2)
     {f g : V → E} (hf : Integrable f μ) (hg : Integrable g μ) :
     fourierIntegral e μ L f + fourierIntegral e μ L g = fourierIntegral e μ L (f + g) := by
   ext1 w
@@ -171,15 +161,13 @@ theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W
 
 /-- The Fourier integral of an `L^1` function is a continuous function. -/
 theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e)
-    (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (hf : Integrable f μ) :
+    (hL : Continuous fun p : V × W ↦ L p.1 p.2) {f : V → E} (hf : Integrable f μ) :
     Continuous (fourierIntegral e μ L f) := by
   apply continuous_of_dominated
-  · exact fun w => ((fourier_integral_convergent_iff he hL w).mp hf).1
-  · refine' fun w => ae_of_all _ fun v => _
-    · rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
+  · exact fun w ↦ ((fourier_integral_convergent_iff he hL w).mp hf).1
+  · exact fun w ↦ ae_of_all _ fun v ↦ le_of_eq (norm_circle_smul _ _)
   · exact hf.norm
-  · rw [continuous_induced_rng] at he
-    refine' ae_of_all _ fun v => (he.comp (continuous_ofAdd.comp _)).smul continuous_const
+  · refine ae_of_all _ fun v ↦ (he.comp ?_).smul continuous_const
     exact (hL.comp (continuous_prod_mk.mpr ⟨continuous_const, continuous_id⟩)).neg
 #align vector_fourier.fourier_integral_continuous VectorFourier.fourierIntegral_continuous
 
@@ -189,7 +177,7 @@ section Fubini
 
 variable [TopologicalSpace 𝕜] [TopologicalRing 𝕜] [TopologicalSpace V] [BorelSpace V]
   [TopologicalSpace W] [MeasurableSpace W] [BorelSpace W]
-  {e : Multiplicative 𝕜 →* 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
+  {e : AddChar 𝕜 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
   {ν : Measure W} [SigmaFinite μ] [SigmaFinite ν] [SecondCountableTopology V]
 
 variable [CompleteSpace E] [CompleteSpace F]
@@ -198,35 +186,40 @@ variable [CompleteSpace E] [CompleteSpace F]
 Version where the multiplication is replaced by a general bilinear form `M`. -/
 theorem integral_bilin_fourierIntegral_eq_flip
     {f : V → E} {g : W → F} (M : E →L[ℂ] F →L[ℂ] G) (he : Continuous e)
-    (hL : Continuous fun p : V × W => L p.1 p.2) (hf : Integrable f μ) (hg : Integrable g ν) :
+    (hL : Continuous fun p : V × W ↦ L p.1 p.2) (hf : Integrable f μ) (hg : Integrable g ν) :
     ∫ ξ, M (fourierIntegral e μ L f ξ) (g ξ) ∂ν =
       ∫ x, M (f x) (fourierIntegral e ν L.flip g x) ∂μ := by
   by_cases hG : CompleteSpace G; swap; · simp [integral, hG]
   calc
-  ∫ ξ, M (fourierIntegral e μ L f ξ) (g ξ) ∂ν
-    = ∫ ξ, M.flip (g ξ) (∫ x, e[-L x ξ] • f x ∂μ) ∂ν := rfl
-  _ = ∫ ξ, (∫ x, M.flip (g ξ) (e[-L x ξ] • f x) ∂μ) ∂ν := by
+  _ = ∫ ξ, M.flip (g ξ) (∫ x, e (-L x ξ) • f x ∂μ) ∂ν := rfl
+  _ = ∫ ξ, (∫ x, M.flip (g ξ) (e (-L x ξ) • f x) ∂μ) ∂ν := by
     congr with ξ
     apply (ContinuousLinearMap.integral_comp_comm _ _).symm
     exact (fourier_integral_convergent_iff he hL _).1 hf
-  _ = ∫ x, (∫ ξ, M.flip (g ξ) (e[-L x ξ] • f x) ∂ν) ∂μ := by
+  _ = ∫ x, (∫ ξ, M.flip (g ξ) (e (-L x ξ) • f x) ∂ν) ∂μ := by
     rw [integral_integral_swap]
     have : Integrable (fun (p : W × V) ↦ ‖M‖ * (‖g p.1‖ * ‖f p.2‖)) (ν.prod μ) :=
       (hg.norm.prod_mul hf.norm).const_mul _
     apply this.mono
-    · have A : AEStronglyMeasurable (fun (p : W × V) ↦ e[-L p.2 p.1] • f p.2) (ν.prod μ) := by
-        apply (Continuous.aestronglyMeasurable ?_).smul hf.1.snd
-        refine (continuous_induced_rng.mp he).comp (continuous_ofAdd.comp ?_)
-        exact (hL.comp continuous_swap).neg
-      exact M.flip.continuous₂.comp_aestronglyMeasurable (hg.1.fst.prod_mk A)
-    · apply eventually_of_forall
-      rintro ⟨ξ, x⟩
-      simp only [ofAdd_neg, map_inv, coe_inv_unitSphere, SMulHomClass.map_smul,
-        ContinuousLinearMap.flip_apply, Function.uncurry_apply_pair, norm_smul, norm_inv,
-        norm_eq_of_mem_sphere, inv_one, one_mul, norm_mul, norm_norm]
-      exact (M.le_opNorm₂ (f x) (g ξ)).trans (le_of_eq (by ring))
-  _ = ∫ x, (∫ ξ, M (f x) (e[-L.flip ξ x] • g ξ) ∂ν) ∂μ := by simp
-  _ = ∫ x, M (f x) (∫ ξ, e[-L.flip ξ x] • g ξ ∂ν) ∂μ := by
+    · -- This proof can be golfed but becomes very slow; breaking it up into steps
+      -- speeds up compilation.
+      change AEStronglyMeasurable (fun p : W × V ↦ (M (e (-(L p.2) p.1) • f p.2) (g p.1))) _
+      have A : AEStronglyMeasurable (fun (p : W × V) ↦ e (-L p.2 p.1) • f p.2) (ν.prod μ) := by
+        refine (Continuous.aestronglyMeasurable ?_).smul hf.1.snd
+        exact he.comp (hL.comp continuous_swap).neg
+      have A' : AEStronglyMeasurable (fun p ↦ (g p.1, e (-(L p.2) p.1) • f p.2) : W × V → F × E)
+        (Measure.prod ν μ) := hg.1.fst.prod_mk A
+      have B : Continuous (fun q ↦ M q.2 q.1 : F × E → G) := M.flip.continuous₂
+      apply B.comp_aestronglyMeasurable A' -- `exact` works, but `apply` is 10x faster!
+    · filter_upwards with ⟨ξ, x⟩
+      rw [Function.uncurry_apply_pair, Submonoid.smul_def, (M.flip (g ξ)).map_smul,
+        ← Submonoid.smul_def, norm_circle_smul, ContinuousLinearMap.flip_apply,
+        norm_mul, norm_norm M, norm_mul, norm_norm, norm_norm, mul_comm (‖g _‖), ← mul_assoc]
+      exact M.le_opNorm₂ (f x) (g ξ)
+  _ = ∫ x, (∫ ξ, M (f x) (e (-L.flip ξ x) • g ξ) ∂ν) ∂μ := by
+      simp only [ContinuousLinearMap.flip_apply, ContinuousLinearMap.map_smul_of_tower,
+      ContinuousLinearMap.coe_smul', Pi.smul_apply, LinearMap.flip_apply]
+  _ = ∫ x, M (f x) (∫ ξ, e (-L.flip ξ x) • g ξ ∂ν) ∂μ := by
     congr with x
     apply ContinuousLinearMap.integral_comp_comm
     apply (fourier_integral_convergent_iff he _ _).1 hg
@@ -235,7 +228,7 @@ theorem integral_bilin_fourierIntegral_eq_flip
 /-- The Fourier transform satisfies `∫ 𝓕 f * g = ∫ f * 𝓕 g`, i.e., it is self-adjoint. -/
 theorem integral_fourierIntegral_smul_eq_flip
     {f : V → ℂ} {g : W → F} (he : Continuous e)
-    (hL : Continuous fun p : V × W => L p.1 p.2) (hf : Integrable f μ) (hg : Integrable g ν) :
+    (hL : Continuous fun p : V × W ↦ L p.1 p.2) (hf : Integrable f μ) (hg : Integrable g ν) :
     ∫ ξ, (fourierIntegral e μ L f ξ) • (g ξ) ∂ν =
       ∫ x, (f x) • (fourierIntegral e ν L.flip g x) ∂μ :=
   integral_bilin_fourierIntegral_eq_flip (ContinuousLinearMap.lsmul ℂ ℂ) he hL hf hg
@@ -258,30 +251,30 @@ variable [CompleteSpace E]
 
 /-- The Fourier transform integral for `f : 𝕜 → E`, with respect to the measure `μ` and additive
 character `e`. -/
-def fourierIntegral (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (w : 𝕜) : E :=
+def fourierIntegral (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (w : 𝕜) : E :=
   VectorFourier.fourierIntegral e μ (LinearMap.mul 𝕜 𝕜) f w
 #align fourier.fourier_integral Fourier.fourierIntegral
 
-theorem fourierIntegral_def (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (w : 𝕜) :
-    fourierIntegral e μ f w = ∫ v : 𝕜, e[-(v * w)] • f v ∂μ :=
+theorem fourierIntegral_def (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (w : 𝕜) :
+    fourierIntegral e μ f w = ∫ v : 𝕜, e (-(v * w)) • f v ∂μ :=
   rfl
 #align fourier.fourier_integral_def Fourier.fourierIntegral_def
 
-theorem fourierIntegral_smul_const (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (r : ℂ) :
+theorem fourierIntegral_smul_const (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (r : ℂ) :
     fourierIntegral e μ (r • f) = r • fourierIntegral e μ f :=
   VectorFourier.fourierIntegral_smul_const _ _ _ _ _
 #align fourier.fourier_integral_smul_const Fourier.fourierIntegral_smul_const
 
 /-- The uniform norm of the Fourier transform of `f` is bounded by the `L¹` norm of `f`. -/
-theorem norm_fourierIntegral_le_integral_norm (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜)
+theorem norm_fourierIntegral_le_integral_norm (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜)
     (f : 𝕜 → E) (w : 𝕜) : ‖fourierIntegral e μ f w‖ ≤ ∫ x : 𝕜, ‖f x‖ ∂μ :=
   VectorFourier.norm_fourierIntegral_le_integral_norm _ _ _ _ _
 #align fourier.norm_fourier_integral_le_integral_norm Fourier.norm_fourierIntegral_le_integral_norm
 
 /-- The Fourier transform converts right-translation into scalar multiplication by a phase factor.-/
-theorem fourierIntegral_comp_add_right [MeasurableAdd 𝕜] (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure 𝕜)
+theorem fourierIntegral_comp_add_right [MeasurableAdd 𝕜] (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜)
     [μ.IsAddRightInvariant] (f : 𝕜 → E) (v₀ : 𝕜) :
-    fourierIntegral e μ (f ∘ fun v => v + v₀) = fun w => e[v₀ * w] • fourierIntegral e μ f w :=
+    fourierIntegral e μ (f ∘ fun v ↦ v + v₀) = fun w ↦ e (v₀ * w) • fourierIntegral e μ f w :=
   VectorFourier.fourierIntegral_comp_add_right _ _ _ _ _
 #align fourier.fourier_integral_comp_add_right Fourier.fourierIntegral_comp_add_right
 
@@ -294,21 +287,23 @@ open scoped Real
 namespace Real
 
 /-- The standard additive character of `ℝ`, given by `fun x ↦ exp (2 * π * x * I)`. -/
-def fourierChar : Multiplicative ℝ →* 𝕊 where
-  toFun z := expMapCircle (2 * π * Multiplicative.toAdd z)
-  map_one' := by simp only; rw [toAdd_one, mul_zero, expMapCircle_zero]
-  map_mul' x y := by simp only; rw [toAdd_mul, mul_add, expMapCircle_add]
+def fourierChar : AddChar ℝ 𝕊 where
+  toFun z := expMapCircle (2 * π * z)
+  map_zero_one' := by simp only; rw [mul_zero, expMapCircle_zero]
+  map_add_mul' x y := by simp only; rw [mul_add, expMapCircle_add]
 #align real.fourier_char Real.fourierChar
 
 @[inherit_doc] scoped[FourierTransform] notation "𝐞" => Real.fourierChar
 
-theorem fourierChar_apply (x : ℝ) : 𝐞[x] = Complex.exp (↑(2 * π * x) * Complex.I) :=
-  by rfl
+open FourierTransform
+
+theorem fourierChar_apply (x : ℝ) : 𝐞 x = Complex.exp (↑(2 * π * x) * Complex.I) :=
+  rfl
 #align real.fourier_char_apply Real.fourierChar_apply
 
 @[continuity]
 theorem continuous_fourierChar : Continuous 𝐞 :=
-  (map_continuous expMapCircle).comp (continuous_const.mul continuous_toAdd)
+  (map_continuous expMapCircle).comp (continuous_mul_left _)
 #align real.continuous_fourier_char Real.continuous_fourierChar
 
 variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
@@ -318,7 +313,8 @@ theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type*} [AddCommGroup V]
     (μ : Measure V) (f : V → E) (w : W) :
     VectorFourier.fourierIntegral fourierChar μ L f w =
       ∫ v : V, Complex.exp (↑(-2 * π * L v w) * Complex.I) • f v ∂μ :=
-  by simp_rw [VectorFourier.fourierIntegral, Real.fourierChar_apply, mul_neg, neg_mul]
+  by simp_rw [VectorFourier.fourierIntegral, Submonoid.smul_def, Real.fourierChar_apply, mul_neg,
+    neg_mul]
 #align real.vector_fourier_integral_eq_integral_exp_smul Real.vector_fourierIntegral_eq_integral_exp_smul
 
 
@@ -345,19 +341,19 @@ def fourierIntegralInv (f : V → E) (w : V) : E :=
 @[inherit_doc] scoped[FourierTransform] notation "𝓕⁻" => Real.fourierIntegralInv
 
 lemma fourierIntegral_eq (f : V → E) (w : V) :
-    𝓕 f w = ∫ v, 𝐞[-⟪v, w⟫] • f v := rfl
+    𝓕 f w = ∫ v, 𝐞 (-⟪v, w⟫) • f v := rfl
 
 lemma fourierIntegral_eq' (f : V → E) (w : V) :
     𝓕 f w = ∫ v, Complex.exp ((↑(-2 * π * ⟪v, w⟫) * Complex.I)) • f v := by
-  simp_rw [fourierIntegral_eq, Real.fourierChar_apply, mul_neg, neg_mul]
+  simp_rw [fourierIntegral_eq, Submonoid.smul_def, Real.fourierChar_apply, mul_neg, neg_mul]
 
 lemma fourierIntegralInv_eq (f : V → E) (w : V) :
-    𝓕⁻ f w = ∫ v, 𝐞[⟪v, w⟫] • f v := by
+    𝓕⁻ f w = ∫ v, 𝐞 ⟪v, w⟫ • f v := by
   simp [fourierIntegralInv, VectorFourier.fourierIntegral]
 
 lemma fourierIntegralInv_eq' (f : V → E) (w : V) :
     𝓕⁻ f w = ∫ v, Complex.exp ((↑(2 * π * ⟪v, w⟫) * Complex.I)) • f v := by
-  simp_rw [fourierIntegralInv_eq, Real.fourierChar_apply]
+  simp_rw [fourierIntegralInv_eq, Submonoid.smul_def, Real.fourierChar_apply]
 
 lemma fourierIntegralInv_eq_fourierIntegral_neg (f : V → E) (w : V) :
     𝓕⁻ f w = 𝓕 f (-w) := by
@@ -365,16 +361,15 @@ lemma fourierIntegralInv_eq_fourierIntegral_neg (f : V → E) (w : V) :
 
 lemma fourierIntegral_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
     𝓕 (f ∘ A) w = (𝓕 f) (A w) := by
-  simp only [fourierIntegral_eq, ofAdd_neg, map_inv, coe_inv_unitSphere, Function.comp_apply,
-    ← MeasurePreserving.integral_comp A.measurePreserving A.toHomeomorph.measurableEmbedding,
-    ← A.inner_map_map]
+  simp only [fourierIntegral_eq, ← A.inner_map_map, Function.comp_apply, ←
+    MeasurePreserving.integral_comp A.measurePreserving A.toHomeomorph.measurableEmbedding]
 
 lemma fourierIntegralInv_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
     𝓕⁻ (f ∘ A) w = (𝓕⁻ f) (A w) := by
   simp [fourierIntegralInv_eq_fourierIntegral_neg, fourierIntegral_comp_linearIsometry]
 
 theorem fourierIntegral_real_eq (f : ℝ → E) (w : ℝ) :
-    fourierIntegral f w = ∫ v : ℝ, 𝐞[-(v * w)] • f v :=
+    fourierIntegral f w = ∫ v : ℝ, 𝐞 (-(v * w)) • f v :=
   rfl
 #align real.fourier_integral_def Real.fourierIntegral_real_eq
 
@@ -382,7 +377,8 @@ theorem fourierIntegral_real_eq (f : ℝ → E) (w : ℝ) :
 
 theorem fourierIntegral_real_eq_integral_exp_smul (f : ℝ → E) (w : ℝ) :
     𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v := by
-  simp_rw [fourierIntegral_real_eq, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
+  simp_rw [fourierIntegral_real_eq, Submonoid.smul_def, Real.fourierChar_apply, mul_neg, neg_mul,
+    mul_assoc]
 #align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_real_eq_integral_exp_smul
 
 @[deprecated] alias fourierIntegral_eq_integral_exp_smul :=

Lemma names around cancellation of multiplication and division are a mess.

This PR renames a handful of them according to the following table (each big row contains the multiplicative statement, then the three rows contain the GroupWithZero lemma name, the Group lemma, the AddGroup lemma name).

| Statement | New name | Old name | |

@@ -114,7 +114,7 @@ theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 
       fun w => e[L v₀ w] • fourierIntegral e μ L f w := by
   ext1 w
   dsimp only [fourierIntegral, Function.comp_apply]
-  conv in L _ => rw [← add_sub_cancel v v₀]
+  conv in L _ => rw [← add_sub_cancel_right v v₀]
   rw [integral_add_right_eq_self fun v : V => e[-L (v - v₀) w] • f v, ← integral_smul]
   congr 1 with v
   rw [← smul_assoc, smul_eq_mul, ← Submonoid.coe_mul, ← e.map_mul, ← ofAdd_add, ←

Also extend the notation 𝓕 for the Fourier transform to inner product spaces, introduce a notation 𝓕⁻ for the inverse Fourier transform, and generalize a few results from the real line to inner product spaces.

@@ -5,7 +5,10 @@ Authors: David Loeffler
 -/
 import Mathlib.Analysis.Complex.Circle
 import Mathlib.MeasureTheory.Group.Integral
+import Mathlib.MeasureTheory.Integral.SetIntegral
 import Mathlib.MeasureTheory.Measure.Haar.OfBasis
+import Mathlib.MeasureTheory.Constructions.Prod.Integral
+import Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace
 
 #align_import analysis.fourier.fourier_transform from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
 
@@ -33,12 +36,17 @@ where `e [x]` is notational sugar for `(e (Multiplicative.ofAdd x) : ℂ)` (avai
 `fourier_transform`). This includes the cases `W` is the dual of `V` and `L` is the canonical
 pairing, or `W = V` and `L` is a bilinear form (e.g. an inner product).
 
-In namespace `fourier`, we consider the more familiar special case when `V = W = 𝕜` and `L` is the
+In namespace `Fourier`, we consider the more familiar special case when `V = W = 𝕜` and `L` is the
 multiplication map (but still allowing `𝕜` to be an arbitrary ring equipped with a measure).
 
 The most familiar case of all is when `V = W = 𝕜 = ℝ`, `L` is multiplication, `μ` is volume, and
-`e` is `Real.fourierChar`, i.e. the character `fun x ↦ exp ((2 * π * x) * I)`. The Fourier integral
-in this case is defined as `Real.fourierIntegral`.
+`e` is `Real.fourierChar`, i.e. the character `fun x ↦ exp ((2 * π * x) * I)` (for which we
+introduce the notation `𝐞` in the locale `FourierTransform`).
+
+Another familiar case (which generalizes the previous one) is when `V = W` is an inner product space
+over `ℝ` and `L` is the scalar product. We introduce two notations `𝓕` for the Fourier transform in
+this case and `𝓕⁻ f (v) = 𝓕 f (-v)` for the inverse Fourier transform. These notations make
+in particular sense for `V = W = ℝ`.
 
 ## Main results
 
@@ -56,6 +64,7 @@ open MeasureTheory Filter
 open scoped Topology
 
 -- To avoid messing around with multiplicative vs. additive characters, we make a notation.
+/-- Notation for multiplicative character applied in an additive setting. -/
 scoped[FourierTransform] notation e "[" x "]" => (e (Multiplicative.ofAdd x) : ℂ)
 
 open FourierTransform
@@ -66,7 +75,9 @@ open FourierTransform
 namespace VectorFourier
 
 variable {𝕜 : Type*} [CommRing 𝕜] {V : Type*} [AddCommGroup V] [Module 𝕜 V] [MeasurableSpace V]
-  {W : Type*} [AddCommGroup W] [Module 𝕜 W] {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  {W : Type*} [AddCommGroup W] [Module 𝕜 W]
+  {E F G : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [NormedAddCommGroup F] [NormedSpace ℂ F]
+  [NormedAddCommGroup G] [NormedSpace ℂ G]
 
 section Defs
 
@@ -174,6 +185,63 @@ theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e
 
 end Continuous
 
+section Fubini
+
+variable [TopologicalSpace 𝕜] [TopologicalRing 𝕜] [TopologicalSpace V] [BorelSpace V]
+  [TopologicalSpace W] [MeasurableSpace W] [BorelSpace W]
+  {e : Multiplicative 𝕜 →* 𝕊} {μ : Measure V} {L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜}
+  {ν : Measure W} [SigmaFinite μ] [SigmaFinite ν] [SecondCountableTopology V]
+
+variable [CompleteSpace E] [CompleteSpace F]
+
+/-- The Fourier transform satisfies `∫ 𝓕 f * g = ∫ f * 𝓕 g`, i.e., it is self-adjoint.
+Version where the multiplication is replaced by a general bilinear form `M`. -/
+theorem integral_bilin_fourierIntegral_eq_flip
+    {f : V → E} {g : W → F} (M : E →L[ℂ] F →L[ℂ] G) (he : Continuous e)
+    (hL : Continuous fun p : V × W => L p.1 p.2) (hf : Integrable f μ) (hg : Integrable g ν) :
+    ∫ ξ, M (fourierIntegral e μ L f ξ) (g ξ) ∂ν =
+      ∫ x, M (f x) (fourierIntegral e ν L.flip g x) ∂μ := by
+  by_cases hG : CompleteSpace G; swap; · simp [integral, hG]
+  calc
+  ∫ ξ, M (fourierIntegral e μ L f ξ) (g ξ) ∂ν
+    = ∫ ξ, M.flip (g ξ) (∫ x, e[-L x ξ] • f x ∂μ) ∂ν := rfl
+  _ = ∫ ξ, (∫ x, M.flip (g ξ) (e[-L x ξ] • f x) ∂μ) ∂ν := by
+    congr with ξ
+    apply (ContinuousLinearMap.integral_comp_comm _ _).symm
+    exact (fourier_integral_convergent_iff he hL _).1 hf
+  _ = ∫ x, (∫ ξ, M.flip (g ξ) (e[-L x ξ] • f x) ∂ν) ∂μ := by
+    rw [integral_integral_swap]
+    have : Integrable (fun (p : W × V) ↦ ‖M‖ * (‖g p.1‖ * ‖f p.2‖)) (ν.prod μ) :=
+      (hg.norm.prod_mul hf.norm).const_mul _
+    apply this.mono
+    · have A : AEStronglyMeasurable (fun (p : W × V) ↦ e[-L p.2 p.1] • f p.2) (ν.prod μ) := by
+        apply (Continuous.aestronglyMeasurable ?_).smul hf.1.snd
+        refine (continuous_induced_rng.mp he).comp (continuous_ofAdd.comp ?_)
+        exact (hL.comp continuous_swap).neg
+      exact M.flip.continuous₂.comp_aestronglyMeasurable (hg.1.fst.prod_mk A)
+    · apply eventually_of_forall
+      rintro ⟨ξ, x⟩
+      simp only [ofAdd_neg, map_inv, coe_inv_unitSphere, SMulHomClass.map_smul,
+        ContinuousLinearMap.flip_apply, Function.uncurry_apply_pair, norm_smul, norm_inv,
+        norm_eq_of_mem_sphere, inv_one, one_mul, norm_mul, norm_norm]
+      exact (M.le_opNorm₂ (f x) (g ξ)).trans (le_of_eq (by ring))
+  _ = ∫ x, (∫ ξ, M (f x) (e[-L.flip ξ x] • g ξ) ∂ν) ∂μ := by simp
+  _ = ∫ x, M (f x) (∫ ξ, e[-L.flip ξ x] • g ξ ∂ν) ∂μ := by
+    congr with x
+    apply ContinuousLinearMap.integral_comp_comm
+    apply (fourier_integral_convergent_iff he _ _).1 hg
+    exact hL.comp continuous_swap
+
+/-- The Fourier transform satisfies `∫ 𝓕 f * g = ∫ f * 𝓕 g`, i.e., it is self-adjoint. -/
+theorem integral_fourierIntegral_smul_eq_flip
+    {f : V → ℂ} {g : W → F} (he : Continuous e)
+    (hL : Continuous fun p : V × W => L p.1 p.2) (hf : Integrable f μ) (hg : Integrable g ν) :
+    ∫ ξ, (fourierIntegral e μ L f ξ) • (g ξ) ∂ν =
+      ∫ x, (f x) • (fourierIntegral e ν L.flip g x) ∂μ :=
+  integral_bilin_fourierIntegral_eq_flip (ContinuousLinearMap.lsmul ℂ ℂ) he hL hf hg
+
+end Fubini
+
 end VectorFourier
 
 /-! ## Fourier theory for functions on `𝕜` -/
@@ -232,12 +300,14 @@ def fourierChar : Multiplicative ℝ →* 𝕊 where
   map_mul' x y := by simp only; rw [toAdd_mul, mul_add, expMapCircle_add]
 #align real.fourier_char Real.fourierChar
 
-theorem fourierChar_apply (x : ℝ) : Real.fourierChar[x] = Complex.exp (↑(2 * π * x) * Complex.I) :=
+@[inherit_doc] scoped[FourierTransform] notation "𝐞" => Real.fourierChar
+
+theorem fourierChar_apply (x : ℝ) : 𝐞[x] = Complex.exp (↑(2 * π * x) * Complex.I) :=
   by rfl
 #align real.fourier_char_apply Real.fourierChar_apply
 
 @[continuity]
-theorem continuous_fourierChar : Continuous Real.fourierChar :=
+theorem continuous_fourierChar : Continuous 𝐞 :=
   (map_continuous expMapCircle).comp (continuous_const.mul continuous_toAdd)
 #align real.continuous_fourier_char Real.continuous_fourierChar
 
@@ -251,23 +321,71 @@ theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type*} [AddCommGroup V]
   by simp_rw [VectorFourier.fourierIntegral, Real.fourierChar_apply, mul_neg, neg_mul]
 #align real.vector_fourier_integral_eq_integral_exp_smul Real.vector_fourierIntegral_eq_integral_exp_smul
 
-/-- The Fourier integral for `f : ℝ → E`, with respect to the standard additive character and
-measure on `ℝ`. -/
-def fourierIntegral (f : ℝ → E) (w : ℝ) :=
-  Fourier.fourierIntegral fourierChar volume f w
+
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  {V : Type*} [NormedAddCommGroup V]
+  [InnerProductSpace ℝ V] [MeasurableSpace V] [BorelSpace V] [FiniteDimensional ℝ V]
+  {W : Type*} [NormedAddCommGroup W]
+  [InnerProductSpace ℝ W] [MeasurableSpace W] [BorelSpace W] [FiniteDimensional ℝ W]
+
+open scoped RealInnerProductSpace
+
+/-- The Fourier transform of a function on an inner product space, with respect to the standard
+additive character `ω ↦ exp (2 i π ω)`. -/
+def fourierIntegral (f : V → E) (w : V) : E :=
+  VectorFourier.fourierIntegral 𝐞 volume (innerₗ V) f w
 #align real.fourier_integral Real.fourierIntegral
 
-theorem fourierIntegral_def (f : ℝ → E) (w : ℝ) :
-    fourierIntegral f w = ∫ v : ℝ, fourierChar[-(v * w)] • f v :=
-  rfl
-#align real.fourier_integral_def Real.fourierIntegral_def
+/-- The inverse Fourier transform of a function on an inner product space, defined as the Fourier
+transform but with opposite sign in the exponential. -/
+def fourierIntegralInv (f : V → E) (w : V) : E :=
+  VectorFourier.fourierIntegral 𝐞 volume (-innerₗ V) f w
 
 @[inherit_doc] scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
+@[inherit_doc] scoped[FourierTransform] notation "𝓕⁻" => Real.fourierIntegralInv
+
+lemma fourierIntegral_eq (f : V → E) (w : V) :
+    𝓕 f w = ∫ v, 𝐞[-⟪v, w⟫] • f v := rfl
 
-theorem fourierIntegral_eq_integral_exp_smul {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
-    (f : ℝ → E) (w : ℝ) :
+lemma fourierIntegral_eq' (f : V → E) (w : V) :
+    𝓕 f w = ∫ v, Complex.exp ((↑(-2 * π * ⟪v, w⟫) * Complex.I)) • f v := by
+  simp_rw [fourierIntegral_eq, Real.fourierChar_apply, mul_neg, neg_mul]
+
+lemma fourierIntegralInv_eq (f : V → E) (w : V) :
+    𝓕⁻ f w = ∫ v, 𝐞[⟪v, w⟫] • f v := by
+  simp [fourierIntegralInv, VectorFourier.fourierIntegral]
+
+lemma fourierIntegralInv_eq' (f : V → E) (w : V) :
+    𝓕⁻ f w = ∫ v, Complex.exp ((↑(2 * π * ⟪v, w⟫) * Complex.I)) • f v := by
+  simp_rw [fourierIntegralInv_eq, Real.fourierChar_apply]
+
+lemma fourierIntegralInv_eq_fourierIntegral_neg (f : V → E) (w : V) :
+    𝓕⁻ f w = 𝓕 f (-w) := by
+  simp [fourierIntegral_eq, fourierIntegralInv_eq]
+
+lemma fourierIntegral_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
+    𝓕 (f ∘ A) w = (𝓕 f) (A w) := by
+  simp only [fourierIntegral_eq, ofAdd_neg, map_inv, coe_inv_unitSphere, Function.comp_apply,
+    ← MeasurePreserving.integral_comp A.measurePreserving A.toHomeomorph.measurableEmbedding,
+    ← A.inner_map_map]
+
+lemma fourierIntegralInv_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
+    𝓕⁻ (f ∘ A) w = (𝓕⁻ f) (A w) := by
+  simp [fourierIntegralInv_eq_fourierIntegral_neg, fourierIntegral_comp_linearIsometry]
+
+theorem fourierIntegral_real_eq (f : ℝ → E) (w : ℝ) :
+    fourierIntegral f w = ∫ v : ℝ, 𝐞[-(v * w)] • f v :=
+  rfl
+#align real.fourier_integral_def Real.fourierIntegral_real_eq
+
+@[deprecated] alias fourierIntegral_def := fourierIntegral_real_eq -- deprecated on 2024-02-21
+
+theorem fourierIntegral_real_eq_integral_exp_smul (f : ℝ → E) (w : ℝ) :
     𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v := by
-  simp_rw [fourierIntegral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
-#align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_eq_integral_exp_smul
+  simp_rw [fourierIntegral_real_eq, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
+#align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_real_eq_integral_exp_smul
+
+@[deprecated] alias fourierIntegral_eq_integral_exp_smul :=
+  fourierIntegral_real_eq_integral_exp_smul -- deprecated on 2024-02-21
 
 end Real

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

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

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

@@ -169,7 +169,7 @@ theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e
   · exact hf.norm
   · rw [continuous_induced_rng] at he
     refine' ae_of_all _ fun v => (he.comp (continuous_ofAdd.comp _)).smul continuous_const
-    refine' (hL.comp (continuous_prod_mk.mpr ⟨continuous_const, continuous_id⟩)).neg
+    exact (hL.comp (continuous_prod_mk.mpr ⟨continuous_const, continuous_id⟩)).neg
 #align vector_fourier.fourier_integral_continuous VectorFourier.fourierIntegral_continuous
 
 end Continuous

Make all the notations that unambiguously should inherit the docstring of their definition actually inherit it.

Also write a few docstrings by hand. I only wrote the ones I was competent to write and which I was sure of. Some docstrings come from mathlib3 as they were lost during the early port.

This PR is only intended as a first pass There are many more docstrings to add.

@@ -262,7 +262,7 @@ theorem fourierIntegral_def (f : ℝ → E) (w : ℝ) :
   rfl
 #align real.fourier_integral_def Real.fourierIntegral_def
 
-scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
+@[inherit_doc] scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
 
 theorem fourierIntegral_eq_integral_exp_smul {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
     (f : ℝ → E) (w : ℝ) :

This eliminates (fun a ↦ β) α in the type when applying a FunLike.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -104,9 +104,7 @@ theorem fourierIntegral_comp_add_right [MeasurableAdd V] (e : Multiplicative 
   ext1 w
   dsimp only [fourierIntegral, Function.comp_apply]
   conv in L _ => rw [← add_sub_cancel v v₀]
-  rw [integral_add_right_eq_self fun v : V => e[-L (v - v₀) w] • f v]
-  dsimp only
-  rw [← integral_smul]
+  rw [integral_add_right_eq_self fun v : V => e[-L (v - v₀) w] • f v, ← integral_smul]
   congr 1 with v
   rw [← smul_assoc, smul_eq_mul, ← Submonoid.coe_mul, ← e.map_mul, ← ofAdd_add, ←
     LinearMap.neg_apply, ← sub_eq_add_neg, ← LinearMap.sub_apply, LinearMap.map_sub, neg_sub]

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

@@ -161,7 +161,7 @@ theorem fourierIntegral_add (he : Continuous e) (hL : Continuous fun p : V × W
 #align vector_fourier.fourier_integral_add VectorFourier.fourierIntegral_add
 
 /-- The Fourier integral of an `L^1` function is a continuous function. -/
-theorem fourierIntegral_continuous [TopologicalSpace.FirstCountableTopology W] (he : Continuous e)
+theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e)
     (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (hf : Integrable f μ) :
     Continuous (fourierIntegral e μ L f) := by
   apply continuous_of_dominated

This rolls in the changed from #6928.

Co-authored-by: Thomas Murrills <thomasmurrills@gmail.com>

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

@@ -167,7 +167,6 @@ theorem fourierIntegral_continuous [TopologicalSpace.FirstCountableTopology W] (
   apply continuous_of_dominated
   · exact fun w => ((fourier_integral_convergent_iff he hL w).mp hf).1
   · refine' fun w => ae_of_all _ fun v => _
-    · exact fun v => ‖f v‖
     · rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
   · exact hf.norm
   · rw [continuous_induced_rng] at he

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
 -/
 import Mathlib.Analysis.Complex.Circle
-import Mathlib.MeasureTheory.Group.Integration
+import Mathlib.MeasureTheory.Group.Integral
 import Mathlib.MeasureTheory.Measure.Haar.OfBasis
 
 #align_import analysis.fourier.fourier_transform from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

@@ -231,7 +231,7 @@ namespace Real
 /-- The standard additive character of `ℝ`, given by `fun x ↦ exp (2 * π * x * I)`. -/
 def fourierChar : Multiplicative ℝ →* 𝕊 where
   toFun z := expMapCircle (2 * π * Multiplicative.toAdd z)
-  map_one' := by simp only; rw [toAdd_one, MulZeroClass.mul_zero, expMapCircle_zero]
+  map_one' := by simp only; rw [toAdd_one, mul_zero, expMapCircle_zero]
   map_mul' x y := by simp only; rw [toAdd_mul, mul_add, expMapCircle_add]
 #align real.fourier_char Real.fourierChar
 

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

This has nice performance benefits.

@@ -65,8 +65,8 @@ open FourierTransform
 
 namespace VectorFourier
 
-variable {𝕜 : Type _} [CommRing 𝕜] {V : Type _} [AddCommGroup V] [Module 𝕜 V] [MeasurableSpace V]
-  {W : Type _} [AddCommGroup W] [Module 𝕜 W] {E : Type _} [NormedAddCommGroup E] [NormedSpace ℂ E]
+variable {𝕜 : Type*} [CommRing 𝕜] {V : Type*} [AddCommGroup V] [Module 𝕜 V] [MeasurableSpace V]
+  {W : Type*} [AddCommGroup W] [Module 𝕜 W] {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
 
 section Defs
 
@@ -184,7 +184,7 @@ end VectorFourier
 
 namespace Fourier
 
-variable {𝕜 : Type _} [CommRing 𝕜] [MeasurableSpace 𝕜] {E : Type _} [NormedAddCommGroup E]
+variable {𝕜 : Type*} [CommRing 𝕜] [MeasurableSpace 𝕜] {E : Type*} [NormedAddCommGroup E]
   [NormedSpace ℂ E]
 
 section Defs
@@ -244,10 +244,10 @@ theorem continuous_fourierChar : Continuous Real.fourierChar :=
   (map_continuous expMapCircle).comp (continuous_const.mul continuous_toAdd)
 #align real.continuous_fourier_char Real.continuous_fourierChar
 
-variable {E : Type _} [NormedAddCommGroup E] [NormedSpace ℂ E]
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
 
-theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type _} [AddCommGroup V] [Module ℝ V]
-    [MeasurableSpace V] {W : Type _} [AddCommGroup W] [Module ℝ W] (L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ)
+theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type*} [AddCommGroup V] [Module ℝ V]
+    [MeasurableSpace V] {W : Type*} [AddCommGroup W] [Module ℝ W] (L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ)
     (μ : Measure V) (f : V → E) (w : W) :
     VectorFourier.fourierIntegral fourierChar μ L f w =
       ∫ v : V, Complex.exp (↑(-2 * π * L v w) * Complex.I) • f v ∂μ :=
@@ -267,7 +267,7 @@ theorem fourierIntegral_def (f : ℝ → E) (w : ℝ) :
 
 scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
 
-theorem fourierIntegral_eq_integral_exp_smul {E : Type _} [NormedAddCommGroup E] [NormedSpace ℂ E]
+theorem fourierIntegral_eq_integral_exp_smul {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
     (f : ℝ → E) (w : ℝ) :
     𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v := by
   simp_rw [fourierIntegral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]

• depends on: #5966

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

@@ -2,16 +2,13 @@
 Copyright (c) 2023 David Loeffler. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Loeffler
-
-! This file was ported from Lean 3 source module analysis.fourier.fourier_transform
-! leanprover-community/mathlib commit fd5edc43dc4f10b85abfe544b88f82cf13c5f844
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Complex.Circle
 import Mathlib.MeasureTheory.Group.Integration
 import Mathlib.MeasureTheory.Measure.Haar.OfBasis
 
+#align_import analysis.fourier.fourier_transform from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
+
 /-!
 # The Fourier transform
 

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.

@@ -73,8 +73,6 @@ variable {𝕜 : Type _} [CommRing 𝕜] {V : Type _} [AddCommGroup V] [Module 
 
 section Defs
 
-variable [CompleteSpace E]
-
 /-- The Fourier transform integral for `f : V → E`, with respect to a bilinear form `L : V × W → 𝕜`
 and an additive character `e`. -/
 def fourierIntegral (e : Multiplicative 𝕜 →* 𝕊) (μ : Measure V) (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E)
@@ -249,7 +247,7 @@ theorem continuous_fourierChar : Continuous Real.fourierChar :=
   (map_continuous expMapCircle).comp (continuous_const.mul continuous_toAdd)
 #align real.continuous_fourier_char Real.continuous_fourierChar
 
-variable {E : Type _} [NormedAddCommGroup E] [CompleteSpace E] [NormedSpace ℂ E]
+variable {E : Type _} [NormedAddCommGroup E] [NormedSpace ℂ E]
 
 theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type _} [AddCommGroup V] [Module ℝ V]
     [MeasurableSpace V] {W : Type _} [AddCommGroup W] [Module ℝ W] (L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ)
@@ -272,8 +270,8 @@ theorem fourierIntegral_def (f : ℝ → E) (w : ℝ) :
 
 scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
 
-theorem fourierIntegral_eq_integral_exp_smul {E : Type _} [NormedAddCommGroup E] [CompleteSpace E]
-    [NormedSpace ℂ E] (f : ℝ → E) (w : ℝ) :
+theorem fourierIntegral_eq_integral_exp_smul {E : Type _} [NormedAddCommGroup E] [NormedSpace ℂ E]
+    (f : ℝ → E) (w : ℝ) :
     𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v := by
   simp_rw [fourierIntegral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
 #align real.fourier_integral_eq_integral_exp_smul Real.fourierIntegral_eq_integral_exp_smul

Found with git grep -n "λ [a-zA-Z_ ]*,"

@@ -30,7 +30,7 @@ In namespace `VectorFourier`, we define the Fourier integral in the following co
 With these definitions, we define `fourierIntegral` to be the map from functions `V → E` to
 functions `W → E` that sends `f` to
 
-`λ w, ∫ v in V, e [-L v w] • f v ∂μ`,
+`fun w ↦ ∫ v in V, e [-L v w] • f v ∂μ`,
 
 where `e [x]` is notational sugar for `(e (Multiplicative.ofAdd x) : ℂ)` (available in locale
 `fourier_transform`). This includes the cases `W` is the dual of `V` and `L` is the canonical
@@ -40,7 +40,7 @@ In namespace `fourier`, we consider the more familiar special case when `V = W =
 multiplication map (but still allowing `𝕜` to be an arbitrary ring equipped with a measure).
 
 The most familiar case of all is when `V = W = 𝕜 = ℝ`, `L` is multiplication, `μ` is volume, and
-`e` is `Real.fourierChar`, i.e. the character `λ x, exp ((2 * π * x) * I)`. The Fourier integral
+`e` is `Real.fourierChar`, i.e. the character `fun x ↦ exp ((2 * π * x) * I)`. The Fourier integral
 in this case is defined as `Real.fourierIntegral`.
 
 ## Main results
@@ -233,7 +233,7 @@ open scoped Real
 
 namespace Real
 
-/-- The standard additive character of `ℝ`, given by `λ x, exp (2 * π * x * I)`. -/
+/-- The standard additive character of `ℝ`, given by `fun x ↦ exp (2 * π * x * I)`. -/
 def fourierChar : Multiplicative ℝ →* 𝕊 where
   toFun z := expMapCircle (2 * π * Multiplicative.toAdd z)
   map_one' := by simp only; rw [toAdd_one, MulZeroClass.mul_zero, expMapCircle_zero]