Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
/- | |
Copyright (c) 2022 Floris van Doorn. All rights reserved. | |
Released under Apache 2.0 license as described in the file LICENSE. | |
Authors: Floris van Doorn | |
-/ | |
import measure_theory.group.integration | |
import measure_theory.group.prod | |
import measure_theory.function.locally_integrable | |
import analysis.calculus.specific_functions | |
import analysis.calculus.parametric_integral | |
/-! | |
# Convolution of functions | |
This file defines the convolution on two functions, i.e. `x β¦ β« f(t)g(x - t) βt`. | |
In the general case, these functions can be vector-valued, and have an arbitrary (additive) | |
group as domain. We use a continuous bilinear operation `L` on these function values as | |
"multiplication". The domain must be equipped with a Haar measure `ΞΌ` | |
(though many individual results have weaker conditions on `ΞΌ`). | |
For many applications we can take `L = lsmul β β` or `L = lmul β β`. | |
We also define `convolution_exists` and `convolution_exists_at` to state that the convolution is | |
well-defined (everywhere or at a single point). These conditions are needed for pointwise | |
computations (e.g. `convolution_exists_at.distrib_add`), but are generally not stong enough for any | |
local (or global) properties of the convolution. For this we need stronger assumptions on `f` | |
and/or `g`, and generally if we impose stronger conditions on one of the functions, we can impose | |
weaker conditions on the other. | |
We have proven many of the properties of the convolution assuming one of these functions | |
has compact support (in which case the other function only needs to be locally integrable). | |
We still need to prove the properties for other pairs of conditions (e.g. both functions are | |
rapidly decreasing) | |
# Design Decisions | |
We use a bilinear map `L` to "multiply" the two functions in the integrand. | |
This generality has several advantages | |
* This allows us to compute the total derivative of the convolution, in case the functions are | |
multivariate. The total derivative is again a convolution, but where the codomains of the | |
functions can be higher-dimensional. See `has_compact_support.has_fderiv_at_convolution_right`. | |
* This allows us to use `@[to_additive]` everywhere (which would not be possible if we would use | |
`mul`/`smul` in the integral, since `@[to_additive]` will incorrectly also try to additivize | |
those definitions). | |
* We need to support the case where at least one of the functions is vector-valued, but if we use | |
`smul` to multiply the functions, that would be an asymmetric definition. | |
# Main Definitions | |
* `convolution f g L ΞΌ x = (f β[L, ΞΌ] g) x = β« t, L (f t) (g (x - t)) βΞΌ` is the convolution of | |
`f` and `g` w.r.t. the continuous bilinear map `L` and measure `ΞΌ`. | |
* `convolution_exists_at f g x L ΞΌ` states that the convolution `(f β[L, ΞΌ] g) x` is well-defined | |
(i.e. the integral exists). | |
* `convolution_exists f g L ΞΌ` states that the convolution `f β[L, ΞΌ] g` is well-defined at each | |
point. | |
# Main Results | |
* `has_compact_support.has_fderiv_at_convolution_right` and | |
`has_compact_support.has_fderiv_at_convolution_left`: we can compute the total derivative | |
of the convolution as a convolution with the total derivative of the right (left) function. | |
* `has_compact_support.cont_diff_convolution_right` and | |
`has_compact_support.cont_diff_convolution_left`: the convolution is `πβΏ` if one of the functions | |
is `πβΏ` with compact support and the other function in locally integrable. | |
* `convolution_tendsto_right`: Given a sequence of nonnegative normalized functions whose support | |
tends to a small neighborhood around `0`, the convolution tends to the right argument. | |
This is specialized to bump functions in `cont_diff_bump_of_inner.convolution_tendsto_right`. | |
# Notation | |
The following notations are localized in the locale `convolution`: | |
* `f β[L, ΞΌ] g` for the convolution. Note: you have to use parentheses to apply the convolution | |
to an argument: `(f β[L, ΞΌ] g) x`. | |
* `f β[L] g := f β[L, volume] g` | |
* `f β g := f β[lsmul β β] g` | |
# To do | |
* Prove properties about the convolution if both functions are rapidly decreasing. | |
* Use `@[to_additive]` everywhere | |
-/ | |
open set function filter measure_theory measure_theory.measure topological_space | |
open continuous_linear_map metric | |
open_locale pointwise topological_space nnreal | |
variables {π G E E' E'' F F' F'' : Type*} | |
variables [normed_add_comm_group E] [normed_add_comm_group E'] [normed_add_comm_group E''] | |
[normed_add_comm_group F] {f f' : G β E} {g g' : G β E'} {x x' : G} {y y' : E} | |
section nontrivially_normed_field | |
variables [nontrivially_normed_field π] | |
variables [normed_space π E] [normed_space π E'] [normed_space π E''] [normed_space π F] | |
variables (L : E βL[π] E' βL[π] F) | |
section no_measurability | |
variables [add_group G] [topological_space G] | |
lemma has_compact_support.convolution_integrand_bound_right (hcg : has_compact_support g) | |
(hg : continuous g) {x t : G} {s : set G} (hx : x β s) : | |
β₯L (f t) (g (x - t))β₯ β€ (- tsupport g + s).indicator (Ξ» t, β₯Lβ₯ * β₯f tβ₯ * (β¨ i, β₯g iβ₯)) t := | |
begin | |
refine le_indicator (Ξ» t ht, _) (Ξ» t ht, _) t, | |
{ refine (L.le_op_normβ _ _).trans _, | |
exact mul_le_mul_of_nonneg_left | |
(le_csupr (hg.norm.bdd_above_range_of_has_compact_support hcg.norm) $ x - t) | |
(mul_nonneg (norm_nonneg _) (norm_nonneg _)) }, | |
{ have : x - t β support g, | |
{ refine mt (Ξ» hxt, _) ht, refine β¨_, _, set.neg_mem_neg.mpr (subset_closure hxt), hx, _β©, | |
rw [neg_sub, sub_add_cancel] }, | |
rw [nmem_support.mp this, (L _).map_zero, norm_zero] } | |
end | |
lemma continuous.convolution_integrand_fst [has_continuous_sub G] (hg : continuous g) (t : G) : | |
continuous (Ξ» x, L (f t) (g (x - t))) := | |
L.continuousβ.compβ continuous_const $ hg.comp $ continuous_id.sub continuous_const | |
lemma has_compact_support.convolution_integrand_bound_left (hcf : has_compact_support f) | |
(hf : continuous f) {x t : G} {s : set G} (hx : x β s) : | |
β₯L (f (x - t)) (g t)β₯ β€ (- tsupport f + s).indicator (Ξ» t, β₯Lβ₯ * (β¨ i, β₯f iβ₯) * β₯g tβ₯) t := | |
by { convert hcf.convolution_integrand_bound_right L.flip hf hx, | |
simp_rw [L.op_norm_flip, mul_right_comm] } | |
end no_measurability | |
section measurability | |
variables [measurable_space G] {ΞΌ : measure G} | |
/-- The convolution of `f` and `g` exists at `x` when the function `t β¦ L (f t) (g (x - t))` is | |
integrable. There are various conditions on `f` and `g` to prove this. -/ | |
def convolution_exists_at [has_sub G] (f : G β E) (g : G β E') (x : G) (L : E βL[π] E' βL[π] F) | |
(ΞΌ : measure G . volume_tac) : Prop := | |
integrable (Ξ» t, L (f t) (g (x - t))) ΞΌ | |
/-- The convolution of `f` and `g` exists when the function `t β¦ L (f t) (g (x - t))` is integrable | |
for all `x : G`. There are various conditions on `f` and `g` to prove this. -/ | |
def convolution_exists [has_sub G] (f : G β E) (g : G β E') (L : E βL[π] E' βL[π] F) | |
(ΞΌ : measure G . volume_tac) : Prop := | |
β x : G, convolution_exists_at f g x L ΞΌ | |
section convolution_exists | |
variables {L} | |
lemma convolution_exists_at.integrable [has_sub G] {x : G} (h : convolution_exists_at f g x L ΞΌ) : | |
integrable (Ξ» t, L (f t) (g (x - t))) ΞΌ := | |
h | |
variables (L) | |
section group | |
variables [add_group G] | |
variables [has_measurable_addβ G] [has_measurable_neg G] | |
lemma measure_theory.ae_strongly_measurable.convolution_integrand' [sigma_finite ΞΌ] | |
(hf : ae_strongly_measurable f ΞΌ) | |
(hg : ae_strongly_measurable g $ map (Ξ» (p : G Γ G), p.1 - p.2) (ΞΌ.prod ΞΌ)) : | |
ae_strongly_measurable (Ξ» p : G Γ G, L (f p.2) (g (p.1 - p.2))) (ΞΌ.prod ΞΌ) := | |
L.ae_strongly_measurable_compβ hf.snd $ hg.comp_measurable $ measurable_fst.sub measurable_snd | |
lemma measure_theory.ae_strongly_measurable.convolution_integrand_snd' | |
(hf : ae_strongly_measurable f ΞΌ) {x : G} | |
(hg : ae_strongly_measurable g $ map (Ξ» t, x - t) ΞΌ) : | |
ae_strongly_measurable (Ξ» t, L (f t) (g (x - t))) ΞΌ := | |
L.ae_strongly_measurable_compβ hf $ hg.comp_measurable $ measurable_id.const_sub x | |
lemma measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd' | |
{x : G} (hf : ae_strongly_measurable f $ map (Ξ» t, x - t) ΞΌ) | |
(hg : ae_strongly_measurable g ΞΌ) : ae_strongly_measurable (Ξ» t, L (f (x - t)) (g t)) ΞΌ := | |
L.ae_strongly_measurable_compβ (hf.comp_measurable $ measurable_id.const_sub x) hg | |
/-- 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. | |
Note: we could weaken the measurability condition to hold only for `ΞΌ.restrict s`. -/ | |
lemma bdd_above.convolution_exists_at' {xβ : G} | |
{s : set G} (hbg : bdd_above ((Ξ» i, β₯g iβ₯) '' ((Ξ» t, - t + xβ) β»ΒΉ' s))) | |
(hs : measurable_set s) (h2s : support (Ξ» t, L (f t) (g (xβ - t))) β s) | |
(hf : integrable_on f s ΞΌ) | |
(hmf : ae_strongly_measurable f ΞΌ) | |
(hmg : ae_strongly_measurable g $ map (Ξ» t, xβ - t) ΞΌ) : | |
convolution_exists_at f g xβ L ΞΌ := | |
begin | |
set s' := (Ξ» t, - t + xβ) β»ΒΉ' s, | |
have : βα΅ (t : G) βΞΌ, | |
β₯L (f t) (g (xβ - t))β₯ β€ s.indicator (Ξ» t, β₯Lβ₯ * β₯f tβ₯ * β¨ i : s', β₯g iβ₯) t, | |
{ refine eventually_of_forall _, | |
refine le_indicator (Ξ» t ht, _) (Ξ» t ht, _), | |
{ refine (L.le_op_normβ _ _).trans _, | |
refine mul_le_mul_of_nonneg_left | |
(le_csupr_set hbg $ mem_preimage.mpr _) | |
(mul_nonneg (norm_nonneg _) (norm_nonneg _)), | |
rwa [neg_sub, sub_add_cancel] }, | |
{ have : t β support (Ξ» t, L (f t) (g (xβ - t))) := mt (Ξ» h, h2s h) ht, | |
rw [nmem_support.mp this, norm_zero] } }, | |
refine integrable.mono' _ _ this, | |
{ rw [integrable_indicator_iff hs], exact (hf.norm.const_mul _).mul_const _ }, | |
{ exact hmf.convolution_integrand_snd' L hmg } | |
end | |
section left | |
variables [sigma_finite ΞΌ] [is_add_left_invariant ΞΌ] | |
lemma measure_theory.ae_strongly_measurable.convolution_integrand_snd | |
(hf : ae_strongly_measurable f ΞΌ) (hg : ae_strongly_measurable g ΞΌ) | |
(x : G) : ae_strongly_measurable (Ξ» t, L (f t) (g (x - t))) ΞΌ := | |
hf.convolution_integrand_snd' L $ hg.mono' $ map_sub_left_absolutely_continuous ΞΌ x | |
lemma measure_theory.ae_strongly_measurable.convolution_integrand_swap_snd | |
(hf : ae_strongly_measurable f ΞΌ) (hg : ae_strongly_measurable g ΞΌ) | |
(x : G) : ae_strongly_measurable (Ξ» t, L (f (x - t)) (g t)) ΞΌ := | |
(hf.mono' (map_sub_left_absolutely_continuous ΞΌ x)).convolution_integrand_swap_snd' L hg | |
end left | |
section right | |
variables [sigma_finite ΞΌ] [is_add_right_invariant ΞΌ] | |
lemma measure_theory.ae_strongly_measurable.convolution_integrand | |
(hf : ae_strongly_measurable f ΞΌ) (hg : ae_strongly_measurable g ΞΌ) : | |
ae_strongly_measurable (Ξ» p : G Γ G, L (f p.2) (g (p.1 - p.2))) (ΞΌ.prod ΞΌ) := | |
hf.convolution_integrand' L $ hg.mono' (quasi_measure_preserving_sub ΞΌ).absolutely_continuous | |
lemma measure_theory.integrable.convolution_integrand (hf : integrable f ΞΌ) (hg : integrable g ΞΌ) : | |
integrable (Ξ» p : G Γ G, L (f p.2) (g (p.1 - p.2))) (ΞΌ.prod ΞΌ) := | |
begin | |
have h_meas : ae_strongly_measurable (Ξ» (p : G Γ G), L (f p.2) (g (p.1 - p.2))) (ΞΌ.prod ΞΌ) := | |
hf.ae_strongly_measurable.convolution_integrand L hg.ae_strongly_measurable, | |
have h2_meas : ae_strongly_measurable (Ξ» (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 (Ξ» t, (L (f t)).integrable_comp (hg.comp_sub_right t)), _β©, | |
refine integrable.mono' _ h2_meas (eventually_of_forall $ | |
Ξ» t, (_ : _ β€ β₯Lβ₯ * β₯f tβ₯ * β« x, β₯g (x - t)β₯ βΞΌ)), | |
{ simp_rw [integral_sub_right_eq_self (Ξ» t, β₯ g t β₯)], | |
exact (hf.norm.const_mul _).mul_const _ }, | |
{ simp_rw [β integral_mul_left], | |
rw [real.norm_of_nonneg], | |
{ exact integral_mono_of_nonneg (eventually_of_forall $ Ξ» t, norm_nonneg _) | |
((hg.comp_sub_right t).norm.const_mul _) (eventually_of_forall $ Ξ» t, L.le_op_normβ _ _) }, | |
exact integral_nonneg (Ξ» x, norm_nonneg _) } | |
end | |
lemma measure_theory.integrable.ae_convolution_exists (hf : integrable f ΞΌ) (hg : integrable g ΞΌ) : | |
βα΅ x βΞΌ, convolution_exists_at f g x L ΞΌ := | |
((integrable_prod_iff $ hf.ae_strongly_measurable.convolution_integrand L | |
hg.ae_strongly_measurable).mp $ hf.convolution_integrand L hg).1 | |
end right | |
variables [topological_space G] [topological_add_group G] [borel_space G] | |
[second_countable_topology G] [sigma_compact_space G] | |
lemma has_compact_support.convolution_exists_at {xβ : G} | |
(h : has_compact_support (Ξ» t, L (f t) (g (xβ - t)))) (hf : locally_integrable f ΞΌ) | |
(hg : continuous g) : convolution_exists_at f g xβ L ΞΌ := | |
((((homeomorph.neg G).trans $ homeomorph.add_right xβ).compact_preimage.mpr h).bdd_above_image | |
hg.norm.continuous_on).convolution_exists_at' L is_closed_closure.measurable_set subset_closure | |
(hf h) hf.ae_strongly_measurable hg.ae_strongly_measurable | |
lemma has_compact_support.convolution_exists_right | |
(hcg : has_compact_support g) (hf : locally_integrable f ΞΌ) (hg : continuous g) : | |
convolution_exists f g L ΞΌ := | |
begin | |
intro xβ, | |
refine has_compact_support.convolution_exists_at L _ hf hg, | |
refine (hcg.comp_homeomorph (homeomorph.sub_left xβ)).mono _, | |
refine Ξ» t, mt (Ξ» ht : g (xβ - t) = 0, _), | |
simp_rw [ht, (L _).map_zero] | |
end | |
lemma has_compact_support.convolution_exists_left_of_continuous_right | |
(hcf : has_compact_support f) (hf : locally_integrable f ΞΌ) (hg : continuous g) : | |
convolution_exists f g L ΞΌ := | |
begin | |
intro xβ, | |
refine has_compact_support.convolution_exists_at L _ hf hg, | |
refine hcf.mono _, | |
refine Ξ» t, mt (Ξ» ht : f t = 0, _), | |
simp_rw [ht, L.map_zeroβ] | |
end | |
end group | |
section comm_group | |
variables [add_comm_group G] | |
section measurable_group | |
variables [has_measurable_addβ G] [has_measurable_neg G] [is_add_left_invariant ΞΌ] | |
/-- 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 `bdd_above.convolution_exists_at'` in an abelian group with a left-invariant | |
measure. This allows us to state the boundedness and measurability of `g` in a more natural way. -/ | |
lemma bdd_above.convolution_exists_at [sigma_finite ΞΌ] {xβ : G} | |
{s : set G} (hbg : bdd_above ((Ξ» i, β₯g iβ₯) '' ((Ξ» t, xβ - t) β»ΒΉ' s))) | |
(hs : measurable_set s) (h2s : support (Ξ» t, L (f t) (g (xβ - t))) β s) | |
(hf : integrable_on f s ΞΌ) | |
(hmf : ae_strongly_measurable f ΞΌ) | |
(hmg : ae_strongly_measurable g ΞΌ) : | |
convolution_exists_at f g xβ L ΞΌ := | |
begin | |
refine bdd_above.convolution_exists_at' L _ hs h2s hf hmf _, | |
{ simp_rw [β sub_eq_neg_add, hbg] }, | |
{ exact hmg.mono' (map_sub_left_absolutely_continuous ΞΌ xβ) } | |
end | |
variables {L} [is_neg_invariant ΞΌ] | |
lemma convolution_exists_at_flip : | |
convolution_exists_at g f x L.flip ΞΌ β convolution_exists_at f g x L ΞΌ := | |
by simp_rw [convolution_exists_at, β integrable_comp_sub_left (Ξ» t, L (f t) (g (x - t))) x, | |
sub_sub_cancel, flip_apply] | |
lemma convolution_exists_at.integrable_swap (h : convolution_exists_at f g x L ΞΌ) : | |
integrable (Ξ» t, L (f (x - t)) (g t)) ΞΌ := | |
by { convert h.comp_sub_left x, simp_rw [sub_sub_self] } | |
lemma convolution_exists_at_iff_integrable_swap : | |
convolution_exists_at f g x L ΞΌ β integrable (Ξ» t, L (f (x - t)) (g t)) ΞΌ := | |
convolution_exists_at_flip.symm | |
end measurable_group | |
variables [topological_space G] [topological_add_group G] [borel_space G] | |
[second_countable_topology G] [is_add_left_invariant ΞΌ] [is_neg_invariant ΞΌ] | |
[sigma_compact_space G] | |
lemma has_compact_support.convolution_exists_left | |
(hcf : has_compact_support f) (hf : continuous f) (hg : locally_integrable g ΞΌ) : | |
convolution_exists f g L ΞΌ := | |
Ξ» xβ, convolution_exists_at_flip.mp $ hcf.convolution_exists_right L.flip hg hf xβ | |
lemma has_compact_support.convolution_exists_right_of_continuous_left | |
(hcg : has_compact_support g) (hf : continuous f) (hg : locally_integrable g ΞΌ) : | |
convolution_exists f g L ΞΌ := | |
Ξ» xβ, convolution_exists_at_flip.mp $ | |
hcg.convolution_exists_left_of_continuous_right L.flip hg hf xβ | |
end comm_group | |
end convolution_exists | |
variables [normed_space β F] [complete_space F] | |
/-- The convolution of two functions `f` and `g` with respect to a continuous bilinear map `L` and | |
measure `ΞΌ`. It is defined to be `(f β[L, ΞΌ] g) x = β« t, L (f t) (g (x - t)) βΞΌ`. -/ | |
noncomputable def convolution [has_sub G] (f : G β E) (g : G β E') (L : E βL[π] E' βL[π] F) | |
(ΞΌ : measure G . volume_tac) : G β F := | |
Ξ» x, β« t, L (f t) (g (x - t)) βΞΌ | |
localized "notation f ` β[`:67 L:67 `, ` ΞΌ:67 `] `:0 g:66 := convolution f g L ΞΌ" in convolution | |
localized "notation f ` β[`:67 L:67 `]`:0 g:66 := convolution f g L | |
measure_theory.measure_space.volume" in convolution | |
localized "notation f ` β `:67 g:66 := convolution f g (continuous_linear_map.lsmul β β) | |
measure_theory.measure_space.volume" in convolution | |
lemma convolution_def [has_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. -/ | |
lemma convolution_lsmul [has_sub G] {f : G β π} {g : G β F} : | |
(f β[lsmul π π, ΞΌ] g : G β F) x = β« t, f t β’ g (x - t) βΞΌ := rfl | |
/-- The definition of convolution where the bilinear operator is multiplication. -/ | |
lemma convolution_lmul [has_sub G] [normed_space β π] [complete_space π] {f : G β π} {g : G β π} : | |
(f β[lmul π π, ΞΌ] g) x = β« t, f t * g (x - t) βΞΌ := rfl | |
section group | |
variables {L} [add_group G] | |
lemma smul_convolution [smul_comm_class β π F] | |
{y : π} : (y β’ f) β[L, ΞΌ] g = y β’ (f β[L, ΞΌ] g) := | |
by { ext, simp only [pi.smul_apply, convolution_def, β integral_smul, L.map_smulβ] } | |
lemma convolution_smul [smul_comm_class β π F] | |
{y : π} : f β[L, ΞΌ] (y β’ g) = y β’ (f β[L, ΞΌ] g) := | |
by { ext, simp only [pi.smul_apply, convolution_def, β integral_smul, (L _).map_smul] } | |
lemma zero_convolution : 0 β[L, ΞΌ] g = 0 := | |
by { ext, simp_rw [convolution_def, pi.zero_apply, L.map_zeroβ, integral_zero] } | |
lemma convolution_zero : f β[L, ΞΌ] 0 = 0 := | |
by { ext, simp_rw [convolution_def, pi.zero_apply, (L _).map_zero, integral_zero] } | |
lemma convolution_exists_at.distrib_add {x : G} (hfg : convolution_exists_at f g x L ΞΌ) | |
(hfg' : convolution_exists_at 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'] | |
lemma convolution_exists.distrib_add (hfg : convolution_exists f g L ΞΌ) | |
(hfg' : convolution_exists f g' L ΞΌ) : f β[L, ΞΌ] (g + g') = f β[L, ΞΌ] g + f β[L, ΞΌ] g' := | |
by { ext, exact (hfg x).distrib_add (hfg' x) } | |
lemma convolution_exists_at.add_distrib {x : G} (hfg : convolution_exists_at f g x L ΞΌ) | |
(hfg' : convolution_exists_at 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'] | |
lemma convolution_exists.add_distrib (hfg : convolution_exists f g L ΞΌ) | |
(hfg' : convolution_exists f' g L ΞΌ) : (f + f') β[L, ΞΌ] g = f β[L, ΞΌ] g + f' β[L, ΞΌ] g := | |
by { ext, exact (hfg x).add_distrib (hfg' x) } | |
variables (L) | |
lemma convolution_congr [has_measurable_add G] [has_measurable_neg G] [is_add_left_invariant ΞΌ] | |
[is_neg_invariant ΞΌ] (h1 : f =α΅[ΞΌ] f') (h2 : g =α΅[ΞΌ] g') : | |
f β[L, ΞΌ] g = f' β[L, ΞΌ] g' := | |
begin | |
ext x, | |
apply integral_congr_ae, | |
exact (h1.prod_mk $ h2.comp_tendsto (map_sub_left_ae ΞΌ x).le).fun_comp βΏ(Ξ» x y, L x y) | |
end | |
lemma support_convolution_subset_swap : support (f β[L, ΞΌ] g) β support g + support f := | |
begin | |
intros x h2x, | |
by_contra hx, | |
apply h2x, | |
simp_rw [set.mem_add, not_exists, not_and_distrib, nmem_support] at hx, | |
rw [convolution_def], | |
convert integral_zero G F, | |
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 } | |
end | |
variables [topological_space G] | |
variables [topological_add_group G] | |
lemma has_compact_support.convolution [t2_space G] (hcf : has_compact_support f) | |
(hcg : has_compact_support g) : has_compact_support (f β[L, ΞΌ] g) := | |
compact_of_is_closed_subset (hcg.is_compact.add hcf) is_closed_closure $ closure_minimal | |
((support_convolution_subset_swap L).trans $ add_subset_add subset_closure subset_closure) | |
(hcg.is_compact.add hcf).is_closed | |
variables [borel_space G] [second_countable_topology G] | |
/-- The convolution is continuous if one function is locally integrable and the other has compact | |
support and is continuous. -/ | |
lemma has_compact_support.continuous_convolution_right [locally_compact_space G] [t2_space G] | |
(hcg : has_compact_support g) (hf : locally_integrable f ΞΌ) | |
(hg : continuous g) : continuous (f β[L, ΞΌ] g) := | |
begin | |
refine continuous_iff_continuous_at.mpr (Ξ» xβ, _), | |
obtain β¨K, hK, h2Kβ© := exists_compact_mem_nhds xβ, | |
let K' := - tsupport g + K, | |
have hK' : is_compact K' := hcg.neg.add hK, | |
have : βαΆ x in π xβ, βα΅ (t : G) βΞΌ, | |
β₯L (f t) (g (x - t))β₯ β€ K'.indicator (Ξ» t, β₯Lβ₯ * β₯f tβ₯ * (β¨ i, β₯g iβ₯)) t := | |
eventually_of_mem h2K (Ξ» x hx, eventually_of_forall $ | |
Ξ» t, hcg.convolution_integrand_bound_right L hg hx), | |
refine continuous_at_of_dominated _ this _ _, | |
{ exact eventually_of_forall | |
(Ξ» x, hf.ae_strongly_measurable.convolution_integrand_snd' L hg.ae_strongly_measurable) }, | |
{ rw [integrable_indicator_iff hK'.measurable_set], | |
exact ((hf hK').norm.const_mul _).mul_const _ }, | |
{ exact eventually_of_forall (Ξ» t, (L.continuousβ.compβ continuous_const $ | |
hg.comp $ continuous_id.sub $ by apply continuous_const).continuous_at) } | |
end | |
/-- The convolution is continuous if one function is integrable and the other is bounded and | |
continuous. -/ | |
lemma bdd_above.continuous_convolution_right_of_integrable | |
(hbg : bdd_above (range (Ξ» x, β₯g xβ₯))) (hf : integrable f ΞΌ) (hg : continuous g) : | |
continuous (f β[L, ΞΌ] g) := | |
begin | |
refine continuous_iff_continuous_at.mpr (Ξ» xβ, _), | |
have : βαΆ x in π xβ, βα΅ (t : G) βΞΌ, | |
β₯L (f t) (g (x - t))β₯ β€ β₯Lβ₯ * β₯f tβ₯ * (β¨ i, β₯g iβ₯), | |
{ refine eventually_of_forall (Ξ» x, eventually_of_forall $ Ξ» t, _), | |
refine (L.le_op_normβ _ _).trans _, | |
exact mul_le_mul_of_nonneg_left (le_csupr hbg $ x - t) | |
(mul_nonneg (norm_nonneg _) (norm_nonneg _)) }, | |
refine continuous_at_of_dominated _ this _ _, | |
{ exact eventually_of_forall | |
(Ξ» x, hf.ae_strongly_measurable.convolution_integrand_snd' L hg.ae_strongly_measurable) }, | |
{ exact (hf.norm.const_mul _).mul_const _ }, | |
{ exact eventually_of_forall (Ξ» t, (L.continuousβ.compβ continuous_const $ | |
hg.comp $ continuous_id.sub $ by apply continuous_const).continuous_at) } | |
end | |
/-- A version of `has_compact_support.continuous_convolution_right` that works if `G` is | |
not locally compact but requires that `g` is integrable. -/ | |
lemma has_compact_support.continuous_convolution_right_of_integrable | |
(hcg : has_compact_support g) (hf : integrable f ΞΌ) (hg : continuous g) : | |
continuous (f β[L, ΞΌ] g) := | |
(hg.norm.bdd_above_range_of_has_compact_support hcg.norm).continuous_convolution_right_of_integrable | |
L hf hg | |
variables [sigma_finite ΞΌ] [is_add_right_invariant ΞΌ] | |
lemma measure_theory.integrable.integrable_convolution (hf : integrable f ΞΌ) (hg : integrable g ΞΌ) : | |
integrable (f β[L, ΞΌ] g) ΞΌ := | |
(hf.convolution_integrand L hg).integral_prod_left | |
end group | |
section comm_group | |
variables [add_comm_group G] | |
lemma support_convolution_subset : support (f β[L, ΞΌ] g) β support f + support g := | |
(support_convolution_subset_swap L).trans (add_comm _ _).subset | |
variables [topological_space G] | |
variables [topological_add_group G] | |
variables [borel_space G] | |
variables [is_add_left_invariant ΞΌ] [is_neg_invariant ΞΌ] | |
variable (L) | |
/-- Commutativity of convolution -/ | |
lemma convolution_flip : g β[L.flip, ΞΌ] f = f β[L, ΞΌ] g := | |
begin | |
ext1 x, | |
simp_rw [convolution_def], | |
rw [β integral_sub_left_eq_self _ ΞΌ x], | |
simp_rw [sub_sub_self, flip_apply] | |
end | |
/-- The symmetric definition of convolution. -/ | |
lemma convolution_eq_swap : (f β[L, ΞΌ] g) x = β« t, L (f (x - t)) (g t) βΞΌ := | |
by { rw [β convolution_flip], refl } | |
/-- The symmetric definition of convolution where the bilinear operator is scalar multiplication. -/ | |
lemma convolution_lsmul_swap {f : G β π} {g : G β F}: | |
(f β[lsmul π π, ΞΌ] g : G β F) x = β« t, f (x - t) β’ g t βΞΌ := | |
convolution_eq_swap _ | |
/-- The symmetric definition of convolution where the bilinear operator is multiplication. -/ | |
lemma convolution_lmul_swap [normed_space β π] [complete_space π] {f : G β π} {g : G β π} : | |
(f β[lmul π π, ΞΌ] g) x = β« t, f (x - t) * g t βΞΌ := | |
convolution_eq_swap _ | |
variables [second_countable_topology G] | |
lemma has_compact_support.continuous_convolution_left [locally_compact_space G] [t2_space G] | |
(hcf : has_compact_support f) (hf : continuous f) (hg : locally_integrable g ΞΌ) : | |
continuous (f β[L, ΞΌ] g) := | |
by { rw [β convolution_flip], exact hcf.continuous_convolution_right L.flip hg hf } | |
lemma bdd_above.continuous_convolution_left_of_integrable | |
(hbf : bdd_above (range (Ξ» 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 } | |
/-- A version of `has_compact_support.continuous_convolution_left` that works if `G` is | |
not locally compact but requires that `g` is integrable. -/ | |
lemma has_compact_support.continuous_convolution_left_of_integrable | |
(hcf : has_compact_support f) (hf : continuous f) (hg : integrable g ΞΌ) : | |
continuous (f β[L, ΞΌ] g) := | |
by { rw [β convolution_flip], exact hcf.continuous_convolution_right_of_integrable L.flip hg hf } | |
end comm_group | |
section normed_add_comm_group | |
variables [seminormed_add_comm_group G] | |
/-- 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 a `antilipschitz_with`-condition. -/ | |
lemma 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β) βΞΌ := | |
begin | |
have h2 : β t, L (f t) (g (xβ - t)) = L (f t) (g xβ), | |
{ 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, | |
rw [hg h2t] }, | |
{ rw [nmem_support] at ht, | |
simp_rw [ht, L.map_zeroβ] } }, | |
simp_rw [convolution_def, h2], | |
end | |
variables [borel_space G] [second_countable_topology G] | |
variables [is_add_left_invariant ΞΌ] [sigma_finite ΞΌ] | |
/-- 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 assume `f` is integrable, but also if | |
`L = (β’)` or more generally if `L` has a `antilipschitz_with`-condition. -/ | |
lemma dist_convolution_le' {xβ : G} {R Ξ΅ : β} | |
(hΞ΅ : 0 β€ Ξ΅) | |
(hif : integrable f ΞΌ) | |
(hf : support f β ball (0 : G) R) | |
(hmg : ae_strongly_measurable g ΞΌ) | |
(hg : β x β ball xβ R, dist (g x) (g xβ) β€ Ξ΅) : | |
dist ((f β[L, ΞΌ] g : G β F) xβ) (β« t, L (f t) (g xβ) βΞΌ) β€ β₯Lβ₯ * β« x, β₯f xβ₯ βΞΌ * Ξ΅ := | |
begin | |
have hfg : convolution_exists_at f g xβ L ΞΌ, | |
{ refine bdd_above.convolution_exists_at L _ metric.is_open_ball.measurable_set | |
(subset_trans _ hf) hif.integrable_on hif.ae_strongly_measurable hmg, | |
swap, { refine Ξ» t, mt (Ξ» ht : f t = 0, _), simp_rw [ht, L.map_zeroβ] }, | |
rw [bdd_above_def], | |
refine β¨β₯g xββ₯ + Ξ΅, _β©, | |
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) (g xβ)) β€ β₯L (f t)β₯ * Ξ΅, | |
{ 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_op_norm _ _).trans _, | |
exact mul_le_mul_of_nonneg_left (hg h2t) (norm_nonneg _) }, | |
{ rw [nmem_support] at ht, | |
simp_rw [ht, L.map_zeroβ, L.map_zero, norm_zero, zero_mul, dist_self] } }, | |
simp_rw [convolution_def], | |
simp_rw [dist_eq_norm] at h2 β’, | |
rw [β integral_sub hfg.integrable], swap, { exact (L.flip (g xβ)).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_right], | |
refine mul_le_mul_of_nonneg_right _ hΞ΅, | |
have h3 : β t, β₯L (f t)β₯ β€ β₯Lβ₯ * β₯f tβ₯ := Ξ» t, L.le_op_norm (f t), | |
refine (integral_mono (L.integrable_comp hif).norm (hif.norm.const_mul _) h3).trans_eq _, | |
rw [integral_mul_left] | |
end | |
variables [normed_space β E] [normed_space β E'] [complete_space E'] | |
/-- 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. -/ | |
lemma dist_convolution_le {f : G β β} {xβ : G} {R Ξ΅ : β} | |
(hΞ΅ : 0 β€ Ξ΅) | |
(hf : support f β ball (0 : G) R) | |
(hnf : β x, 0 β€ f x) | |
(hintf : β« x, f x βΞΌ = 1) | |
(hmg : ae_strongly_measurable g ΞΌ) | |
(hg : β x β ball xβ R, dist (g x) (g xβ) β€ Ξ΅) : | |
dist ((f β[lsmul β β, ΞΌ] g : G β E') xβ) (g xβ) β€ Ξ΅ := | |
begin | |
have hif : integrable f ΞΌ, | |
{ by_contra hif, exact zero_ne_one ((integral_undef hif).symm.trans hintf) }, | |
convert (dist_convolution_le' _ hΞ΅ hif hf hmg hg).trans _, | |
{ simp_rw [lsmul_apply, integral_smul_const, hintf, one_smul] }, | |
{ simp_rw [real.norm_of_nonneg (hnf _), hintf, mul_one], | |
exact (mul_le_mul_of_nonneg_right op_norm_lsmul_le hΞ΅).trans_eq (one_mul Ξ΅) } | |
end | |
/-- `(Ο i β g) xβ` tends to `g xβ` if `Ο` is a sequence of nonnegative functions with integral 1 | |
whose support tends to small neighborhoods around `(0 : G)` and `g` is continuous at `xβ`. | |
See also `cont_diff_bump_of_inner.convolution_tendsto_right'`. -/ | |
lemma convolution_tendsto_right {ΞΉ} {l : filter ΞΉ} {Ο : ΞΉ β G β β} | |
(hnΟ : β i x, 0 β€ Ο i x) | |
(hiΟ : β i, β« s, Ο i s βΞΌ = 1) | |
(hΟ : tendsto (Ξ» n, support (Ο n)) l (π 0).small_sets) | |
(hmg : ae_strongly_measurable g ΞΌ) {xβ : G} (hcg : continuous_at g xβ) : | |
tendsto (Ξ» i, (Ο i β[lsmul β β, ΞΌ] g : G β E') xβ) l (π (g xβ)) := | |
begin | |
simp_rw [tendsto_small_sets_iff] at hΟ, | |
rw [metric.continuous_at_iff] at hcg, | |
rw [metric.tendsto_nhds], | |
intros Ξ΅ hΞ΅, | |
rcases hcg (Ξ΅ / 2) (half_pos hΞ΅) with β¨Ξ΄, hΞ΄, hgΞ΄β©, | |
refine (hΟ (ball (0 : G) Ξ΄) $ ball_mem_nhds _ hΞ΄).mono (Ξ» i hi, _), | |
exact (dist_convolution_le (half_pos hΞ΅).le hi (hnΟ i) (hiΟ i) hmg (Ξ» x hx, (hgΞ΄ hx.out).le)) | |
.trans_lt (half_lt_self hΞ΅) | |
end | |
end normed_add_comm_group | |
namespace cont_diff_bump_of_inner | |
variables {n : with_top β} | |
variables [normed_space β E'] | |
variables [inner_product_space β G] | |
variables [complete_space E'] | |
variables {a : G} {Ο : cont_diff_bump_of_inner (0 : G)} | |
/-- If `Ο` is a bump function, compute `(Ο β g) xβ` if `g` is constant on `metric.ball xβ Ο.R`. -/ | |
lemma convolution_eq_right {xβ : G} | |
(hg : β x β ball xβ Ο.R, g x = g xβ) : (Ο β[lsmul β β, ΞΌ] g : G β E') xβ = integral ΞΌ Ο β’ g xβ := | |
by simp_rw [convolution_eq_right' _ Ο.support_eq.subset hg, lsmul_apply, integral_smul_const] | |
variables [borel_space G] | |
variables [is_locally_finite_measure ΞΌ] [is_open_pos_measure ΞΌ] | |
variables [finite_dimensional β G] | |
/-- If `Ο` is a normed bump function, compute `Ο β g` if `g` is constant on `metric.ball xβ Ο.R`. -/ | |
lemma normed_convolution_eq_right {xβ : G} | |
(hg : β x β ball xβ Ο.R, g x = g xβ) : (Ο.normed ΞΌ β[lsmul β β, ΞΌ] g : G β E') xβ = g xβ := | |
by { simp_rw [convolution_eq_right' _ Ο.support_normed_eq.subset hg, lsmul_apply], | |
exact integral_normed_smul Ο ΞΌ (g xβ) } | |
variables [is_add_left_invariant ΞΌ] | |
/-- If `Ο` is a normed bump function, approximate `(Ο β g) xβ` if `g` is near `g xβ` on a ball with | |
radius `Ο.R` around `xβ`. -/ | |
lemma dist_normed_convolution_le {xβ : G} {Ξ΅ : β} | |
(hmg : ae_strongly_measurable g ΞΌ) | |
(hg : β x β ball xβ Ο.R, dist (g x) (g xβ) β€ Ξ΅) : | |
dist ((Ο.normed ΞΌ β[lsmul β β, ΞΌ] g : G β E') xβ) (g xβ) β€ Ξ΅ := | |
dist_convolution_le (by simp_rw [β dist_self (g xβ), hg xβ (mem_ball_self Ο.R_pos)]) | |
Ο.support_normed_eq.subset Ο.nonneg_normed Ο.integral_normed hmg hg | |
/-- If `Ο i` is a sequence of normed bump function, `(Ο i β g) xβ` tends to `g xβ` if `(Ο i).R` | |
tends to `0` and `g` is continuous at `xβ`. -/ | |
lemma convolution_tendsto_right' {ΞΉ} {Ο : ΞΉ β cont_diff_bump_of_inner (0 : G)} | |
{l : filter ΞΉ} (hΟ : tendsto (Ξ» i, (Ο i).R) l (π 0)) | |
(hmg : ae_strongly_measurable g ΞΌ) {xβ : G} (hcg : continuous_at g xβ) : | |
tendsto (Ξ» i, ((Ξ» x, (Ο i).normed ΞΌ x) β[lsmul β β, ΞΌ] g : G β E') xβ) l (π (g xβ)) := | |
begin | |
refine convolution_tendsto_right (Ξ» i, (Ο i).nonneg_normed) (Ξ» i, (Ο i).integral_normed) | |
_ hmg hcg, | |
rw [normed_add_comm_group.tendsto_nhds_zero] at hΟ, | |
rw [tendsto_small_sets_iff], | |
intros t ht, | |
rcases metric.mem_nhds_iff.mp ht with β¨Ξ΅, hΞ΅, htβ©, | |
refine (hΟ Ξ΅ hΞ΅).mono (Ξ» i hi, subset_trans _ ht), | |
simp_rw [(Ο i).support_normed_eq], | |
rw [real.norm_eq_abs, abs_eq_self.mpr (Ο i).R_pos.le] at hi, | |
exact ball_subset_ball hi.le | |
end | |
/-- Special case of `cont_diff_bump_of_inner.convolution_tendsto_right'` where `g` is continuous. -/ | |
lemma convolution_tendsto_right {ΞΉ} {Ο : ΞΉ β cont_diff_bump_of_inner (0 : G)} | |
{l : filter ΞΉ} (hΟ : tendsto (Ξ» i, (Ο i).R) l (π 0)) | |
(hg : continuous g) (xβ : G) : | |
tendsto (Ξ» i, ((Ξ» x, (Ο i).normed ΞΌ x) β[lsmul β β, ΞΌ] g : G β E') xβ) l (π (g xβ)) := | |
convolution_tendsto_right' hΟ hg.ae_strongly_measurable hg.continuous_at | |
end cont_diff_bump_of_inner | |
end measurability | |
end nontrivially_normed_field | |
open_locale convolution | |
section is_R_or_C | |
variables [is_R_or_C π] | |
variables [normed_space π E] | |
variables [normed_space π E'] | |
variables [normed_space π E''] | |
variables [normed_space β F] [normed_space π F] | |
variables {n : with_top β} | |
variables [complete_space F] | |
variables [measurable_space G] {ΞΌ : measure G} | |
variables (L : E βL[π] E' βL[π] F) | |
section assoc | |
variables [normed_add_comm_group F'] [normed_space β F'] [normed_space π F'] [complete_space F'] | |
variables [normed_add_comm_group F''] [normed_space β F''] [normed_space π F''] [complete_space F''] | |
variables {k : G β E''} | |
variables (Lβ : F βL[π] E'' βL[π] F') | |
variables (Lβ : E βL[π] F'' βL[π] F') | |
variables (Lβ : E' βL[π] E'' βL[π] F'') | |
variables [add_group G] [has_measurable_add G] | |
variables [sigma_finite ΞΌ] | |
variables {Ξ½ : measure G} [sigma_finite Ξ½] [is_add_right_invariant Ξ½] | |
/-- Convolution is associative. | |
To do: prove that `hi` follows from simpler conditions. -/ | |
lemma convolution_assoc (hL : β (x : E) (y : E') (z : E''), Lβ (L x y) z = Lβ x (Lβ y z)) | |
{xβ : G} | |
(hβ : convolution_exists g k Lβ Ξ½) | |
(hβ : convolution_exists f g L ΞΌ) | |
(hi : integrable (uncurry (Ξ» 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β := | |
begin | |
have h1 := Ξ» t, (Lβ.flip (k (xβ - t))).integral_comp_comm (hβ t), | |
dsimp only [flip_apply] at h1, | |
simp_rw [convolution_def, β (Lβ (f _)).integral_comp_comm (hβ (xβ - _)), β h1, hL], | |
rw [integral_integral_swap hi], | |
congr', ext t, | |
rw [eq_comm, β integral_sub_right_eq_self _ t], | |
{ simp_rw [sub_sub_sub_cancel_right] }, | |
{ apply_instance }, | |
end | |
end assoc | |
variables [normed_add_comm_group G] [borel_space G] | |
variables [second_countable_topology G] [sigma_compact_space G] | |
lemma convolution_precompR_apply {g : G β E'' βL[π] E'} | |
(hf : locally_integrable f ΞΌ) (hcg : has_compact_support g) (hg : continuous g) | |
(xβ : G) (x : E'') : (f β[L.precompR E'', ΞΌ] g) xβ x = (f β[L, ΞΌ] (Ξ» a, g a x)) xβ := | |
begin | |
have := hcg.convolution_exists_right (L.precompR E'') hf hg xβ, | |
simp_rw [convolution_def, continuous_linear_map.integral_apply this], | |
refl, | |
end | |
variables [sigma_finite ΞΌ] [is_add_left_invariant ΞΌ] | |
variables [normed_space π G] [proper_space G] | |
/-- Compute the total derivative of `f β g` if `g` is `C^1` with compact support and `f` is locally | |
integrable. To write down the total derivative as a convolution, we use | |
`continuous_linear_map.precompR`. -/ | |
lemma has_compact_support.has_fderiv_at_convolution_right | |
(hcg : has_compact_support g) (hf : locally_integrable f ΞΌ) (hg : cont_diff π 1 g) (xβ : G) : | |
has_fderiv_at (f β[L, ΞΌ] g) ((f β[L.precompR G, ΞΌ] fderiv π g) xβ) xβ := | |
begin | |
set L' := L.precompR G, | |
have h1 : βαΆ x in π xβ, ae_strongly_measurable (Ξ» t, L (f t) (g (x - t))) ΞΌ := | |
eventually_of_forall | |
(hf.ae_strongly_measurable.convolution_integrand_snd L hg.continuous.ae_strongly_measurable), | |
have h2 : β x, ae_strongly_measurable (Ξ» t, L' (f t) (fderiv π g (x - t))) ΞΌ, | |
{ exact hf.ae_strongly_measurable.convolution_integrand_snd L' | |
(hg.continuous_fderiv le_rfl).ae_strongly_measurable }, | |
have h3 : β x t, has_fderiv_at (Ξ» x, g (x - t)) (fderiv π g (x - t)) x, | |
{ intros x t, | |
simpa using (hg.differentiable le_rfl).differentiable_at.has_fderiv_at.comp x | |
((has_fderiv_at_id x).sub (has_fderiv_at_const t x)) }, | |
let K' := - tsupport (fderiv π g) + closed_ball xβ 1, | |
have hK' : is_compact K' := (hcg.fderiv π).neg.add (is_compact_closed_ball xβ 1), | |
refine has_fderiv_at_integral_of_dominated_of_fderiv_le | |
zero_lt_one h1 _ (h2 xβ) _ _ _, | |
{ exact K'.indicator (Ξ» t, β₯L'β₯ * β₯f tβ₯ * (β¨ x, β₯fderiv π g xβ₯)) }, | |
{ exact hcg.convolution_exists_right L hf hg.continuous xβ }, | |
{ refine eventually_of_forall (Ξ» t x hx, _), | |
exact (hcg.fderiv π).convolution_integrand_bound_right L' | |
(hg.continuous_fderiv le_rfl) (ball_subset_closed_ball hx) }, | |
{ rw [integrable_indicator_iff hK'.measurable_set], | |
exact ((hf hK').norm.const_mul _).mul_const _ }, | |
{ exact eventually_of_forall (Ξ» t x hx, (L _).has_fderiv_at.comp x (h3 x t)) }, | |
end | |
lemma has_compact_support.has_fderiv_at_convolution_left [is_neg_invariant ΞΌ] | |
(hcf : has_compact_support f) (hf : cont_diff π 1 f) (hg : locally_integrable g ΞΌ) (xβ : G) : | |
has_fderiv_at (f β[L, ΞΌ] g) ((fderiv π f β[L.precompL G, ΞΌ] g) xβ) xβ := | |
begin | |
simp only [β convolution_flip] {single_pass := tt}, | |
exact hcf.has_fderiv_at_convolution_right L.flip hg hf xβ, | |
end | |
lemma has_compact_support.cont_diff_convolution_right [finite_dimensional π G] | |
(hcg : has_compact_support g) (hf : locally_integrable f ΞΌ) (hg : cont_diff π n g) : | |
cont_diff π n (f β[L, ΞΌ] g) := | |
begin | |
induction n using with_top.nat_induction with n ih ih generalizing g, | |
{ rw [cont_diff_zero] at hg β’, | |
exact hcg.continuous_convolution_right L hf hg }, | |
{ have h : β x, has_fderiv_at (f β[L, ΞΌ] g) ((f β[L.precompR G, ΞΌ] fderiv π g) x) x := | |
hcg.has_fderiv_at_convolution_right L hf hg.one_of_succ, | |
rw cont_diff_succ_iff_fderiv_apply, | |
split, | |
{ exact Ξ» xβ, β¨_, h xββ© }, | |
{ simp_rw [fderiv_eq h, convolution_precompR_apply L hf (hcg.fderiv π) | |
(hg.one_of_succ.continuous_fderiv le_rfl)], | |
intro x, | |
refine ih _ _, | |
{ refine @has_compact_support.comp_left _ _ _ _ _ _ (Ξ» (G : _ βL[π] _), G x) _ | |
(hcg.fderiv π) (continuous_linear_map.zero_apply x) }, | |
{ revert x, rw [β cont_diff_clm_apply], | |
exact (cont_diff_succ_iff_fderiv.mp hg).2 } } }, | |
{ rw [cont_diff_top] at hg β’, exact Ξ» n, ih n hcg (hg n) } | |
end | |
lemma has_compact_support.cont_diff_convolution_left [finite_dimensional π G] [is_neg_invariant ΞΌ] | |
(hcf : has_compact_support f) (hf : cont_diff π n f) (hg : locally_integrable g ΞΌ) : | |
cont_diff π n (f β[L, ΞΌ] g) := | |
by { rw [β convolution_flip], exact hcf.cont_diff_convolution_right L.flip hg hf } | |
end is_R_or_C | |
section real | |
/-! The one-variable case -/ | |
variables [is_R_or_C π] | |
variables [normed_space π E] | |
variables [normed_space π E'] | |
variables [normed_space β F] [normed_space π F] | |
variables {fβ : π β E} {gβ : π β E'} | |
variables {n : with_top β} | |
variables (L : E βL[π] E' βL[π] F) | |
variables [complete_space F] | |
variables {ΞΌ : measure π} | |
variables [is_add_left_invariant ΞΌ] [sigma_finite ΞΌ] | |
lemma has_compact_support.has_deriv_at_convolution_right | |
(hf : locally_integrable fβ ΞΌ) (hcg : has_compact_support gβ) (hg : cont_diff π 1 gβ) | |
(xβ : π) : | |
has_deriv_at (fβ β[L, ΞΌ] gβ) ((fβ β[L, ΞΌ] deriv gβ) xβ) xβ := | |
begin | |
convert (hcg.has_fderiv_at_convolution_right L hf hg xβ).has_deriv_at, | |
rw [convolution_precompR_apply L hf (hcg.fderiv π) (hg.continuous_fderiv le_rfl)], | |
refl, | |
end | |
lemma has_compact_support.has_deriv_at_convolution_left [is_neg_invariant ΞΌ] | |
(hcf : has_compact_support fβ) (hf : cont_diff π 1 fβ) | |
(hg : locally_integrable gβ ΞΌ) (xβ : π) : | |
has_deriv_at (fβ β[L, ΞΌ] gβ) ((deriv fβ β[L, ΞΌ] gβ) xβ) xβ := | |
begin | |
simp only [β convolution_flip] {single_pass := tt}, | |
exact hcf.has_deriv_at_convolution_right L.flip hg hf xβ, | |
end | |
end real | |