fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
_root_.Continuous.convolution_integrand_fst [ContinuousSub G] (hg : Continuous g) (t : G) :
Continuous fun x => L (f t) (g (x - t)) :=
L.continuous₂.comp₂ continuous_const <| hg.comp <| continuous_id.sub continuous_const | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.Continuous.convolution_integrand_fst | null |
_root_.HasCompactSupport.convolution_integrand_bound_left (hcf : HasCompactSupport f)
(hf : Continuous f) {x t : G} {s : Set G} (hx : x ∈ s) :
‖L (f (x - t)) (g t)‖ ≤
(-tsupport f + s).indicator (fun t => (‖L‖ * ⨆ i, ‖f i‖) * ‖g t‖) t := by
convert hcf.convolution_integrand_bound_right L.flip hf hx using 1
simp_rw [L.opNorm_flip, mul_right_comm] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.convolution_integrand_bound_left | null |
ConvolutionExistsAt [Sub G] (f : G → E) (g : G → E') (x : G) (L : E →L[𝕜] E' →L[𝕜] F)
(μ : Measure G := by volume_tac) : Prop :=
Integrable (fun t => L (f t) (g (x - t))) μ | def | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExistsAt | The convolution of `f` and `g` exists at `x` when the function `t ↦ L (f t) (g (x - t))` is
integrable. There are various conditions on `f` and `g` to prove this. |
ConvolutionExists [Sub G] (f : G → E) (g : G → E') (L : E →L[𝕜] E' →L[𝕜] F)
(μ : Measure G := by volume_tac) : Prop :=
∀ x : G, ConvolutionExistsAt f g x L μ | def | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExists | The convolution of `f` and `g` exists when the function `t ↦ L (f t) (g (x - t))` is integrable
for all `x : G`. There are various conditions on `f` and `g` to prove this. |
ConvolutionExistsAt.integrable [Sub G] {x : G} (h : ConvolutionExistsAt f g x L μ) :
Integrable (fun t => L (f t) (g (x - t))) μ :=
h | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExistsAt.integrable | null |
AEStronglyMeasurable.convolution_integrand' [MeasurableAdd₂ G]
[MeasurableNeg G] (hf : AEStronglyMeasurable f ν)
(hg : AEStronglyMeasurable g <| map (fun p : G × G => p.1 - p.2) (μ.prod ν)) :
AEStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.prod ν) :=
L.aestronglyMeasurable_comp₂ hf.comp_snd <| hg.comp_measurable measurable_sub | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | AEStronglyMeasurable.convolution_integrand' | null |
AEStronglyMeasurable.convolution_integrand_snd'
(hf : AEStronglyMeasurable f μ) {x : G}
(hg : AEStronglyMeasurable g <| map (fun t => x - t) μ) :
AEStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
L.aestronglyMeasurable_comp₂ hf <| hg.comp_measurable <| measurable_id.const_sub x | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | AEStronglyMeasurable.convolution_integrand_snd' | null |
AEStronglyMeasurable.convolution_integrand_swap_snd' {x : G}
(hf : AEStronglyMeasurable f <| map (fun t => x - t) μ) (hg : AEStronglyMeasurable g μ) :
AEStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
L.aestronglyMeasurable_comp₂ (hf.comp_measurable <| measurable_id.const_sub x) hg | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | AEStronglyMeasurable.convolution_integrand_swap_snd' | null |
_root_.BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
(hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
(h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
(hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
ConvolutionExistsAt f g x₀ L μ := by
rw [ConvolutionExistsAt]
rw [← integrableOn_iff_integrable_of_support_subset h2s]
set s' := (fun t => -t + x₀) ⁻¹' s
have : ∀ᵐ t : G ∂μ.restrict s,
‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t := by
filter_upwards
refine le_indicator (fun t ht => ?_) fun t ht => ?_
· apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl]
refine (le_ciSup_set hbg <| mem_preimage.mpr ?_)
rwa [neg_sub, sub_add_cancel]
· have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
rw [notMem_support.mp this, norm_zero]
refine Integrable.mono' ?_ ?_ this
· rw [integrable_indicator_iff hs]; exact ((hf.norm.const_mul _).mul_const _).integrableOn
· exact hf.aestronglyMeasurable.convolution_integrand_snd' L hmg | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.BddAbove.convolutionExistsAt' | A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). |
ConvolutionExistsAt.of_norm' {x₀ : G}
(h : ConvolutionExistsAt (fun x => ‖f x‖) (fun x => ‖g x‖) x₀ (mul ℝ ℝ) μ)
(hmf : AEStronglyMeasurable f μ) (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) μ) :
ConvolutionExistsAt f g x₀ L μ := by
refine (h.const_mul ‖L‖).mono'
(hmf.convolution_integrand_snd' L hmg) (Eventually.of_forall fun x => ?_)
rw [mul_apply', ← mul_assoc]
apply L.le_opNorm₂ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExistsAt.of_norm' | If `‖f‖ *[μ] ‖g‖` exists, then `f *[L, μ] g` exists. |
AEStronglyMeasurable.convolution_integrand_snd (hf : AEStronglyMeasurable f μ)
(hg : AEStronglyMeasurable g μ) (x : G) :
AEStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
hf.convolution_integrand_snd' L <|
hg.mono_ac <| (quasiMeasurePreserving_sub_left_of_right_invariant μ x).absolutelyContinuous | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | AEStronglyMeasurable.convolution_integrand_snd | null |
AEStronglyMeasurable.convolution_integrand_swap_snd
(hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) (x : G) :
AEStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ :=
(hf.mono_ac
(quasiMeasurePreserving_sub_left_of_right_invariant μ
x).absolutelyContinuous).convolution_integrand_swap_snd'
L hg | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | AEStronglyMeasurable.convolution_integrand_swap_snd | null |
ConvolutionExistsAt.of_norm {x₀ : G}
(h : ConvolutionExistsAt (fun x => ‖f x‖) (fun x => ‖g x‖) x₀ (mul ℝ ℝ) μ)
(hmf : AEStronglyMeasurable f μ) (hmg : AEStronglyMeasurable g μ) :
ConvolutionExistsAt f g x₀ L μ :=
h.of_norm' L hmf <|
hmg.mono_ac (quasiMeasurePreserving_sub_left_of_right_invariant μ x₀).absolutelyContinuous | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExistsAt.of_norm | If `‖f‖ *[μ] ‖g‖` exists, then `f *[L, μ] g` exists. |
AEStronglyMeasurable.convolution_integrand (hf : AEStronglyMeasurable f ν)
(hg : AEStronglyMeasurable g μ) :
AEStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.prod ν) :=
hf.convolution_integrand' L <|
hg.mono_ac (quasiMeasurePreserving_sub_of_right_invariant μ ν).absolutelyContinuous | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | AEStronglyMeasurable.convolution_integrand | null |
Integrable.convolution_integrand (hf : Integrable f ν) (hg : Integrable g μ) :
Integrable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.prod ν) := by
have h_meas : AEStronglyMeasurable (fun p : G × G => L (f p.2) (g (p.1 - p.2))) (μ.prod ν) :=
hf.aestronglyMeasurable.convolution_integrand L hg.aestronglyMeasurable
have h2_meas : AEStronglyMeasurable (fun y : G => ∫ x : G, ‖L (f y) (g (x - y))‖ ∂μ) ν :=
h_meas.prod_swap.norm.integral_prod_right'
simp_rw [integrable_prod_iff' h_meas]
refine ⟨Eventually.of_forall fun t => (L (f t)).integrable_comp (hg.comp_sub_right t), ?_⟩
refine Integrable.mono' ?_ h2_meas
(Eventually.of_forall fun t => (?_ : _ ≤ ‖L‖ * ‖f t‖ * ∫ x, ‖g (x - t)‖ ∂μ))
· simp only [integral_sub_right_eq_self (‖g ·‖)]
exact (hf.norm.const_mul _).mul_const _
· simp_rw [← integral_const_mul]
rw [Real.norm_of_nonneg (by positivity)]
exact integral_mono_of_nonneg (Eventually.of_forall fun t => norm_nonneg _)
((hg.comp_sub_right t).norm.const_mul _) (Eventually.of_forall fun t => L.le_opNorm₂ _ _) | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | Integrable.convolution_integrand | null |
Integrable.ae_convolution_exists (hf : Integrable f ν) (hg : Integrable g μ) :
∀ᵐ x ∂μ, ConvolutionExistsAt f g x L ν :=
((integrable_prod_iff <|
hf.aestronglyMeasurable.convolution_integrand L hg.aestronglyMeasurable).mp <|
hf.convolution_integrand L hg).1 | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | Integrable.ae_convolution_exists | null |
_root_.HasCompactSupport.convolutionExistsAt {x₀ : G}
(h : HasCompactSupport fun t => L (f t) (g (x₀ - t))) (hf : LocallyIntegrable f μ)
(hg : Continuous g) : ConvolutionExistsAt f g x₀ L μ := by
let u := (Homeomorph.neg G).trans (Homeomorph.addRight x₀)
let v := (Homeomorph.neg G).trans (Homeomorph.addLeft x₀)
apply ((u.isCompact_preimage.mpr h).bddAbove_image hg.norm.continuousOn).convolutionExistsAt' L
isClosed_closure.measurableSet subset_closure (hf.integrableOn_isCompact h)
have A : AEStronglyMeasurable (g ∘ v)
(μ.restrict (tsupport fun t : G => L (f t) (g (x₀ - t)))) := by
apply (hg.comp v.continuous).continuousOn.aestronglyMeasurable_of_isCompact h
exact (isClosed_tsupport _).measurableSet
convert ((v.continuous.measurable.measurePreserving
(μ.restrict (tsupport fun t => L (f t) (g (x₀ - t))))).aestronglyMeasurable_comp_iff
v.measurableEmbedding).1 A
ext x
simp only [v, Homeomorph.neg, sub_eq_add_neg, val_toAddUnits_apply, Homeomorph.trans_apply,
Equiv.neg_apply, Homeomorph.homeomorph_mk_coe, Homeomorph.coe_addLeft] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.convolutionExistsAt | null |
_root_.HasCompactSupport.convolutionExists_right (hcg : HasCompactSupport g)
(hf : LocallyIntegrable f μ) (hg : Continuous g) : ConvolutionExists f g L μ := by
intro x₀
refine HasCompactSupport.convolutionExistsAt L ?_ hf hg
refine (hcg.comp_homeomorph (Homeomorph.subLeft x₀)).mono ?_
refine fun t => mt fun ht : g (x₀ - t) = 0 => ?_
simp_rw [ht, (L _).map_zero] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.convolutionExists_right | null |
_root_.HasCompactSupport.convolutionExists_left_of_continuous_right
(hcf : HasCompactSupport f) (hf : LocallyIntegrable f μ) (hg : Continuous g) :
ConvolutionExists f g L μ := by
intro x₀
refine HasCompactSupport.convolutionExistsAt L ?_ hf hg
refine hcf.mono ?_
refine fun t => mt fun ht : f t = 0 => ?_
simp_rw [ht, L.map_zero₂] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.convolutionExists_left_of_continuous_right | null |
_root_.BddAbove.convolutionExistsAt [MeasurableAdd₂ G] [SFinite μ] {x₀ : G} {s : Set G}
(hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => x₀ - t) ⁻¹' s))) (hs : MeasurableSet s)
(h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
(hmg : AEStronglyMeasurable g μ) : ConvolutionExistsAt f g x₀ L μ := by
refine BddAbove.convolutionExistsAt' L ?_ hs h2s hf ?_
· simp_rw [← sub_eq_neg_add, hbg]
· have : AEStronglyMeasurable g (map (fun t : G => x₀ - t) μ) :=
hmg.mono_ac (quasiMeasurePreserving_sub_left_of_right_invariant μ x₀).absolutelyContinuous
apply this.mono_measure
exact map_mono restrict_le_self (measurable_const.sub measurable_id')
variable {L} [MeasurableAdd G] [IsNegInvariant μ] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.BddAbove.convolutionExistsAt | A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that the integrand has compact support and `g` is bounded on this support (note that
both properties hold if `g` is continuous with compact support). We also require that `f` is
integrable on the support of the integrand, and that both functions are strongly measurable.
This is a variant of `BddAbove.convolutionExistsAt'` in an abelian group with a left-invariant
measure. This allows us to state the boundedness and measurability of `g` in a more natural way. |
convolutionExistsAt_flip :
ConvolutionExistsAt g f x L.flip μ ↔ ConvolutionExistsAt f g x L μ := by
simp_rw [ConvolutionExistsAt, ← integrable_comp_sub_left (fun t => L (f t) (g (x - t))) x,
sub_sub_cancel, flip_apply] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolutionExistsAt_flip | null |
ConvolutionExistsAt.integrable_swap (h : ConvolutionExistsAt f g x L μ) :
Integrable (fun t => L (f (x - t)) (g t)) μ := by
convert h.comp_sub_left x
simp_rw [sub_sub_self] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExistsAt.integrable_swap | null |
convolutionExistsAt_iff_integrable_swap :
ConvolutionExistsAt f g x L μ ↔ Integrable (fun t => L (f (x - t)) (g t)) μ :=
convolutionExistsAt_flip.symm | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolutionExistsAt_iff_integrable_swap | null |
_root_.HasCompactSupport.convolutionExists_left
(hcf : HasCompactSupport f) (hf : Continuous f)
(hg : LocallyIntegrable g μ) : ConvolutionExists f g L μ := fun x₀ =>
convolutionExistsAt_flip.mp <| hcf.convolutionExists_right L.flip hg hf x₀ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.convolutionExists_left | null |
_root_.HasCompactSupport.convolutionExists_right_of_continuous_left
(hcg : HasCompactSupport g) (hf : Continuous f) (hg : LocallyIntegrable g μ) :
ConvolutionExists f g L μ := fun x₀ =>
convolutionExistsAt_flip.mp <| hcg.convolutionExists_left_of_continuous_right L.flip hg hf x₀ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.convolutionExists_right_of_continuous_left | null |
noncomputable convolution [Sub G] (f : G → E) (g : G → E') (L : E →L[𝕜] E' →L[𝕜] F)
(μ : Measure G := by volume_tac) : G → F := fun x =>
∫ t, L (f t) (g (x - t)) ∂μ | def | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution | The convolution of two functions `f` and `g` with respect to a continuous bilinear map `L` and
measure `μ`. It is defined to be `(f ⋆[L, μ] g) x = ∫ t, L (f t) (g (x - t)) ∂μ`. |
convolution_lsmul [Sub G] {f : G → 𝕜} {g : G → F} :
(f ⋆[lsmul 𝕜 𝕜, μ] g : G → F) x = ∫ t, f t • g (x - t) ∂μ :=
rfl | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_lsmul | The convolution of two functions with respect to a bilinear operation `L` and a measure `μ`. -/
scoped[Convolution] notation:67 f " ⋆[" L:67 ", " μ:67 "] " g:66 => convolution f g L μ
/-- The convolution of two functions with respect to a bilinear operation `L` and the volume. -/
scoped[Convolution]
notation:67 f " ⋆[" L:67 "]" g:66 => convolution f g L MeasureSpace.volume
/-- The convolution of two real-valued functions with respect to volume. -/
scoped[Convolution]
notation:67 f " ⋆ " g:66 =>
convolution f g (ContinuousLinearMap.lsmul ℝ ℝ) MeasureSpace.volume
open scoped Convolution
theorem convolution_def [Sub G] : (f ⋆[L, μ] g) x = ∫ t, L (f t) (g (x - t)) ∂μ :=
rfl
/-- The definition of convolution where the bilinear operator is scalar multiplication.
Note: it often helps the elaborator to give the type of the convolution explicitly. |
convolution_mul [Sub G] [NormedSpace ℝ 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
(f ⋆[mul 𝕜 𝕜, μ] g) x = ∫ t, f t * g (x - t) ∂μ :=
rfl | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_mul | The definition of convolution where the bilinear operator is multiplication. |
smul_convolution [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : y • f ⋆[L, μ] g = y • (f ⋆[L, μ] g) := by
ext; simp only [Pi.smul_apply, convolution_def, ← integral_smul, L.map_smul₂] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | smul_convolution | null |
convolution_smul [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : f ⋆[L, μ] y • g = y • (f ⋆[L, μ] g) := by
ext; simp only [Pi.smul_apply, convolution_def, ← integral_smul, (L _).map_smul]
@[simp] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_smul | null |
zero_convolution : 0 ⋆[L, μ] g = 0 := by
ext
simp_rw [convolution_def, Pi.zero_apply, L.map_zero₂, integral_zero]
@[simp] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | zero_convolution | null |
convolution_zero : f ⋆[L, μ] 0 = 0 := by
ext
simp_rw [convolution_def, Pi.zero_apply, (L _).map_zero, integral_zero] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_zero | null |
ConvolutionExistsAt.distrib_add {x : G} (hfg : ConvolutionExistsAt f g x L μ)
(hfg' : ConvolutionExistsAt f g' x L μ) :
(f ⋆[L, μ] (g + g')) x = (f ⋆[L, μ] g) x + (f ⋆[L, μ] g') x := by
simp only [convolution_def, (L _).map_add, Pi.add_apply, integral_add hfg hfg'] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExistsAt.distrib_add | null |
ConvolutionExists.distrib_add (hfg : ConvolutionExists f g L μ)
(hfg' : ConvolutionExists f g' L μ) : f ⋆[L, μ] (g + g') = f ⋆[L, μ] g + f ⋆[L, μ] g' := by
ext x
exact (hfg x).distrib_add (hfg' x) | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExists.distrib_add | null |
ConvolutionExistsAt.add_distrib {x : G} (hfg : ConvolutionExistsAt f g x L μ)
(hfg' : ConvolutionExistsAt f' g x L μ) :
((f + f') ⋆[L, μ] g) x = (f ⋆[L, μ] g) x + (f' ⋆[L, μ] g) x := by
simp only [convolution_def, L.map_add₂, Pi.add_apply, integral_add hfg hfg'] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExistsAt.add_distrib | null |
ConvolutionExists.add_distrib (hfg : ConvolutionExists f g L μ)
(hfg' : ConvolutionExists f' g L μ) : (f + f') ⋆[L, μ] g = f ⋆[L, μ] g + f' ⋆[L, μ] g := by
ext x
exact (hfg x).add_distrib (hfg' x) | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | ConvolutionExists.add_distrib | null |
convolution_mono_right {f g g' : G → ℝ} (hfg : ConvolutionExistsAt f g x (lsmul ℝ ℝ) μ)
(hfg' : ConvolutionExistsAt f g' x (lsmul ℝ ℝ) μ) (hf : ∀ x, 0 ≤ f x) (hg : ∀ x, g x ≤ g' x) :
(f ⋆[lsmul ℝ ℝ, μ] g) x ≤ (f ⋆[lsmul ℝ ℝ, μ] g') x := by
apply integral_mono hfg hfg'
simp only [lsmul_apply, Algebra.id.smul_eq_mul]
intro t
apply mul_le_mul_of_nonneg_left (hg _) (hf _) | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_mono_right | null |
convolution_mono_right_of_nonneg {f g g' : G → ℝ}
(hfg' : ConvolutionExistsAt f g' x (lsmul ℝ ℝ) μ) (hf : ∀ x, 0 ≤ f x) (hg : ∀ x, g x ≤ g' x)
(hg' : ∀ x, 0 ≤ g' x) : (f ⋆[lsmul ℝ ℝ, μ] g) x ≤ (f ⋆[lsmul ℝ ℝ, μ] g') x := by
by_cases H : ConvolutionExistsAt f g x (lsmul ℝ ℝ) μ
· exact convolution_mono_right H hfg' hf hg
have : (f ⋆[lsmul ℝ ℝ, μ] g) x = 0 := integral_undef H
rw [this]
exact integral_nonneg fun y => mul_nonneg (hf y) (hg' (x - y))
variable (L) | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_mono_right_of_nonneg | null |
convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SFinite μ]
[IsAddRightInvariant μ] (h1 : f =ᵐ[μ] f') (h2 : g =ᵐ[μ] g') : f ⋆[L, μ] g = f' ⋆[L, μ] g' := by
ext x
apply integral_congr_ae
exact (h1.prodMk <| h2.comp_tendsto
(quasiMeasurePreserving_sub_left_of_right_invariant μ x).tendsto_ae).fun_comp ↿fun x y ↦ L x y | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_congr | null |
support_convolution_subset_swap : support (f ⋆[L, μ] g) ⊆ support g + support f := by
intro x h2x
by_contra hx
apply h2x
simp_rw [Set.mem_add, ← exists_and_left, not_exists, not_and_or, notMem_support] at hx
rw [convolution_def]
convert integral_zero G F using 2
ext t
rcases hx (x - t) t with (h | h | h)
· rw [h, (L _).map_zero]
· rw [h, L.map_zero₂]
· exact (h <| sub_add_cancel x t).elim | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | support_convolution_subset_swap | null |
Integrable.integrable_convolution (hf : Integrable f μ)
(hg : Integrable g μ) : Integrable (f ⋆[L, μ] g) μ :=
(hf.convolution_integrand L hg).integral_prod_left | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | Integrable.integrable_convolution | null |
protected _root_.HasCompactSupport.convolution [T2Space G] (hcf : HasCompactSupport f)
(hcg : HasCompactSupport g) : HasCompactSupport (f ⋆[L, μ] g) :=
(hcg.isCompact.add hcf).of_isClosed_subset isClosed_closure <|
closure_minimal
((support_convolution_subset_swap L).trans <| add_subset_add subset_closure subset_closure)
(hcg.isCompact.add hcf).isClosed
variable [BorelSpace G] [TopologicalSpace P] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.convolution | null |
continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
(hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
(hf : LocallyIntegrable f μ) (hg : ContinuousOn ↿g (s ×ˢ univ)) :
ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) := by
/- First get rid of the case where the space is not locally compact. Then `g` vanishes everywhere
and the conclusion is trivial. -/
by_cases H : ∀ p ∈ s, ∀ x, g p x = 0
· apply (continuousOn_const (c := 0)).congr
rintro ⟨p, x⟩ ⟨hp, -⟩
apply integral_eq_zero_of_ae (Eventually.of_forall (fun y ↦ ?_))
simp [H p hp _]
have : LocallyCompactSpace G := by
push_neg at H
rcases H with ⟨p, hp, x, hx⟩
have A : support (g p) ⊆ k := support_subset_iff'.2 (fun y hy ↦ hgs p y hp hy)
have B : Continuous (g p) := by
refine hg.comp_continuous (.prodMk_right _) fun x => ?_
simpa only [prodMk_mem_set_prod_eq, mem_univ, and_true] using hp
rcases eq_zero_or_locallyCompactSpace_of_support_subset_isCompact_of_addGroup hk A B with H|H
· simp [H] at hx
· exact H
/- Since `G` is locally compact, one may thicken `k` a little bit into a larger compact set
`(-k) + t`, outside of which all functions that appear in the convolution vanish. Then we can
apply a continuity statement for integrals depending on a parameter, with respect to
locally integrable functions and compactly supported continuous functions. -/
rintro ⟨q₀, x₀⟩ ⟨hq₀, -⟩
obtain ⟨t, t_comp, ht⟩ : ∃ t, IsCompact t ∧ t ∈ 𝓝 x₀ := exists_compact_mem_nhds x₀
let k' : Set G := (-k) +ᵥ t
have k'_comp : IsCompact k' := IsCompact.vadd_set hk.neg t_comp
let g' : (P × G) → G → E' := fun p x ↦ g p.1 (p.2 - x)
let s' : Set (P × G) := s ×ˢ t
have A : ContinuousOn g'.uncurry (s' ×ˢ univ) := by
have : g'.uncurry = g.uncurry ∘ (fun w ↦ (w.1.1, w.1.2 - w.2)) := by ext y; rfl
rw [this]
refine hg.comp (by fun_prop) ?_
simp +contextual [s', MapsTo]
have B : ContinuousOn (fun a ↦ ∫ x, L (f x) (g' a x) ∂μ) s' := by
apply continuousOn_integral_bilinear_of_locally_integrable_of_compact_support L k'_comp A _
(hf.integrableOn_isCompact k'_comp)
rintro ⟨p, x⟩ y ⟨hp, hx⟩ hy
apply hgs p _ hp
contrapose! hy
exact ⟨y - x, by simpa using hy, x, hx, by simp⟩
apply ContinuousWithinAt.mono_of_mem_nhdsWithin (B (q₀, x₀) ⟨hq₀, mem_of_mem_nhds ht⟩)
exact mem_nhdsWithin_prod_iff.2 ⟨s, self_mem_nhdsWithin, t, nhdsWithin_le_nhds ht, Subset.rfl⟩ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | continuousOn_convolution_right_with_param | The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
compactly supported. Version where `g` depends on an additional parameter in a subset `s` of
a parameter space `P` (and the compact support `k` is independent of the parameter in `s`). |
continuousOn_convolution_right_with_param_comp {s : Set P} {v : P → G}
(hv : ContinuousOn v s) {g : P → G → E'} {k : Set G} (hk : IsCompact k)
(hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
(hg : ContinuousOn ↿g (s ×ˢ univ)) : ContinuousOn (fun x => (f ⋆[L, μ] g x) (v x)) s := by
apply
(continuousOn_convolution_right_with_param L hk hgs hf hg).comp (continuousOn_id.prodMk hv)
intro x hx
simp only [hx, prodMk_mem_set_prod_eq, mem_univ, and_self_iff, _root_.id] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | continuousOn_convolution_right_with_param_comp | The convolution `f * g` is continuous if `f` is locally integrable and `g` is continuous and
compactly supported. Version where `g` depends on an additional parameter in an open subset `s` of
a parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
given in terms of compositions with an additional continuous map. |
_root_.HasCompactSupport.continuous_convolution_right (hcg : HasCompactSupport g)
(hf : LocallyIntegrable f μ) (hg : Continuous g) : Continuous (f ⋆[L, μ] g) := by
rw [← continuousOn_univ]
let g' : G → G → E' := fun _ q => g q
have : ContinuousOn ↿g' (univ ×ˢ univ) := (hg.comp continuous_snd).continuousOn
exact continuousOn_convolution_right_with_param_comp L
(continuousOn_univ.2 continuous_id) hcg
(fun p x _ hx => image_eq_zero_of_notMem_tsupport hx) hf this | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.continuous_convolution_right | The convolution is continuous if one function is locally integrable and the other has compact
support and is continuous. |
_root_.BddAbove.continuous_convolution_right_of_integrable
[FirstCountableTopology G] [SecondCountableTopologyEither G E']
(hbg : BddAbove (range fun x => ‖g x‖)) (hf : Integrable f μ) (hg : Continuous g) :
Continuous (f ⋆[L, μ] g) := by
refine continuous_iff_continuousAt.mpr fun x₀ => ?_
have : ∀ᶠ x in 𝓝 x₀, ∀ᵐ t : G ∂μ, ‖L (f t) (g (x - t))‖ ≤ ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖ := by
filter_upwards with x; filter_upwards with t
apply_rules [L.le_of_opNorm₂_le_of_le, le_rfl, le_ciSup hbg (x - t)]
refine continuousAt_of_dominated ?_ this ?_ ?_
· exact Eventually.of_forall fun x =>
hf.aestronglyMeasurable.convolution_integrand_snd' L hg.aestronglyMeasurable
· exact (hf.norm.const_mul _).mul_const _
· exact Eventually.of_forall fun t => (L.continuous₂.comp₂ continuous_const <|
hg.comp <| continuous_id.sub continuous_const).continuousAt | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.BddAbove.continuous_convolution_right_of_integrable | The convolution is continuous if one function is integrable and the other is bounded and
continuous. |
support_convolution_subset : support (f ⋆[L, μ] g) ⊆ support f + support g :=
(support_convolution_subset_swap L).trans (add_comm _ _).subset
variable [IsAddLeftInvariant μ] [IsNegInvariant μ] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | support_convolution_subset | null |
convolution_flip : g ⋆[L.flip, μ] f = f ⋆[L, μ] g := by
ext1 x
simp_rw [convolution_def]
rw [← integral_sub_left_eq_self _ μ x]
simp_rw [sub_sub_self, flip_apply] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_flip | Commutativity of convolution |
convolution_eq_swap : (f ⋆[L, μ] g) x = ∫ t, L (f (x - t)) (g t) ∂μ := by
rw [← convolution_flip]; rfl | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_eq_swap | The symmetric definition of convolution. |
convolution_lsmul_swap {f : G → 𝕜} {g : G → F} :
(f ⋆[lsmul 𝕜 𝕜, μ] g : G → F) x = ∫ t, f (x - t) • g t ∂μ :=
convolution_eq_swap _ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_lsmul_swap | The symmetric definition of convolution where the bilinear operator is scalar multiplication. |
convolution_mul_swap [NormedSpace ℝ 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
(f ⋆[mul 𝕜 𝕜, μ] g) x = ∫ t, f (x - t) * g t ∂μ :=
convolution_eq_swap _ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_mul_swap | The symmetric definition of convolution where the bilinear operator is multiplication. |
convolution_neg_of_neg_eq (h1 : ∀ᵐ x ∂μ, f (-x) = f x) (h2 : ∀ᵐ x ∂μ, g (-x) = g x) :
(f ⋆[L, μ] g) (-x) = (f ⋆[L, μ] g) x :=
calc
∫ t : G, (L (f t)) (g (-x - t)) ∂μ = ∫ t : G, (L (f (-t))) (g (x + t)) ∂μ := by
apply integral_congr_ae
filter_upwards [h1, (eventually_add_left_iff μ x).2 h2] with t ht h't
simp_rw [ht, ← h't, neg_add']
_ = ∫ t : G, (L (f t)) (g (x - t)) ∂μ := by
rw [← integral_neg_eq_self]
simp only [neg_neg, ← sub_eq_add_neg] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_neg_of_neg_eq | The convolution of two even functions is also even. |
_root_.HasCompactSupport.continuous_convolution_left
(hcf : HasCompactSupport f) (hf : Continuous f) (hg : LocallyIntegrable g μ) :
Continuous (f ⋆[L, μ] g) := by
rw [← convolution_flip]
exact hcf.continuous_convolution_right L.flip hg hf | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.continuous_convolution_left | null |
_root_.BddAbove.continuous_convolution_left_of_integrable
[FirstCountableTopology G] [SecondCountableTopologyEither G E]
(hbf : BddAbove (range fun x => ‖f x‖)) (hf : Continuous f) (hg : Integrable g μ) :
Continuous (f ⋆[L, μ] g) := by
rw [← convolution_flip]
exact hbf.continuous_convolution_right_of_integrable L.flip hg hf | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.BddAbove.continuous_convolution_left_of_integrable | null |
convolution_eq_right' {x₀ : G} {R : ℝ} (hf : support f ⊆ ball (0 : G) R)
(hg : ∀ x ∈ ball x₀ R, g x = g x₀) : (f ⋆[L, μ] g) x₀ = ∫ t, L (f t) (g x₀) ∂μ := by
have h2 : ∀ t, L (f t) (g (x₀ - t)) = L (f t) (g x₀) := fun t ↦ by
by_cases ht : t ∈ support f
· have h2t := hf ht
rw [mem_ball_zero_iff] at h2t
specialize hg (x₀ - t)
rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg
rw [hg h2t]
· rw [notMem_support] at ht
simp_rw [ht, L.map_zero₂]
simp_rw [convolution_def, h2]
variable [BorelSpace G] [SecondCountableTopology G]
variable [IsAddLeftInvariant μ] [SFinite μ] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_eq_right' | Compute `(f ⋆ g) x₀` if the support of the `f` is within `Metric.ball 0 R`, and `g` is constant
on `Metric.ball x₀ R`.
We can simplify the RHS further if we assume `f` is integrable, but also if `L = (•)` or more
generally if `L` has an `AntilipschitzWith`-condition. |
dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε) (hif : Integrable f μ)
(hf : support f ⊆ ball (0 : G) R) (hmg : AEStronglyMeasurable g μ)
(hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
dist ((f ⋆[L, μ] g : G → F) x₀) (∫ t, L (f t) z₀ ∂μ) ≤ (‖L‖ * ∫ x, ‖f x‖ ∂μ) * ε := by
have hfg : ConvolutionExistsAt f g x₀ L μ := by
refine BddAbove.convolutionExistsAt L ?_ Metric.isOpen_ball.measurableSet (Subset.trans ?_ hf)
hif.integrableOn hmg
swap; · refine fun t => mt fun ht : f t = 0 => ?_; simp_rw [ht, L.map_zero₂]
rw [bddAbove_def]
refine ⟨‖z₀‖ + ε, ?_⟩
rintro _ ⟨x, hx, rfl⟩
refine norm_le_norm_add_const_of_dist_le (hg x ?_)
rwa [mem_ball_iff_norm, norm_sub_rev, ← mem_ball_zero_iff]
have h2 : ∀ t, dist (L (f t) (g (x₀ - t))) (L (f t) z₀) ≤ ‖L (f t)‖ * ε := by
intro t; by_cases ht : t ∈ support f
· have h2t := hf ht
rw [mem_ball_zero_iff] at h2t
specialize hg (x₀ - t)
rw [sub_eq_add_neg, add_mem_ball_iff_norm, norm_neg, ← sub_eq_add_neg] at hg
refine ((L (f t)).dist_le_opNorm _ _).trans ?_
exact mul_le_mul_of_nonneg_left (hg h2t) (norm_nonneg _)
· rw [notMem_support] at ht
simp_rw [ht, L.map_zero₂, L.map_zero, norm_zero, zero_mul, dist_self]
rfl
simp_rw [convolution_def]
simp_rw [dist_eq_norm] at h2 ⊢
rw [← integral_sub hfg.integrable]; swap; · exact (L.flip z₀).integrable_comp hif
refine (norm_integral_le_of_norm_le ((L.integrable_comp hif).norm.mul_const ε)
(Eventually.of_forall h2)).trans ?_
rw [integral_mul_const]
refine mul_le_mul_of_nonneg_right ?_ hε
have h3 : ∀ t, ‖L (f t)‖ ≤ ‖L‖ * ‖f t‖ := by
intro t
exact L.le_opNorm (f t)
refine (integral_mono (L.integrable_comp hif).norm (hif.norm.const_mul _) h3).trans_eq ?_
rw [integral_const_mul]
variable [NormedSpace ℝ E] [NormedSpace ℝ E'] [CompleteSpace E'] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | dist_convolution_le' | Approximate `(f ⋆ g) x₀` if the support of the `f` is bounded within a ball, and `g` is near
`g x₀` on a ball with the same radius around `x₀`. See `dist_convolution_le` for a special case.
We can simplify the second argument of `dist` further if we add some extra type-classes on `E`
and `𝕜` or if `L` is scalar multiplication. |
dist_convolution_le {f : G → ℝ} {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε)
(hf : support f ⊆ ball (0 : G) R) (hnf : ∀ x, 0 ≤ f x) (hintf : ∫ x, f x ∂μ = 1)
(hmg : AEStronglyMeasurable g μ) (hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
dist ((f ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) z₀ ≤ ε := by
have hif : Integrable f μ := integrable_of_integral_eq_one hintf
convert (dist_convolution_le' (lsmul ℝ ℝ) hε hif hf hmg hg).trans _
· simp_rw [lsmul_apply, integral_smul_const, hintf, one_smul]
· simp_rw [Real.norm_of_nonneg (hnf _), hintf, mul_one]
exact (mul_le_mul_of_nonneg_right opNorm_lsmul_le hε).trans_eq (one_mul ε) | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | dist_convolution_le | Approximate `f ⋆ g` if the support of the `f` is bounded within a ball, and `g` is near `g x₀`
on a ball with the same radius around `x₀`.
This is a special case of `dist_convolution_le'` where `L` is `(•)`, `f` has integral 1 and `f` is
nonnegative. |
convolution_tendsto_right {ι} {g : ι → G → E'} {l : Filter ι} {x₀ : G} {z₀ : E'}
{φ : ι → G → ℝ} {k : ι → G} (hnφ : ∀ᶠ i in l, ∀ x, 0 ≤ φ i x)
(hiφ : ∀ᶠ i in l, ∫ x, φ i x ∂μ = 1)
(hφ : Tendsto (fun n => support (φ n)) l (𝓝 0).smallSets)
(hmg : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ˢ 𝓝 x₀) (𝓝 z₀))
(hk : Tendsto k l (𝓝 x₀)) :
Tendsto (fun i : ι => (φ i ⋆[lsmul ℝ ℝ, μ] g i : G → E') (k i)) l (𝓝 z₀) := by
simp_rw [tendsto_smallSets_iff] at hφ
rw [Metric.tendsto_nhds] at hcg ⊢
simp_rw [Metric.eventually_prod_nhds_iff] at hcg
intro ε hε
have h2ε : 0 < ε / 3 := div_pos hε (by simp)
obtain ⟨p, hp, δ, hδ, hgδ⟩ := hcg _ h2ε
dsimp only [uncurry] at hgδ
have h2k := hk.eventually (ball_mem_nhds x₀ <| half_pos hδ)
have h2φ := hφ (ball (0 : G) _) <| ball_mem_nhds _ (half_pos hδ)
filter_upwards [hp, h2k, h2φ, hnφ, hiφ, hmg] with i hpi hki hφi hnφi hiφi hmgi
have hgi : dist (g i (k i)) z₀ < ε / 3 := hgδ hpi (hki.trans <| half_lt_self hδ)
have h1 : ∀ x' ∈ ball (k i) (δ / 2), dist (g i x') (g i (k i)) ≤ ε / 3 + ε / 3 := by
intro x' hx'
refine (dist_triangle_right _ _ _).trans (add_le_add (hgδ hpi ?_).le hgi.le)
exact ((dist_triangle _ _ _).trans_lt (add_lt_add hx'.out hki)).trans_eq (add_halves δ)
have := dist_convolution_le (add_pos h2ε h2ε).le hφi hnφi hiφi hmgi h1
refine ((dist_triangle _ _ _).trans_lt (add_lt_add_of_le_of_lt this hgi)).trans_eq ?_
field_simp; ring_nf | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_tendsto_right | `(φ i ⋆ g i) (k i)` tends to `z₀` as `i` tends to some filter `l` if
* `φ` is a sequence of nonnegative functions with integral `1` as `i` tends to `l`;
* The support of `φ` tends to small neighborhoods around `(0 : G)` as `i` tends to `l`;
* `g i` is `mu`-a.e. strongly measurable as `i` tends to `l`;
* `g i x` tends to `z₀` as `(i, x)` tends to `l ×ˢ 𝓝 x₀`;
* `k i` tends to `x₀`.
See also `ContDiffBump.convolution_tendsto_right`. |
integral_convolution [MeasurableAdd₂ G] [MeasurableNeg G] [NormedSpace ℝ E]
[NormedSpace ℝ E'] [CompleteSpace E] [CompleteSpace E'] (hf : Integrable f ν)
(hg : Integrable g μ) : ∫ x, (f ⋆[L, ν] g) x ∂μ = L (∫ x, f x ∂ν) (∫ x, g x ∂μ) := by
refine (integral_integral_swap (by apply hf.convolution_integrand L hg)).trans ?_
simp_rw [integral_comp_comm _ (hg.comp_sub_right _), integral_sub_right_eq_self]
exact (L.flip (∫ x, g x ∂μ)).integral_comp_comm hf
variable [MeasurableAdd₂ G] [IsAddRightInvariant ν] [MeasurableNeg G] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | integral_convolution | null |
convolution_assoc' (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z = L₃ x (L₄ y z))
{x₀ : G} (hfg : ∀ᵐ y ∂μ, ConvolutionExistsAt f g y L ν)
(hgk : ∀ᵐ x ∂ν, ConvolutionExistsAt g k x L₄ μ)
(hi : Integrable (uncurry fun x y => (L₃ (f y)) ((L₄ (g (x - y))) (k (x₀ - x)))) (μ.prod ν)) :
((f ⋆[L, ν] g) ⋆[L₂, μ] k) x₀ = (f ⋆[L₃, ν] g ⋆[L₄, μ] k) x₀ :=
calc
((f ⋆[L, ν] g) ⋆[L₂, μ] k) x₀ = ∫ t, L₂ (∫ s, L (f s) (g (t - s)) ∂ν) (k (x₀ - t)) ∂μ := rfl
_ = ∫ t, ∫ s, L₂ (L (f s) (g (t - s))) (k (x₀ - t)) ∂ν ∂μ :=
(integral_congr_ae (hfg.mono fun t ht => ((L₂.flip (k (x₀ - t))).integral_comp_comm ht).symm))
_ = ∫ t, ∫ s, L₃ (f s) (L₄ (g (t - s)) (k (x₀ - t))) ∂ν ∂μ := by simp_rw [hL]
_ = ∫ s, ∫ t, L₃ (f s) (L₄ (g (t - s)) (k (x₀ - t))) ∂μ ∂ν := by rw [integral_integral_swap hi]
_ = ∫ s, ∫ u, L₃ (f s) (L₄ (g u) (k (x₀ - s - u))) ∂μ ∂ν := by
congr; ext t
rw [eq_comm, ← integral_sub_right_eq_self _ t]
simp_rw [sub_sub_sub_cancel_right]
_ = ∫ s, L₃ (f s) (∫ u, L₄ (g u) (k (x₀ - s - u)) ∂μ) ∂ν := by
refine integral_congr_ae ?_
refine ((quasiMeasurePreserving_sub_left_of_right_invariant ν x₀).ae hgk).mono fun t ht => ?_
exact (L₃ (f t)).integral_comp_comm ht
_ = (f ⋆[L₃, ν] g ⋆[L₄, μ] k) x₀ := rfl | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_assoc' | Convolution is associative. This has a weak but inconvenient integrability condition.
See also `MeasureTheory.convolution_assoc`. |
convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z = L₃ x (L₄ y z)) {x₀ : G}
(hf : AEStronglyMeasurable f ν) (hg : AEStronglyMeasurable g μ) (hk : AEStronglyMeasurable k μ)
(hfg : ∀ᵐ y ∂μ, ConvolutionExistsAt f g y L ν)
(hgk : ∀ᵐ x ∂ν, ConvolutionExistsAt (fun x => ‖g x‖) (fun x => ‖k x‖) x (mul ℝ ℝ) μ)
(hfgk :
ConvolutionExistsAt (fun x => ‖f x‖) ((fun x => ‖g x‖) ⋆[mul ℝ ℝ, μ] fun x => ‖k x‖) x₀
(mul ℝ ℝ) ν) :
((f ⋆[L, ν] g) ⋆[L₂, μ] k) x₀ = (f ⋆[L₃, ν] g ⋆[L₄, μ] k) x₀ := by
refine convolution_assoc' L L₂ L₃ L₄ hL hfg (hgk.mono fun x hx => hx.of_norm L₄ hg hk) ?_
have h_meas :
AEStronglyMeasurable (uncurry fun x y => L₃ (f y) (L₄ (g x) (k (x₀ - y - x))))
(μ.prod ν) := by
refine L₃.aestronglyMeasurable_comp₂ hf.comp_snd ?_
refine L₄.aestronglyMeasurable_comp₂ hg.comp_fst ?_
refine (hk.mono_ac ?_).comp_measurable
((measurable_const.sub measurable_snd).sub measurable_fst)
refine QuasiMeasurePreserving.absolutelyContinuous ?_
refine QuasiMeasurePreserving.prod_of_left
((measurable_const.sub measurable_snd).sub measurable_fst) (Eventually.of_forall fun y => ?_)
dsimp only
exact quasiMeasurePreserving_sub_left_of_right_invariant μ _
have h2_meas :
AEStronglyMeasurable (fun y => ∫ x, ‖L₃ (f y) (L₄ (g x) (k (x₀ - y - x)))‖ ∂μ) ν :=
h_meas.prod_swap.norm.integral_prod_right'
have h3 : map (fun z : G × G => (z.1 - z.2, z.2)) (μ.prod ν) = μ.prod ν :=
(measurePreserving_sub_prod μ ν).map_eq
suffices Integrable (uncurry fun x y => L₃ (f y) (L₄ (g x) (k (x₀ - y - x)))) (μ.prod ν) by
rw [← h3] at this
convert this.comp_measurable (measurable_sub.prodMk measurable_snd)
ext ⟨x, y⟩
simp +unfoldPartialApp only [uncurry, Function.comp_apply,
sub_sub_sub_cancel_right]
simp_rw [integrable_prod_iff' h_meas]
refine ⟨((quasiMeasurePreserving_sub_left_of_right_invariant ν x₀).ae hgk).mono fun t ht =>
(L₃ (f t)).integrable_comp <| ht.of_norm L₄ hg hk, ?_⟩
refine (hfgk.const_mul (‖L₃‖ * ‖L₄‖)).mono' h2_meas
(((quasiMeasurePreserving_sub_left_of_right_invariant ν x₀).ae hgk).mono fun t ht => ?_)
simp_rw [convolution_def, mul_apply', mul_mul_mul_comm ‖L₃‖ ‖L₄‖, ← integral_const_mul]
rw [Real.norm_of_nonneg (by positivity)]
refine integral_mono_of_nonneg (Eventually.of_forall fun t => norm_nonneg _)
((ht.const_mul _).const_mul _) (Eventually.of_forall fun s => ?_)
simp only [← mul_assoc ‖L₄‖]
apply_rules [ContinuousLinearMap.le_of_opNorm₂_le_of_le, le_rfl] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_assoc | Convolution is associative. This requires that
* all maps are a.e. strongly measurable w.r.t. one of the measures
* `f ⋆[L, ν] g` exists almost everywhere
* `‖g‖ ⋆[μ] ‖k‖` exists almost everywhere
* `‖f‖ ⋆[ν] (‖g‖ ⋆[μ] ‖k‖)` exists at `x₀` |
convolution_precompR_apply {g : G → E'' →L[𝕜] E'} (hf : LocallyIntegrable f μ)
(hcg : HasCompactSupport g) (hg : Continuous g) (x₀ : G) (x : E'') :
(f ⋆[L.precompR E'', μ] g) x₀ x = (f ⋆[L, μ] fun a => g a x) x₀ := by
have := hcg.convolutionExists_right (L.precompR E'' :) hf hg x₀
simp_rw [convolution_def, ContinuousLinearMap.integral_apply this]
rfl
variable [NormedSpace 𝕜 G] [SFinite μ] [IsAddLeftInvariant μ] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | convolution_precompR_apply | null |
_root_.HasCompactSupport.hasFDerivAt_convolution_right (hcg : HasCompactSupport g)
(hf : LocallyIntegrable f μ) (hg : ContDiff 𝕜 1 g) (x₀ : G) :
HasFDerivAt (f ⋆[L, μ] g) ((f ⋆[L.precompR G, μ] fderiv 𝕜 g) x₀) x₀ := by
rcases hcg.eq_zero_or_finiteDimensional 𝕜 hg.continuous with (rfl | fin_dim)
· have : fderiv 𝕜 (0 : G → E') = 0 := fderiv_const (0 : E')
simp only [this, convolution_zero, Pi.zero_apply]
exact hasFDerivAt_const (0 : F) x₀
have : ProperSpace G := FiniteDimensional.proper_rclike 𝕜 G
set L' := L.precompR G
have h1 : ∀ᶠ x in 𝓝 x₀, AEStronglyMeasurable (fun t => L (f t) (g (x - t))) μ :=
Eventually.of_forall
(hf.aestronglyMeasurable.convolution_integrand_snd L hg.continuous.aestronglyMeasurable)
have h2 : ∀ x, AEStronglyMeasurable (fun t => L' (f t) (fderiv 𝕜 g (x - t))) μ :=
hf.aestronglyMeasurable.convolution_integrand_snd L'
(hg.continuous_fderiv le_rfl).aestronglyMeasurable
have h3 : ∀ x t, HasFDerivAt (fun x => g (x - t)) (fderiv 𝕜 g (x - t)) x := fun x t ↦ by
simpa using
(hg.differentiable le_rfl).differentiableAt.hasFDerivAt.comp x
((hasFDerivAt_id x).sub (hasFDerivAt_const t x))
let K' := -tsupport (fderiv 𝕜 g) + closedBall x₀ 1
have hK' : IsCompact K' := (hcg.fderiv 𝕜).isCompact.neg.add (isCompact_closedBall x₀ 1)
apply hasFDerivAt_integral_of_dominated_of_fderiv_le zero_lt_one h1 _ (h2 x₀)
· filter_upwards with t x hx using
(hcg.fderiv 𝕜).convolution_integrand_bound_right L' (hg.continuous_fderiv le_rfl)
(ball_subset_closedBall hx)
· rw [integrable_indicator_iff hK'.measurableSet]
exact ((hf.integrableOn_isCompact hK').norm.const_mul _).mul_const _
· exact Eventually.of_forall fun t x _ => (L _).hasFDerivAt.comp x (h3 x t)
· exact hcg.convolutionExists_right L hf hg.continuous x₀ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.hasFDerivAt_convolution_right | Compute the total derivative of `f ⋆ g` if `g` is `C^1` with compact support and `f` is locally
integrable. To write down the total derivative as a convolution, we use
`ContinuousLinearMap.precompR`. |
_root_.HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
(hcf : HasCompactSupport f) (hf : ContDiff 𝕜 1 f) (hg : LocallyIntegrable g μ) (x₀ : G) :
HasFDerivAt (f ⋆[L, μ] g) ((fderiv 𝕜 f ⋆[L.precompL G, μ] g) x₀) x₀ := by
simp +singlePass only [← convolution_flip]
exact hcf.hasFDerivAt_convolution_right L.flip hg hf x₀ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.hasFDerivAt_convolution_left | null |
_root_.HasCompactSupport.hasDerivAt_convolution_right (hf : LocallyIntegrable f₀ μ)
(hcg : HasCompactSupport g₀) (hg : ContDiff 𝕜 1 g₀) (x₀ : 𝕜) :
HasDerivAt (f₀ ⋆[L, μ] g₀) ((f₀ ⋆[L, μ] deriv g₀) x₀) x₀ := by
convert (hcg.hasFDerivAt_convolution_right L hf hg x₀).hasDerivAt using 1
rw [convolution_precompR_apply L hf (hcg.fderiv 𝕜) (hg.continuous_fderiv le_rfl)]
rfl | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.hasDerivAt_convolution_right | null |
_root_.HasCompactSupport.hasDerivAt_convolution_left [IsNegInvariant μ]
(hcf : HasCompactSupport f₀) (hf : ContDiff 𝕜 1 f₀) (hg : LocallyIntegrable g₀ μ) (x₀ : 𝕜) :
HasDerivAt (f₀ ⋆[L, μ] g₀) ((deriv f₀ ⋆[L, μ] g₀) x₀) x₀ := by
simp +singlePass only [← convolution_flip]
exact hcf.hasDerivAt_convolution_right L.flip hg hf x₀ | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.hasDerivAt_convolution_left | null |
hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
(hs : IsOpen s) (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
(hf : LocallyIntegrable f μ) (hg : ContDiffOn 𝕜 1 ↿g (s ×ˢ univ)) (q₀ : P × G)
(hq₀ : q₀.1 ∈ s) :
HasFDerivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2)
((f ⋆[L.precompR (P × G), μ] fun x : G => fderiv 𝕜 ↿g (q₀.1, x)) q₀.2) q₀ := by
let g' := fderiv 𝕜 ↿g
have A : ∀ p ∈ s, Continuous (g p) := fun p hp ↦ by
refine hg.continuousOn.comp_continuous (.prodMk_right _) fun x => ?_
simpa only [prodMk_mem_set_prod_eq, mem_univ, and_true] using hp
have A' : ∀ q : P × G, q.1 ∈ s → s ×ˢ univ ∈ 𝓝 q := fun q hq ↦ by
apply (hs.prod isOpen_univ).mem_nhds
simpa only [mem_prod, mem_univ, and_true] using hq
have g'_zero : ∀ p x, p ∈ s → x ∉ k → g' (p, x) = 0 := by
intro p x hp hx
refine (hasFDerivAt_zero_of_eventually_const 0 ?_).fderiv
have M2 : kᶜ ∈ 𝓝 x := hk.isClosed.isOpen_compl.mem_nhds hx
have M1 : s ∈ 𝓝 p := hs.mem_nhds hp
rw [nhds_prod_eq]
filter_upwards [prod_mem_prod M1 M2]
rintro ⟨p, y⟩ ⟨hp, hy⟩
exact hgs p y hp hy
/- We find a small neighborhood of `{q₀.1} × k` on which the derivative is uniformly bounded. This
follows from the continuity at all points of the compact set `k`. -/
obtain ⟨ε, C, εpos, h₀ε, hε⟩ :
∃ ε C, 0 < ε ∧ ball q₀.1 ε ⊆ s ∧ ∀ p x, ‖p - q₀.1‖ < ε → ‖g' (p, x)‖ ≤ C := by
have A : IsCompact ({q₀.1} ×ˢ k) := isCompact_singleton.prod hk
obtain ⟨t, kt, t_open, ht⟩ : ∃ t, {q₀.1} ×ˢ k ⊆ t ∧ IsOpen t ∧ IsBounded (g' '' t) := by
have B : ContinuousOn g' (s ×ˢ univ) :=
hg.continuousOn_fderiv_of_isOpen (hs.prod isOpen_univ) le_rfl
apply exists_isOpen_isBounded_image_of_isCompact_of_continuousOn A (hs.prod isOpen_univ) _ B
simp only [prod_subset_prod_iff, hq₀, singleton_subset_iff, subset_univ, and_self_iff,
true_or]
obtain ⟨ε, εpos, hε, h'ε⟩ :
∃ ε : ℝ, 0 < ε ∧ thickening ε ({q₀.fst} ×ˢ k) ⊆ t ∧ ball q₀.1 ε ⊆ s := by
obtain ⟨ε, εpos, hε⟩ : ∃ ε : ℝ, 0 < ε ∧ thickening ε (({q₀.fst} : Set P) ×ˢ k) ⊆ t :=
A.exists_thickening_subset_open t_open kt
obtain ⟨δ, δpos, hδ⟩ : ∃ δ : ℝ, 0 < δ ∧ ball q₀.1 δ ⊆ s := Metric.isOpen_iff.1 hs _ hq₀
refine ⟨min ε δ, lt_min εpos δpos, ?_, ?_⟩
· exact Subset.trans (thickening_mono (min_le_left _ _) _) hε
· exact Subset.trans (ball_subset_ball (min_le_right _ _)) hδ
obtain ⟨C, Cpos, hC⟩ : ∃ C, 0 < C ∧ g' '' t ⊆ closedBall 0 C := ht.subset_closedBall_lt 0 0
refine ⟨ε, C, εpos, h'ε, fun p x hp => ?_⟩
have hps : p ∈ s := h'ε (mem_ball_iff_norm.2 hp)
by_cases hx : x ∈ k
· have H : (p, x) ∈ t := by
apply hε
refine mem_thickening_iff.2 ⟨(q₀.1, x), ?_, ?_⟩
· simp only [hx, singleton_prod, mem_image, Prod.mk_inj, true_and, exists_eq_right]
· rw [← dist_eq_norm] at hp
simpa only [Prod.dist_eq, εpos, dist_self, max_lt_iff, and_true] using hp
... | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | hasFDerivAt_convolution_right_with_param | The derivative of the convolution `f * g` is given by `f * Dg`, when `f` is locally integrable
and `g` is `C^1` and compactly supported. Version where `g` depends on an additional parameter in an
open subset `s` of a parameter space `P` (and the compact support `k` is independent of the
parameter in `s`). |
contDiffOn_convolution_right_with_param_aux {G : Type uP} {E' : Type uP} {F : Type uP}
{P : Type uP} [NormedAddCommGroup E'] [NormedAddCommGroup F] [NormedSpace 𝕜 E']
[NormedSpace ℝ F] [NormedSpace 𝕜 F] [MeasurableSpace G]
{μ : Measure G}
[NormedAddCommGroup G] [BorelSpace G] [NormedSpace 𝕜 G] [NormedAddCommGroup P] [NormedSpace 𝕜 P]
{f : G → E} {n : ℕ∞} (L : E →L[𝕜] E' →L[𝕜] F) {g : P → G → E'} {s : Set P} {k : Set G}
(hs : IsOpen s) (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
(hf : LocallyIntegrable f μ) (hg : ContDiffOn 𝕜 n ↿g (s ×ˢ univ)) :
ContDiffOn 𝕜 n (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) := by
/- We have a formula for the derivation of `f * g`, which is of the same form, thanks to
`hasFDerivAt_convolution_right_with_param`. Therefore, we can prove the result by induction on
`n` (but for this we need the spaces at the different steps of the induction to live in the same
universe, which is why we make the assumption in the lemma that all the relevant spaces
come from the same universe). -/
induction n using ENat.nat_induction generalizing g E' F with
| zero =>
rw [WithTop.coe_zero, contDiffOn_zero] at hg ⊢
exact continuousOn_convolution_right_with_param L hk hgs hf hg
| succ n ih =>
simp only [Nat.succ_eq_add_one, Nat.cast_add, Nat.cast_one, WithTop.coe_add,
WithTop.coe_natCast, WithTop.coe_one] at hg ⊢
let f' : P → G → P × G →L[𝕜] F := fun p a =>
(f ⋆[L.precompR (P × G), μ] fun x : G => fderiv 𝕜 (uncurry g) (p, x)) a
have A : ∀ q₀ : P × G, q₀.1 ∈ s →
HasFDerivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (f' q₀.1 q₀.2) q₀ :=
hasFDerivAt_convolution_right_with_param L hs hk hgs hf hg.one_of_succ
rw [contDiffOn_succ_iff_fderiv_of_isOpen (hs.prod (@isOpen_univ G _))] at hg ⊢
refine ⟨?_, by simp, ?_⟩
· rintro ⟨p, x⟩ ⟨hp, -⟩
exact (A (p, x) hp).differentiableAt.differentiableWithinAt
· suffices H : ContDiffOn 𝕜 n ↿f' (s ×ˢ univ) by
apply H.congr
rintro ⟨p, x⟩ ⟨hp, -⟩
exact (A (p, x) hp).fderiv
have B : ∀ (p : P) (x : G), p ∈ s → x ∉ k → fderiv 𝕜 (uncurry g) (p, x) = 0 := by
intro p x hp hx
apply (hasFDerivAt_zero_of_eventually_const (0 : E') _).fderiv
have M2 : kᶜ ∈ 𝓝 x := IsOpen.mem_nhds hk.isClosed.isOpen_compl hx
have M1 : s ∈ 𝓝 p := hs.mem_nhds hp
rw [nhds_prod_eq]
filter_upwards [prod_mem_prod M1 M2]
rintro ⟨p, y⟩ ⟨hp, hy⟩
exact hgs p y hp hy
apply ih (L.precompR (P × G) :) B
convert hg.2.2
| top ih =>
rw [contDiffOn_infty] at hg ⊢
exact fun n ↦ ih n L hgs (hg n) | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | contDiffOn_convolution_right_with_param_aux | The convolution `f * g` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
supported. Version where `g` depends on an additional parameter in an open subset `s` of a
parameter space `P` (and the compact support `k` is independent of the parameter in `s`).
In this version, all the types belong to the same universe (to get an induction working in the
proof). Use instead `contDiffOn_convolution_right_with_param`, which removes this restriction. |
contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L : E →L[𝕜] E' →L[𝕜] F)
{g : P → G → E'} {s : Set P} {k : Set G} (hs : IsOpen s) (hk : IsCompact k)
(hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
(hg : ContDiffOn 𝕜 n ↿g (s ×ˢ univ)) :
ContDiffOn 𝕜 n (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ) := by
/- The result is known when all the universes are the same, from
`contDiffOn_convolution_right_with_param_aux`. We reduce to this situation by pushing
everything through `ULift` continuous linear equivalences. -/
let eG : Type max uG uE' uF uP := ULift.{max uE' uF uP} G
borelize eG
let eE' : Type max uE' uG uF uP := ULift.{max uG uF uP} E'
let eF : Type max uF uG uE' uP := ULift.{max uG uE' uP} F
let eP : Type max uP uG uE' uF := ULift.{max uG uE' uF} P
let isoG : eG ≃L[𝕜] G := ContinuousLinearEquiv.ulift
let isoE' : eE' ≃L[𝕜] E' := ContinuousLinearEquiv.ulift
let isoF : eF ≃L[𝕜] F := ContinuousLinearEquiv.ulift
let isoP : eP ≃L[𝕜] P := ContinuousLinearEquiv.ulift
let ef := f ∘ isoG
let eμ : Measure eG := Measure.map isoG.symm μ
let eg : eP → eG → eE' := fun ep ex => isoE'.symm (g (isoP ep) (isoG ex))
let eL :=
ContinuousLinearMap.comp
((ContinuousLinearEquiv.arrowCongr isoE' isoF).symm : (E' →L[𝕜] F) →L[𝕜] eE' →L[𝕜] eF) L
let R := fun q : eP × eG => (ef ⋆[eL, eμ] eg q.1) q.2
have R_contdiff : ContDiffOn 𝕜 n R ((isoP ⁻¹' s) ×ˢ univ) := by
have hek : IsCompact (isoG ⁻¹' k) := isoG.toHomeomorph.isClosedEmbedding.isCompact_preimage hk
have hes : IsOpen (isoP ⁻¹' s) := isoP.continuous.isOpen_preimage _ hs
refine contDiffOn_convolution_right_with_param_aux eL hes hek ?_ ?_ ?_
· intro p x hp hx
simp only [eg,
ContinuousLinearEquiv.map_eq_zero_iff]
exact hgs _ _ hp hx
· exact (locallyIntegrable_map_homeomorph isoG.symm.toHomeomorph).2 hf
· apply isoE'.symm.contDiff.comp_contDiffOn
apply hg.comp (isoP.prodCongr isoG).contDiff.contDiffOn
rintro ⟨p, x⟩ ⟨hp, -⟩
simpa only [mem_preimage, ContinuousLinearEquiv.prodCongr_apply, prodMk_mem_set_prod_eq,
mem_univ, and_true] using hp
have A : ContDiffOn 𝕜 n (isoF ∘ R ∘ (isoP.prodCongr isoG).symm) (s ×ˢ univ) := by
apply isoF.contDiff.comp_contDiffOn
apply R_contdiff.comp (ContinuousLinearEquiv.contDiff _).contDiffOn
rintro ⟨p, x⟩ ⟨hp, -⟩
simpa only [mem_preimage, mem_prod, mem_univ, and_true, ContinuousLinearEquiv.prodCongr_symm,
ContinuousLinearEquiv.prodCongr_apply, ContinuousLinearEquiv.apply_symm_apply] using hp
have : isoF ∘ R ∘ (isoP.prodCongr isoG).symm = fun q : P × G => (f ⋆[L, μ] g q.1) q.2 := by
apply funext
rintro ⟨p, x⟩
simp only [(· ∘ ·), ContinuousLinearEquiv.prodCongr_symm, ContinuousLinearEquiv.prodCongr_apply]
simp only [R, convolution]
rw [IsClosedEmbedding.integral_map, ← isoF.integral_comp_comm]
· rfl
... | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | contDiffOn_convolution_right_with_param | The convolution `f * g` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
supported. Version where `g` depends on an additional parameter in an open subset `s` of a
parameter space `P` (and the compact support `k` is independent of the parameter in `s`). |
contDiffOn_convolution_right_with_param_comp {n : ℕ∞} (L : E →L[𝕜] E' →L[𝕜] F) {s : Set P}
{v : P → G} (hv : ContDiffOn 𝕜 n v s) {f : G → E} {g : P → G → E'} {k : Set G} (hs : IsOpen s)
(hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
(hg : ContDiffOn 𝕜 n ↿g (s ×ˢ univ)) : ContDiffOn 𝕜 n (fun x => (f ⋆[L, μ] g x) (v x)) s := by
apply (contDiffOn_convolution_right_with_param L hs hk hgs hf hg).comp (contDiffOn_id.prodMk hv)
intro x hx
simp only [hx, prodMk_mem_set_prod_eq, mem_univ, and_self_iff, _root_.id] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | contDiffOn_convolution_right_with_param_comp | The convolution `f * g` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
supported. Version where `g` depends on an additional parameter in an open subset `s` of a
parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
given in terms of composition with an additional `C^n` function. |
contDiffOn_convolution_left_with_param [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
(L : E' →L[𝕜] E →L[𝕜] F) {f : G → E} {n : ℕ∞} {g : P → G → E'} {s : Set P} {k : Set G}
(hs : IsOpen s) (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
(hf : LocallyIntegrable f μ) (hg : ContDiffOn 𝕜 n ↿g (s ×ˢ univ)) :
ContDiffOn 𝕜 n (fun q : P × G => (g q.1 ⋆[L, μ] f) q.2) (s ×ˢ univ) := by
simpa only [convolution_flip] using contDiffOn_convolution_right_with_param L.flip hs hk hgs hf hg | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | contDiffOn_convolution_left_with_param | The convolution `g * f` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
supported. Version where `g` depends on an additional parameter in an open subset `s` of a
parameter space `P` (and the compact support `k` is independent of the parameter in `s`). |
contDiffOn_convolution_left_with_param_comp [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
(L : E' →L[𝕜] E →L[𝕜] F) {s : Set P} {n : ℕ∞} {v : P → G} (hv : ContDiffOn 𝕜 n v s) {f : G → E}
{g : P → G → E'} {k : Set G} (hs : IsOpen s) (hk : IsCompact k)
(hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
(hg : ContDiffOn 𝕜 n ↿g (s ×ˢ univ)) : ContDiffOn 𝕜 n (fun x => (g x ⋆[L, μ] f) (v x)) s := by
apply (contDiffOn_convolution_left_with_param L hs hk hgs hf hg).comp (contDiffOn_id.prodMk hv)
intro x hx
simp only [hx, prodMk_mem_set_prod_eq, mem_univ, and_self_iff, _root_.id] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | contDiffOn_convolution_left_with_param_comp | The convolution `g * f` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
supported. Version where `g` depends on an additional parameter in an open subset `s` of a
parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
given in terms of composition with additional `C^n` functions. |
_root_.HasCompactSupport.contDiff_convolution_right {n : ℕ∞} (hcg : HasCompactSupport g)
(hf : LocallyIntegrable f μ) (hg : ContDiff 𝕜 n g) : ContDiff 𝕜 n (f ⋆[L, μ] g) := by
rcases exists_compact_iff_hasCompactSupport.2 hcg with ⟨k, hk, h'k⟩
rw [← contDiffOn_univ]
exact contDiffOn_convolution_right_with_param_comp L contDiffOn_id isOpen_univ hk
(fun p x _ hx => h'k x hx) hf (hg.comp contDiff_snd).contDiffOn | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.contDiff_convolution_right | null |
_root_.HasCompactSupport.contDiff_convolution_left [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
{n : ℕ∞} (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 n f) (hg : LocallyIntegrable g μ) :
ContDiff 𝕜 n (f ⋆[L, μ] g) := by
rw [← convolution_flip]
exact hcf.contDiff_convolution_right L.flip hg hf | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | _root_.HasCompactSupport.contDiff_convolution_left | null |
noncomputable posConvolution (f : ℝ → E) (g : ℝ → E') (L : E →L[ℝ] E' →L[ℝ] F)
(ν : Measure ℝ := by volume_tac) : ℝ → F :=
indicator (Ioi (0 : ℝ)) fun x => ∫ t in 0..x, L (f t) (g (x - t)) ∂ν | def | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | posConvolution | The forward convolution of two functions `f` and `g` on `ℝ`, with respect to a continuous
bilinear map `L` and measure `ν`. It is defined to be the function mapping `x` to
`∫ t in 0..x, L (f t) (g (x - t)) ∂ν` if `0 < x`, and 0 otherwise. |
posConvolution_eq_convolution_indicator (f : ℝ → E) (g : ℝ → E') (L : E →L[ℝ] E' →L[ℝ] F)
(ν : Measure ℝ := by volume_tac) [NoAtoms ν] :
posConvolution f g L ν = convolution (indicator (Ioi 0) f) (indicator (Ioi 0) g) L ν := by
ext1 x
rw [convolution, posConvolution, indicator]
split_ifs with h
· rw [intervalIntegral.integral_of_le (le_of_lt h), integral_Ioc_eq_integral_Ioo, ←
integral_indicator (measurableSet_Ioo : MeasurableSet (Ioo 0 x))]
congr 1 with t : 1
have : t ≤ 0 ∨ t ∈ Ioo 0 x ∨ x ≤ t := by
rcases le_or_gt t 0 with (h | h)
· exact Or.inl h
· rcases lt_or_ge t x with (h' | h')
exacts [Or.inr (Or.inl ⟨h, h'⟩), Or.inr (Or.inr h')]
rcases this with (ht | ht | ht)
· rw [indicator_of_notMem (notMem_Ioo_of_le ht), indicator_of_notMem (notMem_Ioi.mpr ht),
ContinuousLinearMap.map_zero, ContinuousLinearMap.zero_apply]
· rw [indicator_of_mem ht, indicator_of_mem (mem_Ioi.mpr ht.1),
indicator_of_mem (mem_Ioi.mpr <| sub_pos.mpr ht.2)]
· rw [indicator_of_notMem (notMem_Ioo_of_ge ht),
indicator_of_notMem (notMem_Ioi.mpr (sub_nonpos_of_le ht)),
ContinuousLinearMap.map_zero]
· convert (integral_zero ℝ F).symm with t
by_cases ht : 0 < t
· rw [indicator_of_notMem (_ : x - t ∉ Ioi 0), ContinuousLinearMap.map_zero]
rw [notMem_Ioi] at h ⊢
exact sub_nonpos.mpr (h.trans ht.le)
· rw [indicator_of_notMem (mem_Ioi.not.mpr ht), ContinuousLinearMap.map_zero,
ContinuousLinearMap.zero_apply] | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | posConvolution_eq_convolution_indicator | null |
integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measure ℝ} [SFinite μ]
[SFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
(hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
Integrable (posConvolution f g L ν) μ := by
rw [← integrable_indicator_iff (measurableSet_Ioi : MeasurableSet (Ioi (0 : ℝ)))] at hf hg
rw [posConvolution_eq_convolution_indicator f g L ν]
exact (hf.convolution_integrand L hg).integral_prod_left | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | integrable_posConvolution | null |
integral_posConvolution [CompleteSpace E] [CompleteSpace E'] [CompleteSpace F]
{μ ν : Measure ℝ}
[SFinite μ] [SFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] {f : ℝ → E} {g : ℝ → E'}
(hf : IntegrableOn f (Ioi 0) ν) (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
∫ x : ℝ in Ioi 0, ∫ t : ℝ in 0..x, L (f t) (g (x - t)) ∂ν ∂μ =
L (∫ x : ℝ in Ioi 0, f x ∂ν) (∫ x : ℝ in Ioi 0, g x ∂μ) := by
rw [← integrable_indicator_iff measurableSet_Ioi] at hf hg
simp_rw [← integral_indicator measurableSet_Ioi]
convert integral_convolution L hf hg using 4 with x
apply posConvolution_eq_convolution_indicator | theorem | Analysis | [
"Mathlib.Analysis.Calculus.ContDiff.Basic",
"Mathlib.Analysis.Calculus.ParametricIntegral",
"Mathlib.MeasureTheory.Integral.Prod",
"Mathlib.MeasureTheory.Function.LocallyIntegrable",
"Mathlib.MeasureTheory.Group.Integral",
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Integral.IntervalInteg... | Mathlib/Analysis/Convolution.lean | integral_posConvolution | The integral over `Ioi 0` of a forward convolution of two functions is equal to the product
of their integrals over this set. (Compare `integral_convolution` for the two-sided convolution.) |
of a proof needing to construct a sequence by induction in the middle of the proof. | example | Analysis | [
"Mathlib.Analysis.SpecificLimits.Basic"
] | Mathlib/Analysis/Hofer.lean | of | null |
hofer {X : Type*} [MetricSpace X] [CompleteSpace X] (x : X) (ε : ℝ) (ε_pos : 0 < ε)
{ϕ : X → ℝ} (cont : Continuous ϕ) (nonneg : ∀ y, 0 ≤ ϕ y) : ∃ ε' > 0, ∃ x' : X,
ε' ≤ ε ∧ d x' x ≤ 2 * ε ∧ ε * ϕ x ≤ ε' * ϕ x' ∧ ∀ y, d x' y ≤ ε' → ϕ y ≤ 2 * ϕ x' := by
by_contra H
have reformulation : ∀ (x') (k : ℕ), ε * ϕ x ≤ ε / 2 ^ k * ϕ x' ↔ 2 ^ k * ϕ x ≤ ϕ x' := by
intro x' k
rw [div_mul_eq_mul_div, le_div_iff₀, mul_assoc, mul_le_mul_iff_right₀ ε_pos, mul_comm]
positivity
replace H : ∀ k : ℕ, ∀ x', d x' x ≤ 2 * ε ∧ 2 ^ k * ϕ x ≤ ϕ x' →
∃ y, d x' y ≤ ε / 2 ^ k ∧ 2 * ϕ x' < ϕ y := by
intro k x'
push_neg at H
have := H (ε / 2 ^ k) (by positivity) x' (div_le_self ε_pos.le <| one_le_pow₀ one_le_two)
simpa [reformulation] using this
haveI : Nonempty X := ⟨x⟩
choose! F hF using H
let u : ℕ → X := fun n => Nat.recOn n x F
have hu :
∀ n,
d (u n) x ≤ 2 * ε ∧ 2 ^ n * ϕ x ≤ ϕ (u n) →
d (u n) (u <| n + 1) ≤ ε / 2 ^ n ∧ 2 * ϕ (u n) < ϕ (u <| n + 1) := by
exact fun n ↦ hF n (u n)
have key : ∀ n, d (u n) (u (n + 1)) ≤ ε / 2 ^ n ∧ 2 * ϕ (u n) < ϕ (u (n + 1)) := by
intro n
induction n using Nat.case_strong_induction_on with
| hz => simpa [u, ε_pos.le] using hu 0
| hi n IH =>
have A : d (u (n + 1)) x ≤ 2 * ε := by
rw [dist_comm]
let r := range (n + 1) -- range (n+1) = {0, ..., n}
calc
d (u 0) (u (n + 1)) ≤ ∑ i ∈ r, d (u i) (u <| i + 1) := dist_le_range_sum_dist u (n + 1)
_ ≤ ∑ i ∈ r, ε / 2 ^ i :=
(sum_le_sum fun i i_in => (IH i <| Nat.lt_succ_iff.mp <| Finset.mem_range.mp i_in).1)
_ = (∑ i ∈ r, (1 / 2 : ℝ) ^ i) * ε := by
rw [Finset.sum_mul]
simp
field_simp
_ ≤ 2 * ε := by gcongr; apply sum_geometric_two_le
have B : 2 ^ (n + 1) * ϕ x ≤ ϕ (u (n + 1)) := by
refine @geom_le (ϕ ∘ u) _ zero_le_two (n + 1) fun m hm => ?_
exact (IH _ <| Nat.lt_add_one_iff.1 hm).2.le
exact hu (n + 1) ⟨A, B⟩
obtain ⟨key₁, key₂⟩ := forall_and.mp key
have cauchy_u : CauchySeq u := by
refine cauchySeq_of_le_geometric _ ε one_half_lt_one fun n => ?_
simpa only [one_div, inv_pow] using key₁ n
obtain ⟨y, limy⟩ : ∃ y, Tendsto u atTop (𝓝 y) := CompleteSpace.complete cauchy_u
have lim_top : Tendsto (ϕ ∘ u) atTop atTop := by
let v n := (ϕ ∘ u) (n + 1)
suffices Tendsto v atTop atTop by rwa [tendsto_add_atTop_iff_nat] at this
... | theorem | Analysis | [
"Mathlib.Analysis.SpecificLimits.Basic"
] | Mathlib/Analysis/Hofer.lean | hofer | null |
@[to_additive /-- Additive convolution of functions -/]
noncomputable mlconvolution (f g : G → ℝ≥0∞) (μ : Measure G) :
G → ℝ≥0∞ := fun x ↦ ∫⁻ y, (f y) * (g (y⁻¹ * x)) ∂μ | def | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | mlconvolution | Multiplicative convolution of functions. |
@[to_additive /-- The definition of additive convolution of functions. -/]
mlconvolution_def {f g : G → ℝ≥0∞} {μ : Measure G} {x : G} :
(f ⋆ₘₗ[μ] g) x = ∫⁻ y, (f y) * (g (y⁻¹ * x)) ∂μ := rfl | theorem | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | mlconvolution_def | Scoped notation for the multiplicative convolution of functions with respect to a measure `μ`.
-/
scoped[MeasureTheory] notation:67 f " ⋆ₘₗ["μ:67"] " g:66 => MeasureTheory.mlconvolution f g μ
/-- Scoped notation for the multiplicative convolution of functions with respect to `volume`. -/
scoped[MeasureTheory] notation:67 f " ⋆ₘₗ " g:66 => MeasureTheory.mlconvolution f g volume
/-- Scoped notation for the additive convolution of functions with respect to a measure `μ`. -/
scoped[MeasureTheory] notation:67 f " ⋆ₗ["μ:67"] " g:66 => MeasureTheory.lconvolution f g μ
/-- Scoped notation for the additive convolution of functions with respect to `volume`. -/
scoped[MeasureTheory] notation:67 f " ⋆ₗ " g:66 => MeasureTheory.lconvolution f g volume
/- The definition of multiplicative convolution of functions. |
@[to_additive (attr := simp)
/-- Convolution of the zero function with a function returns the zero function. -/]
zero_mlconvolution (f : G → ℝ≥0∞) (μ : Measure G) : 0 ⋆ₘₗ[μ] f = 0 := by
ext; simp [mlconvolution] | theorem | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | zero_mlconvolution | Convolution of the zero function with a function returns the zero function. |
@[to_additive (attr := simp)
/-- Convolution of a function with the zero function returns the zero function. -/]
mlconvolution_zero (f : G → ℝ≥0∞) (μ : Measure G) : f ⋆ₘₗ[μ] 0 = 0 := by
ext; simp [mlconvolution] | theorem | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | mlconvolution_zero | Convolution of a function with the zero function returns the zero function. |
@[to_additive (attr := measurability, fun_prop)
/-- The convolution of measurable functions is measurable. -/]
measurable_mlconvolution {f g : G → ℝ≥0∞} (μ : Measure G) [SFinite μ]
(hf : Measurable f) (hg : Measurable g) : Measurable (f ⋆ₘₗ[μ] g) := by
unfold mlconvolution
fun_prop | theorem | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | measurable_mlconvolution | The convolution of measurable functions is measurable. |
@[to_additive (attr := measurability, fun_prop)
/-- The convolution of `AEMeasurable` functions is `AEMeasurable`. -/]
aemeasurable_mlconvolution {f g : G → ℝ≥0∞}
(hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
AEMeasurable (f ⋆ₘₗ[μ] g) μ := by
unfold mlconvolution
fun_prop
@[to_additive] | theorem | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | aemeasurable_mlconvolution | The convolution of `AEMeasurable` functions is `AEMeasurable`. |
mlconvolution_assoc₀ {f g k : G → ℝ≥0∞}
(hf : AEMeasurable f μ) (hg : AEMeasurable g μ) (hk : AEMeasurable k μ) :
f ⋆ₘₗ[μ] g ⋆ₘₗ[μ] k = (f ⋆ₘₗ[μ] g) ⋆ₘₗ[μ] k := by
ext x
simp only [mlconvolution_def]
conv in f _ * (∫⁻ _ , _ ∂μ) =>
rw [← lintegral_const_mul'' _ (by fun_prop), ← lintegral_mul_left_eq_self _ y⁻¹]
conv in (∫⁻ _ , _ ∂μ) * k _ =>
rw [← lintegral_mul_const'' _ (by fun_prop)]
rw [lintegral_lintegral_swap]
· simp [mul_assoc]
simpa [mul_assoc] using by fun_prop
/- Convolution is associative. -/
@[to_additive /-- Convolution is associative. -/] | theorem | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | mlconvolution_assoc₀ | null |
mlconvolution_assoc {f g k : G → ℝ≥0∞}
(hf : Measurable f) (hg : Measurable g) (hk : Measurable k) :
f ⋆ₘₗ[μ] g ⋆ₘₗ[μ] k = (f ⋆ₘₗ[μ] g) ⋆ₘₗ[μ] k :=
mlconvolution_assoc₀ hf.aemeasurable hg.aemeasurable hk.aemeasurable | theorem | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | mlconvolution_assoc | null |
@[to_additive /-- Convolution is commutative when the group is commutative. -/]
mlconvolution_comm [IsMulLeftInvariant μ] [IsInvInvariant μ] {f g : G → ℝ≥0∞} :
(f ⋆ₘₗ[μ] g) = (g ⋆ₘₗ[μ] f) := by
ext x
simp only [mlconvolution_def]
rw [← lintegral_mul_left_eq_self _ x, ← lintegral_inv_eq_self]
simp [mul_comm] | theorem | Analysis | [
"Mathlib.MeasureTheory.Group.Prod",
"Mathlib.MeasureTheory.Group.LIntegral"
] | Mathlib/Analysis/LConvolution.lean | mlconvolution_comm | Convolution is commutative when the group is commutative. |
protected seminormedAddCommGroup : SeminormedAddCommGroup (Matrix m n α) :=
Pi.seminormedAddCommGroup
attribute [local instance] Matrix.seminormedAddCommGroup | def | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | seminormedAddCommGroup | Seminormed group instance (using sup norm of sup norm) for matrices over a seminormed group. Not
declared as an instance because there are several natural choices for defining the norm of a
matrix. |
norm_def (A : Matrix m n α) : ‖A‖ = ‖fun i j => A i j‖ := rfl | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | norm_def | null |
norm_eq_sup_sup_nnnorm (A : Matrix m n α) :
‖A‖ = Finset.sup Finset.univ fun i ↦ Finset.sup Finset.univ fun j ↦ ‖A i j‖₊ := by
simp_rw [Matrix.norm_def, Pi.norm_def, Pi.nnnorm_def] | lemma | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | norm_eq_sup_sup_nnnorm | The norm of a matrix is the sup of the sup of the nnnorm of the entries |
nnnorm_def (A : Matrix m n α) : ‖A‖₊ = ‖fun i j => A i j‖₊ := rfl | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | nnnorm_def | null |
norm_le_iff {r : ℝ} (hr : 0 ≤ r) {A : Matrix m n α} : ‖A‖ ≤ r ↔ ∀ i j, ‖A i j‖ ≤ r := by
simp_rw [norm_def, pi_norm_le_iff_of_nonneg hr] | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | norm_le_iff | null |
nnnorm_le_iff {r : ℝ≥0} {A : Matrix m n α} : ‖A‖₊ ≤ r ↔ ∀ i j, ‖A i j‖₊ ≤ r := by
simp_rw [nnnorm_def, pi_nnnorm_le_iff] | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | nnnorm_le_iff | null |
norm_lt_iff {r : ℝ} (hr : 0 < r) {A : Matrix m n α} : ‖A‖ < r ↔ ∀ i j, ‖A i j‖ < r := by
simp_rw [norm_def, pi_norm_lt_iff hr] | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | norm_lt_iff | null |
nnnorm_lt_iff {r : ℝ≥0} (hr : 0 < r) {A : Matrix m n α} :
‖A‖₊ < r ↔ ∀ i j, ‖A i j‖₊ < r := by
simp_rw [nnnorm_def, pi_nnnorm_lt_iff hr] | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | nnnorm_lt_iff | null |
norm_entry_le_entrywise_sup_norm (A : Matrix m n α) {i : m} {j : n} : ‖A i j‖ ≤ ‖A‖ :=
(norm_le_pi_norm (A i) j).trans (norm_le_pi_norm A i) | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | norm_entry_le_entrywise_sup_norm | null |
nnnorm_entry_le_entrywise_sup_nnnorm (A : Matrix m n α) {i : m} {j : n} : ‖A i j‖₊ ≤ ‖A‖₊ :=
(nnnorm_le_pi_nnnorm (A i) j).trans (nnnorm_le_pi_nnnorm A i)
@[simp] | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | nnnorm_entry_le_entrywise_sup_nnnorm | null |
nnnorm_map_eq (A : Matrix m n α) (f : α → β) (hf : ∀ a, ‖f a‖₊ = ‖a‖₊) :
‖A.map f‖₊ = ‖A‖₊ := by
simp only [nnnorm_def, Pi.nnnorm_def, Matrix.map_apply, hf]
@[simp] | theorem | Analysis | [
"Mathlib.Analysis.InnerProductSpace.PiL2"
] | Mathlib/Analysis/Matrix.lean | nnnorm_map_eq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.