File: Mathlib/Analysis/Fourier/FourierTransformDeriv.lean

full_name: Real.hasDerivAt_fourierChar
code: lemma hasDerivAt_fourierChar (x : ℝ) : HasDerivAt (𝐞 · : ℝ → ℂ) (2 * π * I * 𝐞 x) x 
goal: HasDerivAt (fun x => ↑(𝐞 x)) (2 * ↑π * Complex.I * ↑(𝐞 x)) x

full_name: Real.differentiable_fourierChar
code: lemma differentiable_fourierChar : Differentiable ℝ (𝐞 · : ℝ → ℂ) 
goal: Differentiable ℝ fun x => ↑(𝐞 x)

full_name: Real.deriv_fourierChar
code: lemma deriv_fourierChar (x : ℝ) : deriv (𝐞 · : ℝ → ℂ) x = 2 * π * I * 𝐞 x 
goal: deriv (fun x => ↑(𝐞 x)) x = 2 * ↑π * Complex.I * ↑(𝐞 x)

full_name: Real.hasFDerivAt_fourierChar_neg_bilinear_right
code: lemma hasFDerivAt_fourierChar_neg_bilinear_right (v : V) (w : W) :
    HasFDerivAt (fun w ↦ (𝐞 (-L v w) : ℂ))
      ((-2 * π * I * 𝐞 (-L v w)) • (ofRealCLM ∘L (L v))) w 
goal: HasFDerivAt (fun w => ↑(𝐞 (-(L v) w))) ((-2 * ↑π * Complex.I * ↑(𝐞 (-(L v) w))) • Complex.ofRealCLM.comp (L v)) w

full_name: Real.fderiv_fourierChar_neg_bilinear_right_apply
code: lemma fderiv_fourierChar_neg_bilinear_right_apply (v : V) (w y : W) :
    fderiv ℝ (fun w ↦ (𝐞 (-L v w) : ℂ)) w y = -2 * π * I * L v y * 𝐞 (-L v w) 
goal: (fderiv ℝ (fun w => ↑(𝐞 (-(L v) w))) w) y = -2 * ↑π * Complex.I * ↑((L v) y) * ↑(𝐞 (-(L v) w))

full_name: Real.differentiable_fourierChar_neg_bilinear_right
code: lemma differentiable_fourierChar_neg_bilinear_right (v : V) :
    Differentiable ℝ (fun w ↦ (𝐞 (-L v w) : ℂ)) 
goal: Differentiable ℝ fun w => ↑(𝐞 (-(L v) w))

full_name: Real.hasFDerivAt_fourierChar_neg_bilinear_left
code: lemma hasFDerivAt_fourierChar_neg_bilinear_left (v : V) (w : W) :
    HasFDerivAt (fun v ↦ (𝐞 (-L v w) : ℂ))
      ((-2 * π * I * 𝐞 (-L v w)) • (ofRealCLM ∘L (L.flip w))) v 
goal: HasFDerivAt (fun v => ↑(𝐞 (-(L v) w))) ((-2 * ↑π * Complex.I * ↑(𝐞 (-(L v) w))) • Complex.ofRealCLM.comp (L.flip w)) v

full_name: Real.fderiv_fourierChar_neg_bilinear_left_apply
code: lemma fderiv_fourierChar_neg_bilinear_left_apply (v y : V) (w : W) :
    fderiv ℝ (fun v ↦ (𝐞 (-L v w) : ℂ)) v y = -2 * π * I * L y w * 𝐞 (-L v w) 
goal: (fderiv ℝ (fun v => ↑(𝐞 (-(L v) w))) v) y = -2 * ↑π * Complex.I * ↑((L y) w) * ↑(𝐞 (-(L v) w))

full_name: Real.differentiable_fourierChar_neg_bilinear_left
code: lemma differentiable_fourierChar_neg_bilinear_left (w : W) :
    Differentiable ℝ (fun v ↦ (𝐞 (-L v w) : ℂ)) 
goal: Differentiable ℝ fun v => ↑(𝐞 (-(L v) w))

full_name: VectorFourier.fourierSMulRight
code: /-- Send a function `f : V → E` to the function `f : V → Hom (W, E)` given by
`v ↦ (w ↦ -2 * π * I * L (v, w) • f v)`. This is designed so that the Fourier transform of
`fourierSMulRight L f` is the derivative of the Fourier transform of `f`. -/
def fourierSMulRight (v : V) : (W →L[ℝ] E) 
goal: W →L[ℝ] E

full_name: VectorFourier.fourierSMulRight_apply
code: @[simp] lemma fourierSMulRight_apply (v : V) (w : W) :
    fourierSMulRight L f v w = -(2 * π * I) • L v w • f v 
goal: (VectorFourier.fourierSMulRight L f v) w = -(2 * ↑π * Complex.I) • (L v) w • f v

full_name: VectorFourier.hasFDerivAt_fourierChar_smul
code: /-- The `w`-derivative of the Fourier transform integrand. -/
lemma hasFDerivAt_fourierChar_smul (v : V) (w : W) :
    HasFDerivAt (fun w' ↦ 𝐞 (-L v w') • f v) (𝐞 (-L v w) • fourierSMulRight L f v) w 
goal: HasFDerivAt (fun w' => 𝐞 (-(L v) w') • f v) (𝐞 (-(L v) w) • VectorFourier.fourierSMulRight L f v) w

full_name: VectorFourier.norm_fourierSMulRight
code: lemma norm_fourierSMulRight (L : V →L[ℝ] W →L[ℝ] ℝ) (f : V → E) (v : V) :
    ‖fourierSMulRight L f v‖ = (2 * π) * ‖L v‖ * ‖f v‖ 
goal: ‖VectorFourier.fourierSMulRight L f v‖ = 2 * π * ‖L v‖ * ‖f v‖

full_name: VectorFourier.norm_fourierSMulRight_le
code: lemma norm_fourierSMulRight_le (L : V →L[ℝ] W →L[ℝ] ℝ) (f : V → E) (v : V) :
    ‖fourierSMulRight L f v‖ ≤ 2 * π * ‖L‖ * ‖v‖ * ‖f v‖ 
goal: ‖VectorFourier.fourierSMulRight L f v‖ ≤ 2 * π * ‖L‖ * ‖v‖ * ‖f v‖

full_name: MeasureTheory.AEStronglyMeasurable.fourierSMulRight
code: lemma _root_.MeasureTheory.AEStronglyMeasurable.fourierSMulRight
    [SecondCountableTopologyEither V (W →L[ℝ] ℝ)] [MeasurableSpace V] [BorelSpace V]
    {L : V →L[ℝ] W →L[ℝ] ℝ} {f : V → E} {μ : Measure V}
    (hf : AEStronglyMeasurable f μ) :
    AEStronglyMeasurable (fun v ↦ fourierSMulRight L f v) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun v => VectorFourier.fourierSMulRight L f v) μ

full_name: VectorFourier.hasFDerivAt_fourierIntegral
code: /-- Main theorem of this section: if both `f` and `x ↦ ‖x‖ * ‖f x‖` are integrable, then the
Fourier transform of `f` has a Fréchet derivative (everywhere in its domain) and its derivative is
the Fourier transform of `smulRight L f`. -/
theorem hasFDerivAt_fourierIntegral
    [MeasurableSpace V] [BorelSpace V] [SecondCountableTopology V] {μ : Measure V}
    (hf : Integrable f μ) (hf' : Integrable (fun v : V ↦ ‖v‖ * ‖f v‖) μ) (w : W) :
    HasFDerivAt (fourierIntegral 𝐞 μ L.toLinearMap₂ f)
      (fourierIntegral 𝐞 μ L.toLinearMap₂ (fourierSMulRight L f) w) w 
goal: HasFDerivAt (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f)
  (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ (VectorFourier.fourierSMulRight L f) w) w

full_name: VectorFourier.fderiv_fourierIntegral
code: lemma fderiv_fourierIntegral
    [MeasurableSpace V] [BorelSpace V] [SecondCountableTopology V] {μ : Measure V}
    (hf : Integrable f μ) (hf' : Integrable (fun v : V ↦ ‖v‖ * ‖f v‖) μ) :
    fderiv ℝ (fourierIntegral 𝐞 μ L.toLinearMap₂ f) =
      fourierIntegral 𝐞 μ L.toLinearMap₂ (fourierSMulRight L f) 
goal: fderiv ℝ (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f) =
  VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ (VectorFourier.fourierSMulRight L f)

full_name: VectorFourier.differentiable_fourierIntegral
code: lemma differentiable_fourierIntegral
    [MeasurableSpace V] [BorelSpace V] [SecondCountableTopology V] {μ : Measure V}
    (hf : Integrable f μ) (hf' : Integrable (fun v : V ↦ ‖v‖ * ‖f v‖) μ) :
    Differentiable ℝ (fourierIntegral 𝐞 μ L.toLinearMap₂ f) 
goal: Differentiable ℝ (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f)

full_name: VectorFourier.fourierIntegral_fderiv
code: /-- The Fourier integral of the derivative of a function is obtained by multiplying the Fourier
integral of the original function by `-L w v`. -/
theorem fourierIntegral_fderiv [MeasurableSpace V] [BorelSpace V] [FiniteDimensional ℝ V]
    {μ : Measure V} [Measure.IsAddHaarMeasure μ]
    (hf : Integrable f μ) (h'f : Differentiable ℝ f) (hf' : Integrable (fderiv ℝ f) μ) :
    fourierIntegral 𝐞 μ L.toLinearMap₂ (fderiv ℝ f)
      = fourierSMulRight (-L.flip) (fourierIntegral 𝐞 μ L.toLinearMap₂ f) 
goal: VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ (fderiv ℝ f) =
  VectorFourier.fourierSMulRight (-L.flip) (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f)

full_name: VectorFourier.fourierPowSMulRight
code: /-- The formal multilinear series whose `n`-th term is
`(w₁, ..., wₙ) ↦ (-2πI)^n * L v w₁ * ... * L v wₙ • f v`, as a continuous multilinear map in
the space `W [×n]→L[ℝ] E`.

This is designed so that the Fourier transform of `v ↦ fourierPowSMulRight L f v n` is the
`n`-th derivative of the Fourier transform of `f`.
-/
def fourierPowSMulRight (f : V → E) (v : V) : FormalMultilinearSeries ℝ W E 
goal: FormalMultilinearSeries ℝ W E

full_name: VectorFourier.fourierPowSMulRight_apply
code: @[simp 1100] lemma fourierPowSMulRight_apply {f : V → E} {v : V} {n : ℕ} {m : Fin n → W} :
    fourierPowSMulRight L f v n m = (- (2 * π * I))^n • (∏ i, L v (m i)) • f v 
goal: (VectorFourier.fourierPowSMulRight L f v n) m = (-(2 * ↑π * Complex.I)) ^ n • (∏ i : Fin n, (L v) (m i)) • f v

full_name: VectorFourier.fourierPowSMulRight_eq_comp
code: /-- Decomposing `fourierPowSMulRight L f v n` as a composition of continuous bilinear and
multilinear maps, to deduce easily its continuity and differentiability properties. -/
lemma fourierPowSMulRight_eq_comp {f : V → E} {v : V} {n : ℕ} :
    fourierPowSMulRight L f v n = (- (2 * π * I))^n • smulRightL ℝ (fun (_ : Fin n) ↦ W) E
      (compContinuousLinearMapLRight
        (ContinuousMultilinearMap.mkPiAlgebra ℝ (Fin n) ℝ) (fun _ ↦ L v)) (f v) 
goal: VectorFourier.fourierPowSMulRight L f v n =
  (-(2 * ↑π * Complex.I)) ^ n •
    ((ContinuousMultilinearMap.smulRightL ℝ (fun x => W) E)
        ((ContinuousMultilinearMap.mkPiAlgebra ℝ (Fin n) ℝ).compContinuousLinearMapLRight fun x => L v))
      (f v)

full_name: Continuous.fourierPowSMulRight
code: @[continuity, fun_prop]
lemma _root_.Continuous.fourierPowSMulRight {f : V → E} (hf : Continuous f) (n : ℕ) :
    Continuous (fun v ↦ fourierPowSMulRight L f v n) 
goal: Continuous fun v => VectorFourier.fourierPowSMulRight L f v n

full_name: ContDiff.fourierPowSMulRight
code: lemma _root_.ContDiff.fourierPowSMulRight {f : V → E} {k : ℕ∞} (hf : ContDiff ℝ k f) (n : ℕ) :
    ContDiff ℝ k (fun v ↦ fourierPowSMulRight L f v n) 
goal: ContDiff ℝ k fun v => VectorFourier.fourierPowSMulRight L f v n

full_name: VectorFourier.norm_fourierPowSMulRight_le
code: lemma norm_fourierPowSMulRight_le (f : V → E) (v : V) (n : ℕ) :
    ‖fourierPowSMulRight L f v n‖ ≤ (2 * π * ‖L‖) ^ n * ‖v‖ ^ n * ‖f v‖ 
goal: ‖VectorFourier.fourierPowSMulRight L f v n‖ ≤ (2 * π * ‖L‖) ^ n * ‖v‖ ^ n * ‖f v‖

full_name: VectorFourier.norm_iteratedFDeriv_fourierPowSMulRight
code: /-- The iterated derivative of a function multiplied by `(L v ⬝) ^ n` can be controlled in terms
of the iterated derivatives of the initial function. -/
lemma norm_iteratedFDeriv_fourierPowSMulRight
    {f : V → E} {K : ℕ∞} {C : ℝ} (hf : ContDiff ℝ K f) {n : ℕ} {k : ℕ} (hk : k ≤ K)
    {v : V} (hv : ∀ i ≤ k, ∀ j ≤ n, ‖v‖ ^ j * ‖iteratedFDeriv ℝ i f v‖ ≤ C) :
    ‖iteratedFDeriv ℝ k (fun v ↦ fourierPowSMulRight L f v n) v‖ ≤
      (2 * π) ^ n * (2 * n + 2) ^ k * ‖L‖ ^ n * C 
goal: ‖iteratedFDeriv ℝ k (fun v => VectorFourier.fourierPowSMulRight L f v n) v‖ ≤
  (2 * π) ^ n * (2 * ↑n + 2) ^ k * ‖L‖ ^ n * C

full_name: MeasureTheory.AEStronglyMeasurable.fourierPowSMulRight
code: lemma _root_.MeasureTheory.AEStronglyMeasurable.fourierPowSMulRight
    (hf : AEStronglyMeasurable f μ) (n : ℕ) :
    AEStronglyMeasurable (fun v ↦ fourierPowSMulRight L f v n) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun v => VectorFourier.fourierPowSMulRight L f v n) μ

full_name: VectorFourier.integrable_fourierPowSMulRight
code: lemma integrable_fourierPowSMulRight {n : ℕ} (hf : Integrable (fun v ↦ ‖v‖ ^ n * ‖f v‖) μ)
    (h'f : AEStronglyMeasurable f μ) : Integrable (fun v ↦ fourierPowSMulRight L f v n) μ 
goal: MeasureTheory.Integrable (fun v => VectorFourier.fourierPowSMulRight L f v n) μ

full_name: VectorFourier.hasFTaylorSeriesUpTo_fourierIntegral
code: lemma hasFTaylorSeriesUpTo_fourierIntegral {N : ℕ∞}
    (hf : ∀ (n : ℕ), n ≤ N → Integrable (fun v ↦ ‖v‖^n * ‖f v‖) μ)
    (h'f : AEStronglyMeasurable f μ) :
    HasFTaylorSeriesUpTo N (fourierIntegral 𝐞 μ L.toLinearMap₂ f)
      (fun w n ↦ fourierIntegral 𝐞 μ L.toLinearMap₂ (fun v ↦ fourierPowSMulRight L f v n) w) 
goal: HasFTaylorSeriesUpTo N (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f) fun w n =>
  VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ (fun v => VectorFourier.fourierPowSMulRight L f v n) w

full_name: VectorFourier.contDiff_fourierIntegral
code: /-- If `‖v‖^n * ‖f v‖` is integrable for all `n ≤ N`, then the Fourier transform of `f` is `C^N`. -/
theorem contDiff_fourierIntegral {N : ℕ∞}
    (hf : ∀ (n : ℕ), n ≤ N → Integrable (fun v ↦ ‖v‖^n * ‖f v‖) μ) :
    ContDiff ℝ N (fourierIntegral 𝐞 μ L.toLinearMap₂ f) 
goal: ContDiff ℝ N (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f)

full_name: VectorFourier.iteratedFDeriv_fourierIntegral
code: /-- If `‖v‖^n * ‖f v‖` is integrable for all `n ≤ N`, then the `n`-th derivative of the Fourier
transform of `f` is the Fourier transform of `fourierPowSMulRight L f v n`,
i.e., `(L v ⬝) ^ n • f v`. -/
lemma iteratedFDeriv_fourierIntegral {N : ℕ∞}
    (hf : ∀ (n : ℕ), n ≤ N → Integrable (fun v ↦ ‖v‖^n * ‖f v‖) μ)
    (h'f : AEStronglyMeasurable f μ) {n : ℕ} (hn : n ≤ N) :
    iteratedFDeriv ℝ n (fourierIntegral 𝐞 μ L.toLinearMap₂ f) =
      fourierIntegral 𝐞 μ L.toLinearMap₂ (fun v ↦ fourierPowSMulRight L f v n) 
goal: iteratedFDeriv ℝ n (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f) =
  VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ fun v => VectorFourier.fourierPowSMulRight L f v n

full_name: VectorFourier.fourierIntegral_iteratedFDeriv
code: /-- The Fourier integral of the `n`-th derivative of a function is obtained by multiplying the
Fourier integral of the original function by `(2πI L w ⬝ )^n`. -/
theorem fourierIntegral_iteratedFDeriv [FiniteDimensional ℝ V]
    {μ : Measure V} [Measure.IsAddHaarMeasure μ] {N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (n : ℕ), n ≤ N → Integrable (iteratedFDeriv ℝ n f) μ) {n : ℕ} (hn : n ≤ N) :
    fourierIntegral 𝐞 μ L.toLinearMap₂ (iteratedFDeriv ℝ n f)
      = (fun w ↦ fourierPowSMulRight (-L.flip) (fourierIntegral 𝐞 μ L.toLinearMap₂ f) w n) 
goal: VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ (iteratedFDeriv ℝ n f) = fun w =>
  VectorFourier.fourierPowSMulRight (-L.flip) (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f) w n

full_name: VectorFourier.fourierPowSMulRight_iteratedFDeriv_fourierIntegral
code: /-- The `k`-th derivative of the Fourier integral of `f`, multiplied by `(L v w) ^ n`, is the
Fourier integral of the `n`-th derivative of `(L v w) ^ k * f`. -/
theorem fourierPowSMulRight_iteratedFDeriv_fourierIntegral [FiniteDimensional ℝ V]
    {μ : Measure V} [Measure.IsAddHaarMeasure μ] {K N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖) μ)
    {k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) {w : W} :
    fourierPowSMulRight (-L.flip)
      (iteratedFDeriv ℝ k (fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w n =
    fourierIntegral 𝐞 μ L.toLinearMap₂
      (iteratedFDeriv ℝ n (fun v ↦ fourierPowSMulRight L f v k)) w 
goal: VectorFourier.fourierPowSMulRight (-L.flip) (iteratedFDeriv ℝ k (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w
    n =
  VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂
    (iteratedFDeriv ℝ n fun v => VectorFourier.fourierPowSMulRight L f v k) w

full_name: VectorFourier.norm_fourierPowSMulRight_iteratedFDeriv_fourierIntegral_le
code: /-- One can bound the `k`-th derivative of the Fourier integral of `f`, multiplied by `(L v w) ^ n`,
in terms of integrals of iterated derivatives of `f` (of order up to `n`) multiplied by `‖v‖ ^ i`
(for `i ≤ k`).
Auxiliary version in terms of the operator norm of `fourierPowSMulRight (-L.flip) ⬝`. For a version
in terms of `|L v w| ^ n * ⬝`, see `pow_mul_norm_iteratedFDeriv_fourierIntegral_le`.
-/
theorem norm_fourierPowSMulRight_iteratedFDeriv_fourierIntegral_le [FiniteDimensional ℝ V]
    {μ : Measure V} [Measure.IsAddHaarMeasure μ] {K N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖) μ)
    {k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) {w : W} :
    ‖fourierPowSMulRight (-L.flip)
      (iteratedFDeriv ℝ k (fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w n‖ ≤
    (2 * π) ^ k * (2 * k + 2) ^ n * ‖L‖ ^ k * ∑ p in Finset.range (k + 1) ×ˢ Finset.range (n + 1),
      ∫ v, ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ 
goal: ‖VectorFourier.fourierPowSMulRight (-L.flip) (iteratedFDeriv ℝ k (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w
      n‖ ≤
  (2 * π) ^ k * (2 * ↑k + 2) ^ n * ‖L‖ ^ k *
    ∑ p ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), ∫ (v : V), ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ

full_name: VectorFourier.pow_mul_norm_iteratedFDeriv_fourierIntegral_le
code: /-- One can bound the `k`-th derivative of the Fourier integral of `f`, multiplied by `(L v w) ^ n`,
in terms of integrals of iterated derivatives of `f` (of order up to `n`) multiplied by `‖v‖ ^ i`
(for `i ≤ k`). -/
lemma pow_mul_norm_iteratedFDeriv_fourierIntegral_le [FiniteDimensional ℝ V]
    {μ : Measure V} [Measure.IsAddHaarMeasure μ] {K N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖) μ)
    {k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) (v : V) (w : W) :
    |L v w| ^ n * ‖(iteratedFDeriv ℝ k (fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w‖ ≤
      ‖v‖ ^ n * (2 * π * ‖L‖) ^ k * (2 * k + 2) ^ n *
        ∑ p in Finset.range (k + 1) ×ˢ Finset.range (n + 1),
          ∫ v, ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ 
goal: |(L v) w| ^ n * ‖iteratedFDeriv ℝ k (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f) w‖ ≤
  ‖v‖ ^ n * (2 * π * ‖L‖) ^ k * (2 * ↑k + 2) ^ n *
    ∑ p ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), ∫ (v : V), ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ

full_name: Real.hasFDerivAt_fourierIntegral
code: /-- The Fréchet derivative of the Fourier transform of `f` is the Fourier transform of
    `fun v ↦ -2 * π * I ⟪v, ⬝⟫ f v`. -/
theorem hasFDerivAt_fourierIntegral
    (hf_int : Integrable f) (hvf_int : Integrable (fun v ↦ ‖v‖ * ‖f v‖)) (x : V) :
    HasFDerivAt (𝓕 f) (𝓕 (fourierSMulRight (innerSL ℝ) f) x) x 
goal: HasFDerivAt (𝓕 f) (𝓕 (VectorFourier.fourierSMulRight (innerSL ℝ) f) x) x

full_name: Real.fderiv_fourierIntegral
code: /-- The Fréchet derivative of the Fourier transform of `f` is the Fourier transform of
    `fun v ↦ -2 * π * I ⟪v, ⬝⟫ f v`. -/
theorem fderiv_fourierIntegral
    (hf_int : Integrable f) (hvf_int : Integrable (fun v ↦ ‖v‖ * ‖f v‖)) :
    fderiv ℝ (𝓕 f) = 𝓕 (fourierSMulRight (innerSL ℝ) f) 
goal: fderiv ℝ (𝓕 f) = 𝓕 (VectorFourier.fourierSMulRight (innerSL ℝ) f)

full_name: Real.differentiable_fourierIntegral
code: theorem differentiable_fourierIntegral
    (hf_int : Integrable f) (hvf_int : Integrable (fun v ↦ ‖v‖ * ‖f v‖)) :
    Differentiable ℝ (𝓕 f) 
goal: Differentiable ℝ (𝓕 f)

full_name: Real.fourierIntegral_fderiv
code: /-- The Fourier integral of the Fréchet derivative of a function is obtained by multiplying the
Fourier integral of the original function by `2πI ⟪v, w⟫`. -/
theorem fourierIntegral_fderiv
    (hf : Integrable f) (h'f : Differentiable ℝ f) (hf' : Integrable (fderiv ℝ f)) :
    𝓕 (fderiv ℝ f) = fourierSMulRight (-innerSL ℝ) (𝓕 f) 
goal: 𝓕 (fderiv ℝ f) = VectorFourier.fourierSMulRight (-innerSL ℝ) (𝓕 f)

full_name: Real.contDiff_fourierIntegral
code: /-- If `‖v‖^n * ‖f v‖` is integrable, then the Fourier transform of `f` is `C^n`. -/
theorem contDiff_fourierIntegral {N : ℕ∞}
    (hf : ∀ (n : ℕ), n ≤ N → Integrable (fun v ↦ ‖v‖^n * ‖f v‖)) :
    ContDiff ℝ N (𝓕 f) 
goal: ContDiff ℝ N (𝓕 f)

full_name: Real.iteratedFDeriv_fourierIntegral
code: /-- If `‖v‖^n * ‖f v‖` is integrable, then the `n`-th derivative of the Fourier transform of `f` is
  the Fourier transform of `fun v ↦ (-2 * π * I) ^ n ⟪v, ⬝⟫^n f v`. -/
theorem iteratedFDeriv_fourierIntegral {N : ℕ∞}
    (hf : ∀ (n : ℕ), n ≤ N → Integrable (fun v ↦ ‖v‖^n * ‖f v‖))
    (h'f : AEStronglyMeasurable f) {n : ℕ} (hn : n ≤ N) :
    iteratedFDeriv ℝ n (𝓕 f) = 𝓕 (fun v ↦ fourierPowSMulRight (innerSL ℝ) f v n) 
goal: iteratedFDeriv ℝ n (𝓕 f) = 𝓕 fun v => VectorFourier.fourierPowSMulRight (innerSL ℝ) f v n

full_name: Real.fourierIntegral_iteratedFDeriv
code: /-- The Fourier integral of the `n`-th derivative of a function is obtained by multiplying the
Fourier integral of the original function by `(2πI L w ⬝ )^n`. -/
theorem fourierIntegral_iteratedFDeriv {N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (n : ℕ), n ≤ N → Integrable (iteratedFDeriv ℝ n f)) {n : ℕ} (hn : n ≤ N) :
    𝓕 (iteratedFDeriv ℝ n f)
      = (fun w ↦ fourierPowSMulRight (-innerSL ℝ) (𝓕 f) w n) 
goal: 𝓕 (iteratedFDeriv ℝ n f) = fun w => VectorFourier.fourierPowSMulRight (-innerSL ℝ) (𝓕 f) w n

full_name: Real.pow_mul_norm_iteratedFDeriv_fourierIntegral_le
code: /-- One can bound `‖w‖^n * ‖D^k (𝓕 f) w‖` in terms of integrals of the derivatives of `f` (or order
at most `n`) multiplied by powers of `v` (of order at most `k`). -/
lemma pow_mul_norm_iteratedFDeriv_fourierIntegral_le [FiniteDimensional ℝ V]
    {K N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖))
    {k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) (w : V) :
    ‖w‖ ^ n * ‖iteratedFDeriv ℝ k (𝓕 f) w‖ ≤ (2 * π) ^ k * (2 * k + 2) ^ n *
      ∑ p in Finset.range (k + 1) ×ˢ Finset.range (n + 1),
        ∫ v, ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ 
goal: ‖w‖ ^ n * ‖iteratedFDeriv ℝ k (𝓕 f) w‖ ≤
  (2 * π) ^ k * (2 * ↑k + 2) ^ n *
    ∑ p ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), ∫ (v : V), ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖

full_name: Real.hasDerivAt_fourierIntegral
code: lemma hasDerivAt_fourierIntegral
    {f : ℝ → E} (hf : Integrable f) (hf' : Integrable (fun x : ℝ ↦ x • f x)) (w : ℝ) :
    HasDerivAt (𝓕 f) (𝓕 (fun x : ℝ ↦ (-2 * π * I * x) • f x) w) w 
goal: HasDerivAt (𝓕 f) (𝓕 (fun x => (-2 * ↑π * Complex.I * ↑x) • f x) w) w

full_name: Real.deriv_fourierIntegral
code: theorem deriv_fourierIntegral
    {f : ℝ → E} (hf : Integrable f) (hf' : Integrable (fun x : ℝ ↦ x • f x)) :
    deriv (𝓕 f) = 𝓕 (fun x : ℝ ↦ (-2 * π * I * x) • f x) 
goal: deriv (𝓕 f) = 𝓕 fun x => (-2 * ↑π * Complex.I * ↑x) • f x

full_name: Real.fourierIntegral_deriv
code: /-- The Fourier integral of the Fréchet derivative of a function is obtained by multiplying the
Fourier integral of the original function by `2πI x`. -/
theorem fourierIntegral_deriv
    {f : ℝ → E} (hf : Integrable f) (h'f : Differentiable ℝ f) (hf' : Integrable (deriv f)) :
    𝓕 (deriv f) = fun (x : ℝ) ↦ (2 * π * I * x) • (𝓕 f x) 
goal: 𝓕 (deriv f) = fun x => (2 * ↑π * Complex.I * ↑x) • 𝓕 f x

full_name: Real.iteratedDeriv_fourierIntegral
code: theorem iteratedDeriv_fourierIntegral {f : ℝ → E} {N : ℕ∞} {n : ℕ}
    (hf : ∀ (n : ℕ), n ≤ N → Integrable (fun x ↦ x^n • f x)) (hn : n ≤ N) :
    iteratedDeriv n (𝓕 f) = 𝓕 (fun x : ℝ ↦ (-2 * π * I * x) ^ n • f x) 
goal: iteratedDeriv n (𝓕 f) = 𝓕 fun x => (-2 * ↑π * Complex.I * ↑x) ^ n • f x

full_name: Real.fourierIntegral_iteratedDeriv
code: theorem fourierIntegral_iteratedDeriv {f : ℝ → E} {N : ℕ∞} {n : ℕ} (hf : ContDiff ℝ N f)
    (h'f : ∀ (n : ℕ), n ≤ N → Integrable (iteratedDeriv n f)) (hn : n ≤ N) :
    𝓕 (iteratedDeriv n f) = fun (x : ℝ) ↦ (2 * π * I * x) ^ n • (𝓕 f x) 
goal: 𝓕 (iteratedDeriv n f) = fun x => (2 * ↑π * Complex.I * ↑x) ^ n • 𝓕 f x