File: Mathlib/Analysis/Fourier/FourierTransform.lean

full_name: _aux_Mathlib_Analysis_Fourier_FourierTransform___unexpand_circle_1
code: local notation "𝕊" => circle
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Analysis_Fourier_FourierTransform___macroRules_term𝕊_1
code: local notation "𝕊" => circle
goal: Lean.Macro

full_name: VectorFourier.fourierIntegral
code: /-- 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 : AddChar 𝕜 𝕊) (μ : Measure V) (L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E)
    (w : W) : E 
goal: E

full_name: VectorFourier.fourierIntegral_smul_const
code: 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 
goal: VectorFourier.fourierIntegral e μ L (r • f) = r • VectorFourier.fourierIntegral e μ L f

full_name: VectorFourier.norm_fourierIntegral_le_integral_norm
code: /-- The uniform norm of the Fourier integral of `f` is bounded by the `L¹` norm of `f`. -/
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‖ ∂μ 
goal: ‖VectorFourier.fourierIntegral e μ L f w‖ ≤ ∫ (v : V), ‖f v‖ ∂μ

full_name: VectorFourier.fourierIntegral_comp_add_right
code: /-- 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₀) =
      fun w ↦ e (L v₀ w) • fourierIntegral e μ L f w 
goal: VectorFourier.fourierIntegral e μ L (f ∘ fun v => v + v₀) = fun w =>
  e ((L v₀) w) • VectorFourier.fourierIntegral e μ L f w

full_name: VectorFourier.fourierIntegral_convergent_iff
code: /-- For any `w`, the Fourier integral is convergent iff `f` is integrable. -/
theorem fourierIntegral_convergent_iff (he : Continuous e)
    (hL : Continuous fun p : V × W ↦ L p.1 p.2) {f : V → E} (w : W) :
    Integrable (fun v : V ↦ e (-L v w) • f v) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (fun v => e (-(L v) w) • f v) μ ↔ MeasureTheory.Integrable f μ

full_name: VectorFourier.fourierIntegral_add
code: 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) 
goal: VectorFourier.fourierIntegral e μ L f + VectorFourier.fourierIntegral e μ L g =
  VectorFourier.fourierIntegral e μ L (f + g)

full_name: VectorFourier.fourierIntegral_continuous
code: /-- 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 μ) :
    Continuous (fourierIntegral e μ L f) 
goal: Continuous (VectorFourier.fourierIntegral e μ L f)

full_name: VectorFourier.integral_bilin_fourierIntegral_eq_flip
code: /-- 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) ∂μ 
goal: ∫ (ξ : W), (M (VectorFourier.fourierIntegral e μ L f ξ)) (g ξ) ∂ν =
  ∫ (x : V), (M (f x)) (VectorFourier.fourierIntegral e ν L.flip g x) ∂μ

full_name: VectorFourier.integral_fourierIntegral_smul_eq_flip
code: /-- 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) ∂μ 
goal: ∫ (ξ : W), VectorFourier.fourierIntegral e μ L f ξ • g ξ ∂ν =
  ∫ (x : V), f x • VectorFourier.fourierIntegral e ν L.flip g x ∂μ

full_name: VectorFourier.fourierIntegral_continuousLinearMap_apply
code: 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 
goal: (VectorFourier.fourierIntegral e μ L.toLinearMap₂ f w) a =
  VectorFourier.fourierIntegral e μ L.toLinearMap₂ (fun x => (f x) a) w

full_name: VectorFourier.fourierIntegral_continuousMultilinearMap_apply
code: 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 
goal: (VectorFourier.fourierIntegral e μ L.toLinearMap₂ f w) m =
  VectorFourier.fourierIntegral e μ L.toLinearMap₂ (fun x => (f x) m) w

full_name: Fourier.fourierIntegral
code: /-- The Fourier transform integral for `f : 𝕜 → E`, with respect to the measure `μ` and additive
character `e`. -/
def fourierIntegral (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (w : 𝕜) : E 
goal: E

full_name: Fourier.fourierIntegral_def
code: theorem fourierIntegral_def (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (w : 𝕜) :
    fourierIntegral e μ f w = ∫ v : 𝕜, e (-(v * w)) • f v ∂μ 
goal: Fourier.fourierIntegral e μ f w = ∫ (v : 𝕜), e (-(v * w)) • f v ∂μ

full_name: Fourier.fourierIntegral_smul_const
code: theorem fourierIntegral_smul_const (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜) (f : 𝕜 → E) (r : ℂ) :
    fourierIntegral e μ (r • f) = r • fourierIntegral e μ f 
goal: Fourier.fourierIntegral e μ (r • f) = r • Fourier.fourierIntegral e μ f

full_name: Fourier.norm_fourierIntegral_le_integral_norm
code: /-- The uniform norm of the Fourier transform of `f` is bounded by the `L¹` norm of `f`. -/
theorem norm_fourierIntegral_le_integral_norm (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜)
    (f : 𝕜 → E) (w : 𝕜) : ‖fourierIntegral e μ f w‖ ≤ ∫ x : 𝕜, ‖f x‖ ∂μ 
goal: ‖Fourier.fourierIntegral e μ f w‖ ≤ ∫ (x : 𝕜), ‖f x‖ ∂μ

full_name: Fourier.fourierIntegral_comp_add_right
code: /-- 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 
goal: Fourier.fourierIntegral e μ (f ∘ fun v => v + v₀) = fun w => e (v₀ * w) • Fourier.fourierIntegral e μ f w

full_name: Real.fourierChar
code: /-- The standard additive character of `ℝ`, given by `fun x ↦ exp (2 * π * x * I)`. -/
def fourierChar : AddChar ℝ 𝕊 
goal: AddChar ℝ ↥𝕊

full_name: FourierTransform._aux_Mathlib_Analysis_Fourier_FourierTransform___unexpand_Real_fourierChar_1
code: @[inherit_doc] scoped[FourierTransform] notation "𝐞" => Real.fourierChar
goal: Lean.PrettyPrinter.Unexpander

full_name: FourierTransform.«_aux_Mathlib_Analysis_Fourier_FourierTransform___macroRules_FourierTransform_term𝐞_1»
code: @[inherit_doc] scoped[FourierTransform] notation "𝐞" => Real.fourierChar
goal: Lean.Macro

full_name: Real.fourierChar_apply
code: theorem fourierChar_apply (x : ℝ) : 𝐞 x = Complex.exp (↑(2 * π * x) * Complex.I) 
goal: ↑(Real.fourierChar x) = Complex.exp (↑(2 * π * x) * Complex.I)

full_name: Real.continuous_fourierChar
code: @[continuity]
theorem continuous_fourierChar : Continuous 𝐞 
goal: Continuous ⇑Real.fourierChar

full_name: Real.vector_fourierIntegral_eq_integral_exp_smul
code: 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 ∂μ 
goal: VectorFourier.fourierIntegral Real.fourierChar μ L f w =
  ∫ (v : V), Complex.exp (↑(-2 * π * (L v) w) * Complex.I) • f v ∂μ

full_name: Real.fourierIntegral_convergent_iff'
code: /-- 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 μ 
goal: MeasureTheory.Integrable (fun v => Real.fourierChar (-(L v) w) • f v) μ ↔ MeasureTheory.Integrable f μ

full_name: Real.fourierIntegral_continuousLinearMap_apply'
code: 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 
goal: (VectorFourier.fourierIntegral Real.fourierChar μ L.toLinearMap₂ f w) a =
  VectorFourier.fourierIntegral Real.fourierChar μ L.toLinearMap₂ (fun x => (f x) a) w

full_name: Real.fourierIntegral_continuousMultilinearMap_apply'
code: 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 
goal: (VectorFourier.fourierIntegral Real.fourierChar μ L.toLinearMap₂ f w) m =
  VectorFourier.fourierIntegral Real.fourierChar μ L.toLinearMap₂ (fun x => (f x) m) w

full_name: Real.fourierIntegral
code: /-- 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 
goal: E

full_name: Real.fourierIntegralInv
code: /-- 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 
goal: E

full_name: FourierTransform._aux_Mathlib_Analysis_Fourier_FourierTransform___unexpand_Real_fourierIntegral_1
code: @[inherit_doc] scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
goal: Lean.PrettyPrinter.Unexpander

full_name: FourierTransform._aux_Mathlib_Analysis_Fourier_FourierTransform___macroRules_FourierTransform_term𝓕_1
code: @[inherit_doc] scoped[FourierTransform] notation "𝓕" => Real.fourierIntegral
goal: Lean.Macro

full_name: FourierTransform.«_aux_Mathlib_Analysis_Fourier_FourierTransform___macroRules_FourierTransform_term𝓕⁻_1»
code: @[inherit_doc] scoped[FourierTransform] notation "𝓕⁻" => Real.fourierIntegralInv
goal: Lean.Macro

full_name: FourierTransform._aux_Mathlib_Analysis_Fourier_FourierTransform___unexpand_Real_fourierIntegralInv_1
code: @[inherit_doc] scoped[FourierTransform] notation "𝓕⁻" => Real.fourierIntegralInv
goal: Lean.PrettyPrinter.Unexpander

full_name: Real.fourierIntegral_eq
code: lemma fourierIntegral_eq (f : V → E) (w : V) :
    𝓕 f w = ∫ v, 𝐞 (-⟪v, w⟫) • f v 
goal: Real.fourierIntegral f w = ∫ (v : V), Real.fourierChar (-⟪v, w⟫_ℝ) • f v

full_name: Real.fourierIntegral_eq'
code: lemma fourierIntegral_eq' (f : V → E) (w : V) :
    𝓕 f w = ∫ v, Complex.exp ((↑(-2 * π * ⟪v, w⟫) * Complex.I)) • f v 
goal: Real.fourierIntegral f w = ∫ (v : V), Complex.exp (↑(-2 * π * ⟪v, w⟫_ℝ) * Complex.I) • f v

full_name: Real.fourierIntegralInv_eq
code: lemma fourierIntegralInv_eq (f : V → E) (w : V) :
    𝓕⁻ f w = ∫ v, 𝐞 ⟪v, w⟫ • f v 
goal: Real.fourierIntegralInv f w = ∫ (v : V), Real.fourierChar ⟪v, w⟫_ℝ • f v

full_name: Real.fourierIntegralInv_eq'
code: lemma fourierIntegralInv_eq' (f : V → E) (w : V) :
    𝓕⁻ f w = ∫ v, Complex.exp ((↑(2 * π * ⟪v, w⟫) * Complex.I)) • f v 
goal: Real.fourierIntegralInv f w = ∫ (v : V), Complex.exp (↑(2 * π * ⟪v, w⟫_ℝ) * Complex.I) • f v

full_name: Real.fourierIntegral_comp_linearIsometry
code: lemma fourierIntegral_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
    𝓕 (f ∘ A) w = (𝓕 f) (A w) 
goal: Real.fourierIntegral (f ∘ ⇑A) w = Real.fourierIntegral f (A w)

full_name: Real.fourierIntegralInv_eq_fourierIntegral_neg
code: lemma fourierIntegralInv_eq_fourierIntegral_neg (f : V → E) (w : V) :
    𝓕⁻ f w = 𝓕 f (-w) 
goal: Real.fourierIntegralInv f w = Real.fourierIntegral f (-w)

full_name: Real.fourierIntegralInv_eq_fourierIntegral_comp_neg
code: lemma fourierIntegralInv_eq_fourierIntegral_comp_neg (f : V → E) :
    𝓕⁻ f = 𝓕 (fun x ↦ f (-x)) 
goal: Real.fourierIntegralInv f = Real.fourierIntegral fun x => f (-x)

full_name: Real.fourierIntegralInv_comm
code: lemma fourierIntegralInv_comm (f : V → E) :
    𝓕 (𝓕⁻ f) = 𝓕⁻ (𝓕 f) 
goal: Real.fourierIntegral (Real.fourierIntegralInv f) = Real.fourierIntegralInv (Real.fourierIntegral f)

full_name: Real.fourierIntegralInv_comp_linearIsometry
code: lemma fourierIntegralInv_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
    𝓕⁻ (f ∘ A) w = (𝓕⁻ f) (A w) 
goal: Real.fourierIntegralInv (f ∘ ⇑A) w = Real.fourierIntegralInv f (A w)

full_name: Real.fourierIntegral_real_eq
code: theorem fourierIntegral_real_eq (f : ℝ → E) (w : ℝ) :
    fourierIntegral f w = ∫ v : ℝ, 𝐞 (-(v * w)) • f v 
goal: Real.fourierIntegral f w = ∫ (v : ℝ), Real.fourierChar (-(v * w)) • f v

full_name: Real.fourierIntegral_real_eq_integral_exp_smul
code: theorem fourierIntegral_real_eq_integral_exp_smul (f : ℝ → E) (w : ℝ) :
    𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v 
goal: Real.fourierIntegral f w = ∫ (v : ℝ), Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v

full_name: Real.fourierIntegral_convergent_iff
code: @[simp] theorem fourierIntegral_convergent_iff {μ : Measure V} {f : V → E} (w : V) :
    Integrable (fun v : V ↦ 𝐞 (- ⟪v, w⟫) • f v) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (fun v => Real.fourierChar (-⟪v, w⟫_ℝ) • f v) μ ↔ MeasureTheory.Integrable f μ

full_name: Real.fourierIntegral_continuousLinearMap_apply
code: 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 
goal: (Real.fourierIntegral f v) a = Real.fourierIntegral (fun x => (f x) a) v

full_name: Real.fourierIntegral_continuousMultilinearMap_apply
code: 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 
goal: (Real.fourierIntegral f v) m = Real.fourierIntegral (fun x => (f x) m) v