Download data/lean/OAI/Analysis/AncientFlat/Kernel/ClassicalBase.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 329 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/AncientFlat/Kernel/ClassicalBase.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/AncientFlat/Kernel/ClassicalBase.lean
-
curl -L -o ClassicalBase.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/AncientFlat/Kernel/ClassicalBase.lean
329 kB
import Mathlib
namespace OAI
noncomputable section
open scoped Topology SchwartzMap FourierTransform ContDiff
open Set Filter MeasureTheory
namespace BiharmonicKernel
lemma gaussian_moment_bound (n : ℕ) :
∃ C : ℝ, ∀ x : ℝ, |x|^n * Real.exp (-(x^2/2)) ≤ C := by
refine ⟨max 1 ((2:ℝ)^n * (n.factorial : ℝ)), fun x => ?_⟩
by_cases hx : |x| ≤ 1
· apply le_trans _ (le_max_left _ _)
have he : Real.exp (-(x^2/2)) ≤ 1 := Real.exp_le_one_iff.mpr (neg_nonpos.mpr (by positivity))
exact (mul_le_of_le_one_left (Real.exp_nonneg _)
(pow_le_one₀ (abs_nonneg x) hx)).trans he
· have hx1 : 1 ≤ |x| := (lt_of_not_ge hx).le
have hxx : |x| ≤ x^2 := by nlinarith [sq_abs x]
have hf : (x^2/2)^n ≤ Real.exp (x^2/2)*(n.factorial : ℝ) :=
(div_le_iff₀ (show (0:ℝ)<(n.factorial : ℝ) by positivity)).mp
(Real.pow_div_factorial_le_exp _ (by positivity) n)
have hfm : (x^2/2)^n * Real.exp (-(x^2/2)) ≤ (n.factorial : ℝ) := by
calc
_ ≤ (Real.exp (x^2/2)*(n.factorial : ℝ))*Real.exp (-(x^2/2)) :=
mul_le_mul_of_nonneg_right hf (Real.exp_nonneg _)
_ = (n.factorial : ℝ) := by rw [mul_right_comm, ← Real.exp_add, add_neg_cancel, Real.exp_zero, one_mul]
calc
_ ≤ (x^2)^n * Real.exp (-(x^2/2)) := by gcongr
_ = (2:ℝ)^n *((x^2/2)^n * Real.exp (-(x^2/2))) := by
rw [← mul_assoc, ← mul_pow]
congr 2
ring
_ ≤ (2:ℝ)^n * (n.factorial : ℝ) := mul_le_mul_of_nonneg_left hfm (by positivity)
_ ≤ _ := le_max_right _ _
lemma polynomial_gaussian_bound (p : Polynomial ℝ) (k : ℕ) :
∃ C : ℝ, ∀ x : ℝ, |x|^k * |p.eval x| * Real.exp (-(x^2/2)) ≤ C := by
induction p using Polynomial.induction_on' with
| add p q hp hq =>
obtain ⟨Cp,hp⟩ := hp
obtain ⟨Cq,hq⟩ := hq
refine ⟨Cp+Cq, fun x => ?_⟩
calc
_ ≤ |x|^k*(|p.eval x|+|q.eval x|)*Real.exp (-(x^2/2)) := by
rw [Polynomial.eval_add]
gcongr
exact abs_add_le _ _
_ = |x|^k*|p.eval x| *Real.exp (-(x^2/2))+
|x|^k*|q.eval x| *Real.exp (-(x^2/2)) := by ring
_ ≤ Cp+Cq := add_le_add (hp x) (hq x)
| monomial n a =>
obtain ⟨C,hC⟩ := gaussian_moment_bound (k+n)
refine ⟨|a| *C, fun x => ?_⟩
calc
_ = |a| *(|x|^(k+n)*Real.exp (-(x^2/2))) := by
simp only [Polynomial.eval_monomial, abs_mul, abs_pow, pow_add]
ring
_ ≤ |a| *C := mul_le_mul_of_nonneg_left (hC x) (abs_nonneg _)
def gaussian : SchwartzMap ℝ ℝ where
toFun x := Real.exp (-(x^2/2))
smooth' := by fun_prop
decay' k n := by
obtain ⟨C,hC⟩ := polynomial_gaussian_bound
((Polynomial.hermite n).map (algebraMap ℤ ℝ)) k
refine ⟨C,fun x => ?_⟩
rw [norm_iteratedFDeriv_eq_norm_iteratedDeriv, iteratedDeriv_eq_iterate,
Polynomial.deriv_gaussian_eq_hermite_mul_gaussian]
simpa only [norm_mul, norm_pow, norm_neg, norm_one, one_pow, one_mul,
Real.norm_eq_abs, abs_of_pos (Real.exp_pos _), Polynomial.eval_map,
Polynomial.aeval_def, mul_assoc] using hC x
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
omit [InnerProductSpace ℝ V] in
lemma norm_le_quadratic (q : ℝ) (hq : 0 < q) :
∃ (k : ℕ) (C : ℝ), ∀ x : V, ‖x‖ ≤ C * (1+‖q*‖x‖^2‖)^k := by
refine ⟨1,1+q⁻¹,fun x => ?_⟩
rw [pow_one, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
have he : (1+q⁻¹)*(1+q*‖x‖^2) = 1+‖x‖^2+q*‖x‖^2+q⁻¹ := by
field_simp
ring
rw [he]
nlinarith [sq_nonneg (‖x‖-1/2), inv_pos.mpr hq, mul_nonneg hq.le (sq_nonneg ‖x‖)]
def multiplier (b : ℝ) (hb : 0 < b) : SchwartzMap V ℂ :=
SchwartzMap.postcompCLM Complex.ofRealCLM
(SchwartzMap.compCLM ℝ
(g := fun x : V => Real.sqrt (2*b)*‖x‖^2) (by fun_prop)
(norm_le_quadratic _ (Real.sqrt_pos.mpr (by positivity))) gaussian)
@[simp] lemma multiplier_apply (b : ℝ) (hb : 0 < b) (x : V) :
multiplier b hb x = (Real.exp (-b*‖x‖^4) : ℂ) := by
change (Real.exp (-((Real.sqrt (2*b)*‖x‖^2)^2/2)) : ℂ) = _
congr 2
rw [mul_pow, Real.sq_sqrt (by positivity)]
ring
variable [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
open Real FourierTransform
def heatKernel (θ : ℝ) (hθ : 0 < θ) : SchwartzMap V ℂ :=
𝓕⁻ (multiplier (V := V) ((2*Real.pi)^4*θ) (by positivity))
lemma fourier_heatKernel (θ : ℝ) (hθ : 0 < θ) :
𝓕 (heatKernel (V := V) θ hθ) = multiplier ((2*Real.pi)^4*θ) (by positivity) := by
exact fourier_fourierInv_eq (multiplier (V := V) ((2*Real.pi)^4*θ) (by positivity))
lemma integral_heatKernel (θ : ℝ) (hθ : 0 < θ) :
∫ x : V, heatKernel θ hθ x = 1 := by
have h := congrArg (fun f : SchwartzMap V ℂ => f 0) (fourier_heatKernel (V := V) θ hθ)
simpa [SchwartzMap.fourier_coe, Real.fourier_eq, multiplier_apply] using h
lemma heatKernel_decay (θ : ℝ) (hθ : 0 < θ) (N j : ℕ) :
∃ C : ℝ, 0 ≤ C ∧ ∀ x : V,
‖iteratedFDeriv ℝ j (heatKernel (V := V) θ hθ) x‖ ≤ C/(1+‖x‖)^N := by
let C := 2^N * (Finset.Iic (N,j)).sup (fun m => SchwartzMap.seminorm ℝ m.1 m.2)
(heatKernel (V := V) θ hθ)
refine ⟨C,by positivity,fun x => ?_⟩
apply (le_div_iff₀ (by positivity)).mpr
rw [mul_comm]
exact SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) (m := (N,j))
le_rfl le_rfl (heatKernel (V := V) θ hθ) x
lemma heatKernel_invariant (θ : ℝ) (hθ : 0 < θ) (A : V ≃ₗᵢ[ℝ] V) (x : V) :
heatKernel θ hθ (A x) = heatKernel θ hθ x := by
have hm : (fun y : V => multiplier ((2*Real.pi)^4*θ) (by positivity) (A y)) =
(multiplier ((2*Real.pi)^4*θ) (by positivity) : V → ℂ) := by
ext y
simp
unfold heatKernel
rw [SchwartzMap.fourierInv_coe, Real.fourierInv_eq_fourier_neg,
← map_neg A, ← Real.fourier_comp_linearIsometry, Function.comp_def, hm,
← Real.fourierInv_eq_fourier_neg]
open scoped RealInnerProductSpace Real
lemma fourierInv_comp_smul (f : V → ℂ) (r : ℝ) (hr : 0 < r) (x : V) :
𝓕⁻ (fun ξ => f (r • ξ)) x = (r ^ Module.finrank ℝ V)⁻¹ • 𝓕⁻ f (r⁻¹ • x) := by
rw [Real.fourierInv_eq, Real.fourierInv_eq]
convert Measure.integral_comp_smul_of_nonneg volume
(fun ξ : V => Real.fourierChar ⟪ξ,r⁻¹ • x⟫ • f ξ) r (hR := hr.le) using 1
congr 1
ext ξ
simp only [real_inner_smul_left, real_inner_smul_right]
rw [← mul_assoc, inv_mul_cancel₀ hr.ne', one_mul]
lemma heatKernel_scaling (θ : ℝ) (hθ : 0 < θ) (r : ℝ) (hr : 0 < r) (x : V) :
heatKernel (r^4*θ) (by positivity) x =
(r ^ Module.finrank ℝ V)⁻¹ • heatKernel θ hθ (r⁻¹ • x) := by
have hm : (multiplier (V := V) ((2*Real.pi)^4*(r^4*θ)) (by positivity) : V → ℂ) =
fun ξ => multiplier ((2*Real.pi)^4*θ) (by positivity) (r • ξ) := by
ext ξ
simp only [multiplier_apply, norm_smul, Real.norm_eq_abs, abs_of_pos hr]
congr 2
ring
simp only [heatKernel, SchwartzMap.fourierInv_coe, hm]
exact fourierInv_comp_smul _ _ hr _
lemma heatKernel_deriv_scaling (θ : ℝ) (hθ : 0 < θ) (r : ℝ) (hr : 0 < r)
(j : ℕ) (x : V) :
iteratedFDeriv ℝ j (heatKernel (V := V) (r^4*θ) (by positivity)) x =
((r ^ Module.finrank ℝ V)⁻¹ * (r⁻¹)^j) •
iteratedFDeriv ℝ j (heatKernel θ hθ) (r⁻¹ • x) := by
have he : (heatKernel (V := V) (r^4*θ) (by positivity) : V → ℂ) =
fun y => (r ^ Module.finrank ℝ V)⁻¹ • heatKernel θ hθ (r⁻¹ • y) := by
ext y
exact heatKernel_scaling θ hθ r hr y
rw [he, iteratedFDeriv_const_smul_apply']
· rw [iteratedFDeriv_comp_const_smul r⁻¹ ((heatKernel θ hθ).smooth j), smul_smul]
· exact (((heatKernel θ hθ).smooth j).comp (by fun_prop)).contDiffAt
lemma heatKernel_scaled_decay (N j : ℕ) :
∃ C : ℝ, 0 ≤ C ∧ ∀ r : ℝ, ∀ hr : 0 < r, ∀ x : V,
‖iteratedFDeriv ℝ j (heatKernel (V := V) (r^4) (by positivity)) x‖ ≤
C / r^(Module.finrank ℝ V+j) / (1+‖x‖/r)^N := by
obtain ⟨C,hC,hdec⟩ := heatKernel_decay (V := V) 1 zero_lt_one N j
refine ⟨C,hC,fun r hr x => ?_⟩
have hid := heatKernel_deriv_scaling (V := V) 1 zero_lt_one r hr j x
simp only [mul_one] at hid
rw [hid, norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
have hd := hdec (r⁻¹ • x)
simp only [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hr)] at hd
calc
_ ≤ ((r ^ Module.finrank ℝ V)⁻¹ * r⁻¹^j) * (C/(1+r⁻¹*‖x‖)^N) := by gcongr
_ = _ := by rw [pow_add, inv_pow]; field_simp
def symbol (x : V) : ℝ := (2*Real.pi)^4 * ‖x‖^4
omit [InnerProductSpace ℝ V] [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
lemma symbol_nonneg (x : V) : 0 ≤ symbol x := by unfold symbol; positivity
omit [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
lemma symbol_temperate : Function.HasTemperateGrowth (symbol (V := V)) := by
have he : symbol (V := V) = fun x : V => (2*Real.pi)^4 * (‖x‖^2)^2 := by
ext x
unfold symbol
ring
rw [he]
fun_prop
def kernel (t : ℝ) (x : V) : ℂ :=
𝓕⁻ (fun ξ : V => (Real.exp (-t*symbol ξ) : ℂ)) x
lemma heatKernel_eq_kernel (t : ℝ) (ht : 0 < t) :
(heatKernel (V := V) t ht : V → ℂ) = kernel t := by
simp only [heatKernel, SchwartzMap.fourierInv_coe]
congr 1
ext ξ
simp only [multiplier_apply, symbol]
congr 2
ring
lemma kernel_hasDerivAt (t : ℝ) (ht : 0 < t) (x : V) :
HasDerivAt (fun s => kernel s x)
(𝓕⁻ (fun ξ : V => (-symbol ξ) • (Real.exp (-t*symbol ξ) : ℂ)) x) t := by
let F := fun s : ℝ => fun ξ : V => Real.fourierChar ⟪ξ,x⟫ • (Real.exp (-s*symbol ξ) : ℂ)
let F' := fun s : ℝ => fun ξ : V =>
Real.fourierChar ⟪ξ,x⟫ • ((-symbol ξ) • (Real.exp (-s*symbol ξ) : ℂ))
let W := SchwartzMap.smulLeftCLM ℂ (symbol (V := V))
(multiplier (V := V) ((2*Real.pi)^4*(t/2)) (by positivity))
have hW (ξ : V) : ‖W ξ‖ = symbol ξ * Real.exp (-(t/2)*symbol ξ) := by
simp only [W, SchwartzMap.smulLeftCLM_apply_apply symbol_temperate,
multiplier_apply, norm_smul, Complex.norm_real, Real.norm_eq_abs,
abs_of_nonneg (symbol_nonneg ξ), abs_of_pos (Real.exp_pos _)]
congr 2
unfold symbol
ring
have htemp : Continuous (symbol (V := V)) := symbol_temperate.1.continuous
have hFi : Integrable (F t) := by
have hm : (fun ξ => (Real.exp (-t*symbol ξ) : ℂ)) =
(multiplier (V := V) ((2*Real.pi)^4*t) (by positivity) : V → ℂ) := by
ext ξ
rw [multiplier_apply]
congr 2
unfold symbol
ring
have hi : Integrable (multiplier (V := V) ((2*Real.pi)^4*t) (by positivity)) volume :=
(multiplier (V := V) ((2*Real.pi)^4*t) (by positivity)).integrable
convert (Real.fourierIntegral_convergent_iff (-x)).mpr hi using 1
ext ξ
rw [← congrFun hm ξ]
simp only [F, inner_neg_right, neg_neg]
have hder : ∀ ξ : V, ∀ s : ℝ, HasDerivAt (fun u => F u ξ) (F' s ξ) s := by
intro ξ s
have h : HasDerivAt (fun u : ℝ => (Real.exp (-u*symbol ξ) : ℂ))
((-symbol ξ) • (Real.exp (-s*symbol ξ) : ℂ)) s := by
convert (((hasDerivAt_id s).neg.mul_const (symbol ξ)).exp).ofReal_comp using 1 <;>
simp [Complex.real_smul, mul_comm]
simpa only [F, F'] using h.fun_const_smul (Real.fourierChar ⟪ξ,x⟫)
have hh := hasDerivAt_integral_of_dominated_loc_of_deriv_le
(F := F) (F' := F') (bound := fun ξ : V => ‖W ξ‖)
(s := Ioi (t/2)) (Ioi_mem_nhds (show t/2 < t by linarith))
(Filter.Eventually.of_forall (fun s =>
(show Continuous (F s) by dsimp [F]; fun_prop).aestronglyMeasurable)) hFi
(show AEStronglyMeasurable (F' t) volume from
(show Continuous (F' t) by dsimp [F']; fun_prop).aestronglyMeasurable)
(Filter.Eventually.of_forall (fun ξ s hs => by
change ‖Real.fourierChar ⟪ξ,x⟫ • ((-symbol ξ) •
(Real.exp (-s*symbol ξ) : ℂ))‖ ≤ ‖W ξ‖
simp only [Circle.norm_smul, norm_smul, Complex.norm_real, Real.norm_eq_abs,
abs_neg, abs_of_nonneg (symbol_nonneg ξ), abs_of_pos (Real.exp_pos _), hW]
apply mul_le_mul_of_nonneg_left _ (symbol_nonneg ξ)
apply Real.exp_le_exp.mpr
have hs' : t/2 ≤ s := hs.le
nlinarith [symbol_nonneg ξ])) W.integrable.norm
(Filter.Eventually.of_forall (fun ξ s _ => hder ξ s))
simpa only [kernel, Real.fourierInv_eq, F, F'] using hh.2
open Laplacian
lemma biharmonic_eq_fourierMultiplier (f : SchwartzMap V ℂ) :
Δ (Δ f) = SchwartzMap.fourierMultiplierCLM ℂ (symbol (V := V)) f := by
have hg : Function.HasTemperateGrowth (fun ξ : V => ‖ξ‖^2) := by fun_prop
rw [SchwartzMap.laplacian_eq_fourierMultiplierCLM (Δ f),
SchwartzMap.laplacian_eq_fourierMultiplierCLM f, map_smul, smul_smul,
SchwartzMap.fourierMultiplierCLM_fourierMultiplierCLM_apply hg hg]
have he : symbol (V := V) =
((-(2*Real.pi)^2)* (-(2*Real.pi)^2)) •
((fun ξ : V => ‖ξ‖^2) * (fun ξ : V => ‖ξ‖^2)) := by
ext ξ
simp only [symbol, Pi.smul_apply, Pi.mul_apply, smul_eq_mul]
ring
rw [he, SchwartzMap.fourierMultiplierCLM_smul (hg.mul hg)]
rfl
lemma kernel_heat_equation (t : ℝ) (ht : 0 < t) (x : V) :
HasDerivAt (fun s => kernel s x) (-((Δ (Δ (heatKernel (V := V) t ht))) x)) t := by
have hd := kernel_hasDerivAt t ht x
have he : (fun ξ : V => (-symbol ξ) • (Real.exp (-t*symbol ξ) : ℂ)) =
((-SchwartzMap.smulLeftCLM ℂ (symbol (V := V))
(multiplier (V := V) ((2*Real.pi)^4*t) (by positivity)) : SchwartzMap V ℂ) : V → ℂ) := by
ext ξ
simp only [neg_apply, SchwartzMap.smulLeftCLM_apply_apply symbol_temperate,
multiplier_apply, neg_smul]
congr 2
congr 1
unfold symbol
ring_nf
rw [he, ← SchwartzMap.fourierInv_coe, FourierTransform.fourierInv_neg] at hd
rw [biharmonic_eq_fourierMultiplier, SchwartzMap.fourierMultiplierCLM_apply,
fourier_heatKernel]
exact hd
lemma kernel_eq_scaled (t : ℝ) (ht : 0 < t) (x : V) :
kernel t x = ((Real.sqrt (Real.sqrt t)) ^ Module.finrank ℝ V)⁻¹ •
heatKernel 1 zero_lt_one ((Real.sqrt (Real.sqrt t))⁻¹ • x) := by
have hr : 0 < Real.sqrt (Real.sqrt t) := Real.sqrt_pos.mpr (Real.sqrt_pos.mpr ht)
have he : (Real.sqrt (Real.sqrt t))^4 = t := by
calc
_ = ((Real.sqrt (Real.sqrt t))^2)^2 := by ring
_ = t := by rw [Real.sq_sqrt (Real.sqrt_nonneg t), Real.sq_sqrt ht.le]
have hs := heatKernel_scaling (V := V) 1 zero_lt_one _ hr x
simp only [mul_one, he] at hs
rw [← heatKernel_eq_kernel t ht]
exact hs
lemma kernel_contDiffAt (q : ℝ × V) (hq : 0 < q.1) :
ContDiffAt ℝ ∞ (fun p : ℝ × V => kernel p.1 p.2) q := by
have hr : ContDiffAt ℝ ∞ (fun p : ℝ × V => Real.sqrt (Real.sqrt p.1)) q :=
(contDiffAt_fst.sqrt (ne_of_gt hq)).sqrt (ne_of_gt (Real.sqrt_pos.mpr hq))
have hpos : 0 < Real.sqrt (Real.sqrt q.1) := Real.sqrt_pos.mpr (Real.sqrt_pos.mpr hq)
have hs : ContDiffAt ℝ ∞ (fun p : ℝ × V =>
((Real.sqrt (Real.sqrt p.1)) ^ Module.finrank ℝ V)⁻¹ •
heatKernel 1 zero_lt_one ((Real.sqrt (Real.sqrt p.1))⁻¹ • p.2)) q :=
((hr.pow _).inv (pow_ne_zero _ hpos.ne')).smul
(((heatKernel (V := V) 1 zero_lt_one).smooth ⊤).contDiffAt.comp q
((hr.inv hpos.ne').smul contDiffAt_snd))
apply hs.congr_of_eventuallyEq
filter_upwards [continuous_fst.continuousAt.eventually (Ioi_mem_nhds hq)] with p hp
exact kernel_eq_scaled _ hp _
lemma integral_norm_heatKernel (t : ℝ) (ht : 0 < t) :
∫ x : V, ‖heatKernel t ht x‖ = ∫ x : V, ‖heatKernel 1 zero_lt_one x‖ := by
let r := Real.sqrt (Real.sqrt t)
have hr : 0 < r := Real.sqrt_pos.mpr (Real.sqrt_pos.mpr ht)
have he : (fun x : V => ‖heatKernel t ht x‖) =
fun x => (r ^ Module.finrank ℝ V)⁻¹ * ‖heatKernel 1 zero_lt_one (r⁻¹ • x)‖ := by
ext x
rw [congrFun (heatKernel_eq_kernel t ht) x, kernel_eq_scaled t ht x,
norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
rw [he, integral_const_mul,
MeasureTheory.Measure.integral_comp_inv_smul_of_nonneg volume
(fun x : V => ‖heatKernel 1 zero_lt_one x‖) hr.le]
simp [hr.ne']
end BiharmonicKernel
open scoped Topology ZeroAtInfty
open Set Filter MeasureTheory
namespace C0Convolution
variable {V : Type*} [NormedAddCommGroup V]
def translate (y : V) (f : C₀(V, ℂ)) : C₀(V, ℂ) :=
f.comp (Homeomorph.subRight y).toCocompactMap
@[simp] lemma translate_apply (y : V) (f : C₀(V, ℂ)) (x : V) :
translate y f x = f (x-y) := rfl
@[simp] lemma translate_zero (f : C₀(V, ℂ)) : translate 0 f = f := by
ext x
simp
@[simp] lemma translate_add (y : V) (f g : C₀(V, ℂ)) :
translate y (f+g) = translate y f + translate y g := rfl
@[simp] lemma translate_smul (y : V) (c : ℂ) (f : C₀(V, ℂ)) :
translate y (c • f) = c • translate y f := rfl
lemma norm_le_iff (f : C₀(V, ℂ)) {C : ℝ} (hC : 0 ≤ C) :
‖f‖ ≤ C ↔ ∀ x : V, ‖f x‖ ≤ C :=
BoundedContinuousFunction.norm_le hC
lemma apply_norm_le (f : C₀(V, ℂ)) (x : V) : ‖f x‖ ≤ ‖f‖ :=
f.toBCF.norm_coe_le_norm x
@[simp] lemma norm_translate (y : V) (f : C₀(V, ℂ)) : ‖translate y f‖ = ‖f‖ := by
apply le_antisymm
· exact (norm_le_iff _ (norm_nonneg _)).mpr (fun x => apply_norm_le f (x-y))
· apply (norm_le_iff _ (norm_nonneg _)).mpr
intro x
simpa using apply_norm_le (translate y f) (x+y)
lemma continuous_translate (f : C₀(V, ℂ)) : Continuous (fun y : V => translate y f) := by
apply continuous_iff_continuousAt.mpr
intro y
apply Metric.continuousAt_iff.mpr
intro ε hε
obtain ⟨δ,hδ,hf⟩ := Metric.uniformContinuous_iff.mp (ZeroAtInftyContinuousMap.uniformContinuous f) (ε/2) (by positivity)
refine ⟨δ,hδ,fun z hz => ?_⟩
apply lt_of_le_of_lt _ (show ε/2 < ε by linarith)
change dist (translate z f).toBCF (translate y f).toBCF ≤ ε/2
apply (BoundedContinuousFunction.dist_le (by positivity)).mpr
intro x
change dist (f (x-z)) (f (x-y)) ≤ ε/2
apply (hf ?_).le
simpa only [dist_sub_left] using hz
def eval (x : V) : C₀(V, ℂ) →L[ℂ] ℂ :=
LinearMap.mkContinuous
{ toFun := fun f => f x
map_add' := fun _ _ => rfl
map_smul' := fun _ _ => rfl }
1 (fun f => by simpa using apply_norm_le f x)
@[simp] lemma eval_apply (x : V) (f : C₀(V, ℂ)) : eval x f = f x := rfl
variable [MeasureSpace V] [BorelSpace V] [SecondCountableTopology V]
lemma integrable_translated (k : V → ℂ) (hk : Integrable k) (f : C₀(V, ℂ)) :
Integrable (fun y : V => k y • translate y f) := by
apply (hk.norm.mul_const ‖f‖).mono'
· exact hk.aestronglyMeasurable.smul (continuous_translate f).aestronglyMeasurable
· filter_upwards with y
simp only [norm_smul, norm_translate, le_refl]
def convolve (k : V → ℂ) (f : C₀(V, ℂ)) : C₀(V, ℂ) :=
∫ y : V, k y • translate y f
lemma convolve_apply (k : V → ℂ) (hk : Integrable k) (f : C₀(V, ℂ)) (x : V) :
convolve k f x = ∫ y : V, k y * f (x-y) := by
have h := (eval x).integral_comp_comm (integrable_translated k hk f)
simpa [convolve] using h.symm
omit [BorelSpace V] [SecondCountableTopology V] in
lemma norm_convolve_le (k : V → ℂ) (f : C₀(V, ℂ)) :
‖convolve k f‖ ≤ (∫ y : V, ‖k y‖) * ‖f‖ := by
calc
_ ≤ ∫ y : V, ‖k y • translate y f‖ := norm_integral_le_integral_norm _
_ = _ := by simp only [norm_smul, norm_translate, integral_mul_const]
lemma convolve_add (k : V → ℂ) (hk : Integrable k) (f g : C₀(V, ℂ)) :
convolve k (f+g) = convolve k f + convolve k g := by
have he (y : V) : k y • translate y (f+g) =
k y • translate y f + k y • translate y g := by
ext x
exact mul_add (k y) (f (x-y)) (g (x-y))
simp only [convolve, he]
exact integral_add (integrable_translated k hk f) (integrable_translated k hk g)
omit [BorelSpace V] [SecondCountableTopology V] in
lemma convolve_smul (k : V → ℂ) (c : ℂ) (f : C₀(V, ℂ)) :
convolve k (c • f) = c • convolve k f := by
simp only [convolve, translate_smul, smul_comm (k _) c, integral_smul]
def convolveCLM (k : V → ℂ) (hk : Integrable k) : C₀(V, ℂ) →L[ℂ] C₀(V, ℂ) :=
LinearMap.mkContinuous
{ toFun := convolve k
map_add' := convolve_add k hk
map_smul' := convolve_smul k }
(∫ y : V, ‖k y‖) (norm_convolve_le k)
lemma norm_convolveCLM_le (k : V → ℂ) (hk : Integrable k) :
‖convolveCLM k hk‖ ≤ ∫ y : V, ‖k y‖ := by
exact LinearMap.mkContinuous_norm_le _ (integral_nonneg (fun _ => norm_nonneg _)) _
variable [NormedSpace ℝ V]
lemma integrable_scaled_translated (k : V → ℂ) (hk : Integrable k)
(r : ℝ) (f : C₀(V, ℂ)) :
Integrable (fun y : V => k y • translate (r • y) f) := by
apply (hk.norm.mul_const ‖f‖).mono'
· exact hk.aestronglyMeasurable.smul
((continuous_translate f).comp (continuous_const.smul continuous_id)).aestronglyMeasurable
· filter_upwards with y
simp only [norm_smul, norm_translate, le_refl]
def scaleConvolve (k : V → ℂ) (r : ℝ) (f : C₀(V, ℂ)) : C₀(V, ℂ) :=
∫ y : V, k y • translate (r • y) f
lemma continuous_scaleConvolve (k : V → ℂ) (hk : Integrable k) (f : C₀(V, ℂ)) :
Continuous (fun r : ℝ => scaleConvolve k r f) := by
apply continuous_of_dominated (bound := fun y => ‖k y‖ * ‖f‖)
· exact fun r => (integrable_scaled_translated k hk r f).aestronglyMeasurable
· intro r
filter_upwards with y
simp only [norm_smul, norm_translate, le_refl]
· exact hk.norm.mul_const ‖f‖
· filter_upwards with y
exact (continuous_const : Continuous (fun _ : ℝ => k y)).smul
((continuous_translate f).comp
(continuous_id.smul (continuous_const : Continuous (fun _ : ℝ => y))))
omit [BorelSpace V] [SecondCountableTopology V] in
lemma scaleConvolve_zero (k : V → ℂ) (f : C₀(V, ℂ)) :
scaleConvolve k 0 f = (∫ y : V, k y) • f := by
simp only [scaleConvolve, zero_smul, translate_zero, integral_smul_const]
lemma scaleConvolve_tendsto (k : V → ℂ) (hk : Integrable k)
(hmass : ∫ y : V, k y = 1) (f : C₀(V, ℂ)) :
Tendsto (fun r : ℝ => scaleConvolve k r f) (𝓝 0) (𝓝 f) := by
simpa only [scaleConvolve_zero, hmass, one_smul] using
(continuous_scaleConvolve k hk f).tendsto 0
variable [FiniteDimensional ℝ V] [Measure.IsAddHaarMeasure (volume : Measure V)]
omit [SecondCountableTopology V] in
lemma convolve_scaled (k : V → ℂ) (r : ℝ) (hr : 0 < r) (f : C₀(V, ℂ)) :
convolve (fun y : V => (r ^ Module.finrank ℝ V)⁻¹ • k (r⁻¹ • y)) f =
scaleConvolve k r f := by
have he (y : V) :
((r ^ Module.finrank ℝ V)⁻¹ • k (r⁻¹ • y)) • translate y f =
(r ^ Module.finrank ℝ V)⁻¹ •
(k (r⁻¹ • y) • translate (r • (r⁻¹ • y)) f) := by
rw [smul_inv_smul₀ hr.ne']
ext x
exact smul_mul_assoc _ _ _
simp only [convolve, he, integral_smul]
rw [Measure.integral_comp_inv_smul_of_nonneg volume
(fun y : V => k y • translate (r • y) f) hr.le]
rw [inv_smul_smul₀ (pow_ne_zero _ hr.ne')]
rfl
open scoped Convolution
omit [NormedSpace ℝ V] [FiniteDimensional ℝ V]
[Measure.IsAddHaarMeasure (volume : Measure V)] in
lemma convolve_coe (k : V → ℂ) (hk : Integrable k) (f : C₀(V, ℂ)) :
(convolve k f : V → ℂ) = k ⋆[ContinuousLinearMap.mul ℂ ℂ] (f : V → ℂ) := by
ext x
exact convolve_apply k hk f x
lemma convolve_assoc (k l : V → ℂ) (hk : Integrable k) (hl : Integrable l)
(hkc : Continuous k) (hlc : Continuous l) (f : C₀(V, ℂ)) :
convolve (k ⋆[ContinuousLinearMap.mul ℂ ℂ] l) f = convolve k (convolve l f) := by
apply DFunLike.coe_injective
rw [convolve_coe _ (hk.integrable_convolution _ hl) f,
convolve_coe k hk, convolve_coe l hl]
ext x
apply convolution_assoc' (ContinuousLinearMap.mul ℂ ℂ)
(ContinuousLinearMap.mul ℂ ℂ) (ContinuousLinearMap.mul ℂ ℂ)
(ContinuousLinearMap.mul ℂ ℂ) (fun _ _ _ => mul_assoc _ _ _)
(hk.ae_convolution_exists _ hl)
· filter_upwards with z
change Integrable (fun y => l y * f (z-y))
exact (eval z).integrable_comp (integrable_translated l hl f)
· apply ((hk.convolution_integrand (ContinuousLinearMap.mul ℂ ℂ) hl).norm.mul_const ‖f‖).mono'
· exact (show Continuous (fun p : V × V => k p.2 * (l (p.1-p.2) * f (x-p.1))) by
fun_prop).aestronglyMeasurable
· filter_upwards with p
simp only [Function.uncurry, ContinuousLinearMap.mul_apply', norm_mul]
calc
_ = (‖k p.2‖ * ‖l (p.1-p.2)‖) * ‖f (x-p.1)‖ := by ring
_ ≤ _ := mul_le_mul_of_nonneg_left (apply_norm_le f _) (by positivity)
end C0Convolution
namespace BiharmonicKernel
open scoped FourierTransform ZeroAtInfty
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma heatKernel_semigroup (s t : ℝ) (hs : 0 < s) (ht : 0 < t) :
SchwartzMap.convolution (ContinuousLinearMap.mul ℂ ℂ)
(heatKernel (V := V) s hs) (heatKernel t ht) =
heatKernel (s+t) (by positivity) := by
apply (FourierTransform.fourierEquiv ℂ (SchwartzMap V ℂ)).injective
ext ξ
simp only [FourierTransform.fourierEquiv_apply, SchwartzMap.fourier_convolution,
fourier_heatKernel, SchwartzMap.pairing_apply_apply,
ContinuousLinearMap.mul_apply', multiplier_apply]
rw [← Complex.ofReal_mul, ← Real.exp_add]
congr 2
ring
def evolution (t : ℝ) (f : C₀(V, ℂ)) : C₀(V, ℂ) :=
C0Convolution.scaleConvolve (heatKernel 1 zero_lt_one)
(Real.sqrt (Real.sqrt t)) f
lemma evolution_zero (f : C₀(V, ℂ)) : evolution 0 f = f := by
simp only [evolution, Real.sqrt_zero, C0Convolution.scaleConvolve_zero,
integral_heatKernel, one_smul]
lemma evolution_continuous (f : C₀(V, ℂ)) : Continuous (fun t : ℝ => evolution t f) := by
exact (C0Convolution.continuous_scaleConvolve
(heatKernel 1 zero_lt_one) (heatKernel (V := V) 1 zero_lt_one).integrable f).comp
(Real.continuous_sqrt.comp Real.continuous_sqrt)
lemma evolution_initial_trace (f : C₀(V, ℂ)) :
Tendsto (fun t : ℝ => evolution t f) (𝓝[>] 0) (𝓝 f) := by
simpa only [ContinuousWithinAt, evolution_zero] using ((evolution_continuous f).continuousAt (x := 0)).continuousWithinAt (s := Ioi 0)
lemma evolution_eq_convolve (t : ℝ) (ht : 0 < t) (f : C₀(V, ℂ)) :
evolution t f = C0Convolution.convolve (heatKernel t ht) f := by
have he : (heatKernel (V := V) t ht : V → ℂ) =
fun x => ((Real.sqrt (Real.sqrt t)) ^ Module.finrank ℝ V)⁻¹ •
heatKernel 1 zero_lt_one ((Real.sqrt (Real.sqrt t))⁻¹ • x) := by
ext x
rw [congrFun (heatKernel_eq_kernel t ht) x, kernel_eq_scaled t ht x]
rw [he, C0Convolution.convolve_scaled _ _
(Real.sqrt_pos.mpr (Real.sqrt_pos.mpr ht))]
rfl
lemma evolution_apply (t : ℝ) (ht : 0 < t) (f : C₀(V, ℂ)) (x : V) :
evolution t f x = ∫ y : V, heatKernel t ht y * f (x-y) := by
rw [evolution_eq_convolve t ht f,
C0Convolution.convolve_apply _ (heatKernel t ht).integrable]
lemma evolution_norm_le (t : ℝ) (ht : 0 < t) (f : C₀(V, ℂ)) :
‖evolution t f‖ ≤ (∫ x : V, ‖heatKernel 1 zero_lt_one x‖) * ‖f‖ := by
rw [evolution_eq_convolve t ht f]
simpa only [integral_norm_heatKernel] using
C0Convolution.norm_convolve_le (heatKernel t ht) f
open scoped Convolution
lemma evolution_semigroup (s t : ℝ) (hs : 0 < s) (ht : 0 < t) (f : C₀(V, ℂ)) :
evolution (s+t) f = evolution s (evolution t f) := by
rw [evolution_eq_convolve _ (add_pos hs ht), evolution_eq_convolve s hs,
evolution_eq_convolve t ht,
← C0Convolution.convolve_assoc _ _ (heatKernel s hs).integrable
(heatKernel t ht).integrable (heatKernel s hs).continuous (heatKernel t ht).continuous]
congr 1
ext x
have he := congrArg (fun h : SchwartzMap V ℂ => h x) (heatKernel_semigroup s t hs ht)
rw [SchwartzMap.convolution_apply] at he
exact he.symm
end BiharmonicKernel
open scoped SchwartzMap Topology ZeroAtInfty Convolution ContDiff BoundedContinuousFunction
open Set Filter MeasureTheory
namespace SchwartzConvolution
section ShiftedMajorant
universe u
variable {V E F A : Type u} [NormedAddCommGroup V] [NormedSpace ℝ V]
[FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)]
[NormedAddCommGroup E] [NormedSpace ℝ E]
[NormedAddCommGroup F] [NormedSpace ℝ F]
lemma shifted_majorant (g : SchwartzMap V E) (x₀ : V) :
∃ b : V → ℝ, Integrable b ∧ ∀ x ∈ Metric.ball x₀ 1, ∀ y,
‖g (x-y)‖ ≤ b y := by
let N := Module.finrank ℝ V + 1
let C := 2^N * (Finset.Iic (N,0)).sup (fun i => SchwartzMap.seminorm ℝ i.1 i.2) g
have hC : 0 ≤ C := by positivity
have hdec (z : V) : (1+‖z‖)^N * ‖g z‖ ≤ C := by
simpa only [norm_iteratedFDeriv_zero] using
SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) (m := (N,0))
le_rfl le_rfl g z
refine ⟨fun y => (2^N*C)/(1+‖x₀-y‖)^N, ?_, ?_⟩
· have hi : Integrable (fun z : V => (1+‖z‖) ^ (-(N : ℝ))) :=
integrable_one_add_norm (by dsimp [N]; norm_num)
simpa only [Real.rpow_neg (by positivity : (0:ℝ) ≤ 1+‖x₀-_‖),
Real.rpow_natCast, div_eq_mul_inv] using (hi.comp_sub_left x₀).const_mul (2^N*C)
· intro x hx y
have hd : ‖x₀-x‖ < 1 := by simpa only [Metric.mem_ball, dist_eq_norm, norm_sub_rev] using hx
have hn : ‖x₀-y‖ ≤ ‖x₀-x‖ + ‖x-y‖ := by simpa only [sub_add_sub_cancel] using norm_add_le (x₀-x) (x-y)
have hs : 1+‖x₀-y‖ ≤ 2*(1+‖x-y‖) := by nlinarith [norm_nonneg (x-y)]
apply (le_div_iff₀ (by positivity)).mpr
calc
‖g (x-y)‖ * (1+‖x₀-y‖)^N ≤ ‖g (x-y)‖ * (2*(1+‖x-y‖))^N := by gcongr
_ = 2^N * ((1+‖x-y‖)^N * ‖g (x-y)‖) := by rw [mul_pow]; ring
_ ≤ _ := mul_le_mul_of_nonneg_left (hdec (x-y)) (by positivity)
variable [NormedAddCommGroup A] [NormedSpace ℝ A]
lemma integrable_integrand (L : A →L[ℝ] E →L[ℝ] F)
(f : V →ᵇ A) (g : SchwartzMap V E) (x : V) :
Integrable (fun y => L (f y) (g (x-y))) := by
refine ((g.integrable.norm.comp_sub_left x).const_mul (‖L‖*‖f‖)).mono'
(f.continuous.aestronglyMeasurable.convolution_integrand_snd L
g.continuous.aestronglyMeasurable x) (Eventually.of_forall fun y => ?_)
exact (L.le_opNorm₂ (f y) (g (x-y))).trans (by
gcongr
exact f.norm_coe_le_norm y)
lemma hasFDerivAt_convolution (L : A →L[ℝ] E →L[ℝ] F)
(f : V →ᵇ A) (g : SchwartzMap V E) (x₀ : V) :
HasFDerivAt (f ⋆[L] g)
((f ⋆[L.precompR V] SchwartzMap.fderivCLM ℝ V E g) x₀) x₀ := by
let g' := SchwartzMap.fderivCLM ℝ V E g
obtain ⟨b, hb, hbound⟩ := shifted_majorant g' x₀
have hderiv (x y : V) : HasFDerivAt (fun x => g (x-y)) (g' (x-y)) x := by
simpa [g', SchwartzMap.fderivCLM_apply, Function.comp_def, Pi.sub_apply] using
(g.hasFDerivAt (x-y)).comp x ((hasFDerivAt_id x).sub (hasFDerivAt_const y x))
apply hasFDerivAt_integral_of_dominated_of_fderiv_le
(Metric.ball_mem_nhds x₀ zero_lt_one)
· exact Eventually.of_forall fun x => (integrable_integrand L f g x).aestronglyMeasurable
· exact integrable_integrand L f g x₀
· exact (integrable_integrand (L.precompR V) f g' x₀).aestronglyMeasurable
· filter_upwards with y x hx
change ‖(L (f y)).comp (g' (x-y))‖ ≤ _
calc
‖(L (f y)).comp (g' (x-y))‖ ≤ ‖L (f y)‖ * ‖g' (x-y)‖ := ContinuousLinearMap.opNorm_comp_le _ _
_ ≤ (‖L‖ * ‖f‖) * ‖g' (x-y)‖ := by
gcongr
exact (L.le_opNorm (f y)).trans (mul_le_mul_of_nonneg_left (f.norm_coe_le_norm y) (norm_nonneg L))
_ ≤ (‖L‖ * ‖f‖) * b y := mul_le_mul_of_nonneg_left (hbound x hx y) (by positivity)
· exact hb.const_mul (‖L‖ * ‖f‖)
· filter_upwards with y x _
exact (L (f y)).hasFDerivAt.comp x (hderiv x y)
lemma contDiff_convolution_nat (n : ℕ) (L : A →L[ℝ] E →L[ℝ] F)
(f : V →ᵇ A) (g : SchwartzMap V E) :
ContDiff ℝ n (f ⋆[L] g) := by
induction n generalizing E F with
| zero =>
rw [Nat.cast_zero, contDiff_zero]
exact continuous_iff_continuousAt.mpr fun x => (hasFDerivAt_convolution L f g x).continuousAt
| succ n ih =>
rw [Nat.cast_add, Nat.cast_one, contDiff_succ_iff_hasFDerivAt]
exact ⟨f ⋆[L.precompR V] SchwartzMap.fderivCLM ℝ V E g,
ih (L.precompR V) (SchwartzMap.fderivCLM ℝ V E g), hasFDerivAt_convolution L f g⟩
lemma contDiff_convolution (L : A →L[ℝ] E →L[ℝ] F)
(f : V →ᵇ A) (g : SchwartzMap V E) :
ContDiff ℝ ∞ (f ⋆[L] g) :=
contDiff_infty.mpr fun n => contDiff_convolution_nat n L f g
lemma fderiv_convolution (L : A →L[ℝ] E →L[ℝ] F)
(f : V →ᵇ A) (g : SchwartzMap V E) :
fderiv ℝ (f ⋆[L] g) = f ⋆[L.precompR V] SchwartzMap.fderivCLM ℝ V E g := by
funext x
exact (hasFDerivAt_convolution L f g x).fderiv
lemma fderiv_convolution_apply (L : A →L[ℝ] E →L[ℝ] F)
(f : V →ᵇ A) (g : SchwartzMap V E) (x v : V) :
fderiv ℝ (f ⋆[L] g) x v = ∫ y, L (f y) (fderiv ℝ g (x-y) v) := by
rw [fderiv_convolution, MeasureTheory.convolution_def,
ContinuousLinearMap.integral_apply (integrable_integrand (L.precompR V) f
(SchwartzMap.fderivCLM ℝ V E g) x)]
rfl
lemma second_fderiv_convolution_apply (L : A →L[ℝ] E →L[ℝ] F)
(f : V →ᵇ A) (g : SchwartzMap V E) (x v w : V) :
fderiv ℝ (fderiv ℝ (f ⋆[L] g)) x v w =
∫ y, L (f y) (fderiv ℝ (fderiv ℝ g) (x-y) v w) := by
rw [fderiv_convolution, fderiv_convolution_apply]
rw [ContinuousLinearMap.integral_apply]
· rfl
· exact integrable_integrand (L.precompR V) f
(SchwartzMap.evalCLM ℝ V (V →L[ℝ] E) v
(SchwartzMap.fderivCLM ℝ V (V →L[ℝ] E) (SchwartzMap.fderivCLM ℝ V E g))) x
end ShiftedMajorant
open scoped Laplacian
universe u
variable {V E F A : Type u} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)]
[NormedAddCommGroup E] [NormedSpace ℝ E]
[NormedAddCommGroup F] [NormedSpace ℝ F]
[NormedAddCommGroup A] [NormedSpace ℝ A]
lemma laplacian_convolution (L : A →L[ℝ] E →L[ℝ] F)
(f : V →ᵇ A) (g : SchwartzMap V E) :
Δ (f ⋆[L] g) = f ⋆[L] (Δ g : SchwartzMap V E) := by
funext x
rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis]
simp only [iteratedFDeriv_two_apply, Matrix.cons_val_zero, Matrix.cons_val_one,
second_fderiv_convolution_apply]
rw [MeasureTheory.convolution_def]
simp_rw [SchwartzMap.laplacian_apply,
InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis,
iteratedFDeriv_two_apply, Matrix.cons_val_zero, Matrix.cons_val_one,
map_sum]
rw [integral_finsetSum]
· rfl
· intro i _
exact integrable_integrand L f
(SchwartzMap.evalCLM ℝ V E ((stdOrthonormalBasis ℝ V) i)
(SchwartzMap.evalCLM ℝ V (V →L[ℝ] E) ((stdOrthonormalBasis ℝ V) i)
(SchwartzMap.fderivCLM ℝ V (V →L[ℝ] E) (SchwartzMap.fderivCLM ℝ V E g)))) x
end SchwartzConvolution
open Set Filter MeasureTheory
open scoped SchwartzMap Topology
namespace SchwartzConvolution
variable {V E : Type*} [NormedAddCommGroup V] [NormedSpace ℝ V]
[FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)]
[NormedAddCommGroup E] [NormedSpace ℝ E]
lemma scaled_majorant (g : SchwartzMap V E) (a b : ℝ) (ha : 0 < a) (K : ℕ) :
∃ B : V → ℝ, Integrable B ∧ ∀ c ∈ Icc a b, ∀ x,
‖(c⁻¹)^K • g (c⁻¹ • x)‖ ≤ B x := by
let N := Module.finrank ℝ V + 1
let M := max b 1
let C := 2^N * (Finset.Iic (N,0)).sup (fun i => SchwartzMap.seminorm ℝ i.1 i.2) g
have hC : 0 ≤ C := by positivity
have hM : 0 < M := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
have hdec (z : V) : (1+‖z‖)^N * ‖g z‖ ≤ C := by
simpa only [norm_iteratedFDeriv_zero] using
SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) (m := (N,0)) le_rfl le_rfl g z
refine ⟨fun x => ((a⁻¹)^K*(M^N*C))/(1+‖x‖)^N, ?_, ?_⟩
· have hi : Integrable (fun x : V => (1+‖x‖)^(-(N : ℝ))) :=
integrable_one_add_norm (by dsimp [N]; norm_num)
simpa only [Real.rpow_neg (by positivity : (0:ℝ) ≤ 1+‖(_ : V)‖),
Real.rpow_natCast, div_eq_mul_inv] using hi.const_mul ((a⁻¹)^K*(M^N*C))
· intro c hc x
have hcpos : 0 < c := ha.trans_le hc.1
have hcM : c ≤ M := hc.2.trans (le_max_left _ _)
have hnx : ‖x‖ = c * ‖c⁻¹ • x‖ := by
rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hcpos),
← mul_assoc, mul_inv_cancel₀ hcpos.ne', one_mul]
have hs : 1+‖x‖ ≤ M*(1+‖c⁻¹ • x‖) := by
rw [hnx, mul_add, mul_one]
exact add_le_add (le_max_right b 1) (mul_le_mul_of_nonneg_right hcM (norm_nonneg _))
have hg : ‖g (c⁻¹ • x)‖ * (1+‖x‖)^N ≤ M^N*C := by
calc
_ ≤ ‖g (c⁻¹ • x)‖ * (M * (1+‖c⁻¹ • x‖))^N := by gcongr
_ = M^N * ((1+‖c⁻¹ • x‖)^N * ‖g (c⁻¹ • x)‖) := by rw [mul_pow]; ring
_ ≤ _ := mul_le_mul_of_nonneg_left (hdec _) (by positivity)
rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
apply (le_div_iff₀ (by positivity)).mpr
calc
_ = (c⁻¹)^K * (‖g (c⁻¹ • x)‖ * (1+‖x‖)^N) := by ring
_ ≤ (a⁻¹)^K * (‖g (c⁻¹ • x)‖ * (1+‖x‖)^N) := by
gcongr
exact hc.1
_ ≤ _ := mul_le_mul_of_nonneg_left hg (by positivity)
end SchwartzConvolution
namespace LaplacianScaling
open scoped Laplacian ContDiff
variable {V E : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [NormedAddCommGroup E] [NormedSpace ℝ E]
lemma laplacian_scaled (f : V → E) (hf : ContDiff ℝ 2 f) (a c : ℝ) :
Δ (fun x => a • f (c • x)) = fun x => (a*c^2) • Δ f (c • x) := by
have hs : ContDiff ℝ 2 (fun x : V => f (c • x)) := hf.comp (by fun_prop)
funext x
rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis]
simp_rw [iteratedFDeriv_const_smul_apply' hs.contDiffAt,
iteratedFDeriv_comp_const_smul c hf]
simp only [smul_apply, smul_smul, ← Finset.smul_sum,
InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis]
end LaplacianScaling
namespace BiharmonicKernel
section LaplacianKernelScaling
open scoped SchwartzMap FourierTransform ZeroAtInfty Convolution Laplacian ContDiff
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma laplacian_kernel_scaling (t : ℝ) (ht : 0 < t) (r : ℝ) (hr : 0 < r) :
((Δ (heatKernel (V := V) (r^4*t) (by positivity)) : SchwartzMap V ℂ) : V → ℂ) =
fun x => ((r ^ Module.finrank ℝ V)⁻¹ * (r⁻¹)^2) •
(Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) (r⁻¹ • x) := by
have he : (heatKernel (V := V) (r^4*t) (by positivity) : V → ℂ) =
fun x => (r ^ Module.finrank ℝ V)⁻¹ • heatKernel (V := V) t ht (r⁻¹ • x) := by
funext x
exact heatKernel_scaling t ht r hr x
have hs := LaplacianScaling.laplacian_scaled (heatKernel (V := V) t ht)
((heatKernel (V := V) t ht).smooth 2) (r ^ Module.finrank ℝ V)⁻¹ r⁻¹
funext x
simpa only [← he, ← SchwartzMap.laplacian_apply] using congrFun hs x
lemma biharmonic_kernel_scaling (t : ℝ) (ht : 0 < t) (r : ℝ) (hr : 0 < r) :
((Δ (Δ (heatKernel (V := V) (r^4*t) (by positivity)) : SchwartzMap V ℂ) : SchwartzMap V ℂ) : V → ℂ) =
fun x => (r⁻¹)^(Module.finrank ℝ V+4) •
(Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) (r⁻¹ • x) := by
have he := laplacian_kernel_scaling (V := V) t ht r hr
have hs := LaplacianScaling.laplacian_scaled ((Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : V → ℂ)
((Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ).smooth 2)
((r ^ Module.finrank ℝ V)⁻¹ * (r⁻¹)^2) r⁻¹
funext x
have hx := congrFun hs x
rw [← he] at hx
simp only [← SchwartzMap.laplacian_apply] at hx
rw [hx, inv_pow, pow_add]
congr 1
ring
lemma evolution_coe_convolution (t : ℝ) (ht : 0 < t) (f : C₀(V, ℂ)) :
(evolution t f : V → ℂ) = f.toBCF ⋆[ContinuousLinearMap.mul ℝ ℂ] heatKernel (V := V) t ht := by
funext x
rw [evolution_apply t ht, convolution_def]
rw [← integral_sub_left_eq_self (fun y : V => heatKernel (V := V) t ht y * f (x-y)) volume x]
simp only [sub_sub_self, ContinuousLinearMap.mul_apply']
congr 1
funext y
exact mul_comm _ _
lemma evolution_smooth (t : ℝ) (ht : 0 < t) (f : C₀(V, ℂ)) :
ContDiff ℝ ∞ (evolution t f : V → ℂ) := by
rw [evolution_coe_convolution t ht]
exact SchwartzConvolution.contDiff_convolution (ContinuousLinearMap.mul ℝ ℂ) f.toBCF (heatKernel (V := V) t ht)
lemma evolution_biharmonic (t : ℝ) (ht : 0 < t) (f : C₀(V, ℂ)) :
Δ (Δ (evolution t f : V → ℂ)) =
(f.toBCF ⋆[ContinuousLinearMap.mul ℝ ℂ] (Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ)) := by
rw [evolution_coe_convolution t ht, SchwartzConvolution.laplacian_convolution,
SchwartzConvolution.laplacian_convolution]
lemma kernel_deriv_majorant (t : ℝ) (ht : 0 < t) :
∃ B : V → ℝ, Integrable B ∧ ∀ s ∈ Ioo (t/2) (2*t), ∀ x : V,
‖deriv (fun u => kernel u x) s‖ ≤ B x := by
let r : ℝ → ℝ := fun s => Real.sqrt (Real.sqrt s)
let g : SchwartzMap V ℂ := Δ (Δ (heatKernel (V := V) 1 zero_lt_one) : SchwartzMap V ℂ)
have hr (s : ℝ) (hs : 0 < s) : 0 < r s :=
Real.sqrt_pos.mpr (Real.sqrt_pos.mpr hs)
have hr4 (s : ℝ) (hs : 0 < s) : r s ^ 4 = s := by
dsimp [r]
calc
_ = ((Real.sqrt (Real.sqrt s))^2)^2 := by ring
_ = s := by rw [Real.sq_sqrt (Real.sqrt_nonneg s), Real.sq_sqrt hs.le]
obtain ⟨B,hB,hbound⟩ := SchwartzConvolution.scaled_majorant g (r (t/2)) (r (2*t))
(hr _ (by positivity)) (Module.finrank ℝ V+4)
refine ⟨B,hB,fun s hs x => ?_⟩
have hspos : 0 < s := lt_trans (by positivity) hs.1
rw [(kernel_heat_equation s hspos x).deriv, norm_neg]
have he := congrFun (biharmonic_kernel_scaling (V := V) 1 zero_lt_one (r s) (hr s hspos)) x
simp only [mul_one, hr4 s hspos] at he
rw [he]
apply hbound (r s) ⟨?_, ?_⟩ x
· exact Real.sqrt_le_sqrt (Real.sqrt_le_sqrt hs.1.le)
· exact Real.sqrt_le_sqrt (Real.sqrt_le_sqrt hs.2.le)
lemma evolution_hasDerivAt (t : ℝ) (ht : 0 < t) (f : C₀(V, ℂ)) :
HasDerivAt (fun s => evolution s f)
(-C0Convolution.convolve
(Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) f) t := by
let F := fun s : ℝ => fun y : V => kernel s y • C0Convolution.translate y f
let F' := fun s : ℝ => fun y : V =>
deriv (fun u => kernel u y) s • C0Convolution.translate y f
have hK (s : ℝ) (hs : 0 < s) : kernel (V := V) s = heatKernel s hs :=
(heatKernel_eq_kernel s hs).symm
have hD (s : ℝ) (hs : 0 < s) : (fun y : V => deriv (fun u => kernel u y) s) =
(-(Δ (Δ (heatKernel (V := V) s hs) : SchwartzMap V ℂ) : SchwartzMap V ℂ) : V → ℂ) := by
funext y
exact (kernel_heat_equation s hs y).deriv
have hFi (s : ℝ) (hs : 0 < s) : Integrable (F s) := by
dsimp [F]
rw [hK s hs]
exact C0Convolution.integrable_translated _ (heatKernel s hs).integrable f
have hF'i (s : ℝ) (hs : 0 < s) : Integrable (F' s) := by
change Integrable (fun y => (fun y : V => deriv (fun u => kernel u y) s) y • _)
rw [hD s hs]
exact C0Convolution.integrable_translated _
(-(Δ (Δ (heatKernel (V := V) s hs) : SchwartzMap V ℂ) : SchwartzMap V ℂ)).integrable f
obtain ⟨B,hB,hbound⟩ := kernel_deriv_majorant (V := V) t ht
have hd := hasDerivAt_integral_of_dominated_loc_of_deriv_le
(F := F) (F' := F') (bound := fun y => B y * ‖f‖)
(s := Ioo (t/2) (2*t)) (Ioo_mem_nhds (by linarith) (by linarith))
(by
filter_upwards [Ioi_mem_nhds ht] with s hs
exact (hFi s hs).aestronglyMeasurable)
(hFi t ht) (hF'i t ht).aestronglyMeasurable
(Filter.Eventually.of_forall (fun y s hs => by
simp only [F', norm_smul, C0Convolution.norm_translate]
exact mul_le_mul_of_nonneg_right (hbound s hs y) (norm_nonneg f)))
(hB.mul_const ‖f‖)
(Filter.Eventually.of_forall (fun y s hs => by
dsimp only [F, F']
exact ((kernel_heat_equation s (lt_trans (by positivity) hs.1) y).differentiableAt.hasDerivAt).smul_const (C0Convolution.translate y f)))
have hval : (∫ y, F' t y) = -C0Convolution.convolve
(Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) f := by
change (∫ y, (fun y : V => deriv (fun u => kernel u y) t) y • _) = _
rw [hD t ht]
change (∫ y, -((Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) y) • C0Convolution.translate y f) =
-(∫ y, (Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) y • C0Convolution.translate y f)
have he (y : V) :
-((Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) y) • C0Convolution.translate y f =
-((Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) y • C0Convolution.translate y f) :=
neg_smul ((Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) y) (C0Convolution.translate y f)
simp_rw [he]
exact integral_neg _
rw [hval] at hd
apply hd.2.congr_of_eventuallyEq
filter_upwards [Ioi_mem_nhds ht] with s hs
rw [evolution_eq_convolve s hs]
change C0Convolution.convolve _ _ = ∫ y, kernel s y • _
rw [hK s hs]
rfl
lemma evolution_heat_equation (t : ℝ) (ht : 0 < t) (f : C₀(V, ℂ)) (x : V) :
HasDerivAt (fun s => evolution s f x)
(- (Δ (Δ (evolution t f : V → ℂ) : V → ℂ) : V → ℂ) x) t := by
have hd := ((C0Convolution.eval x).restrictScalars ℝ).hasFDerivAt.comp_hasDerivAt t
(evolution_hasDerivAt t ht f)
change HasDerivAt (fun s => evolution s f x)
(-C0Convolution.convolve
(Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) f x) t at hd
convert hd using 1
congr 1
rw [evolution_biharmonic, convolution_def, C0Convolution.convolve_apply _
(Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable]
rw [← integral_sub_left_eq_self
(fun y : V => (Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) y * f (x-y)) volume x]
simp only [sub_sub_self, ContinuousLinearMap.mul_apply']
congr 1
funext y
exact mul_comm _ _
end LaplacianKernelScaling
open scoped SchwartzMap ZeroAtInfty
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma kernel_majorant (a b : ℝ) (ha : 0 < a) :
∃ B : V → ℝ, Integrable B ∧ ∀ t ∈ Icc a b, ∀ x : V, ‖kernel t x‖ ≤ B x := by
let r := fun t : ℝ => Real.sqrt (Real.sqrt t)
obtain ⟨B,hB,hbound⟩ := SchwartzConvolution.scaled_majorant
(heatKernel (V := V) 1 zero_lt_one) (r a) (r b)
(Real.sqrt_pos.mpr (Real.sqrt_pos.mpr ha)) (Module.finrank ℝ V)
refine ⟨B,hB,fun t ht x => ?_⟩
rw [kernel_eq_scaled t (ha.trans_le ht.1) x, ← inv_pow]
exact hbound (r t) ⟨Real.sqrt_le_sqrt (Real.sqrt_le_sqrt ht.1),
Real.sqrt_le_sqrt (Real.sqrt_le_sqrt ht.2)⟩ x
lemma continuous_kernel_comp {X : Type*} [TopologicalSpace X]
(a : X → ℝ) (v : X → V) (ha : Continuous a) (hv : Continuous v)
(hpos : ∀ x, 0 < a x) : Continuous (fun x => kernel (a x) (v x)) := by
apply continuous_iff_continuousAt.mpr
intro x
exact ContinuousAt.comp (f := fun u => (a u,v u))
(kernel_contDiffAt (a x,v x) (hpos x)).continuousAt
(ha.continuousAt.prodMk hv.continuousAt)
end BiharmonicKernel
namespace FrozenParametrix
open scoped SchwartzMap ZeroAtInfty
open BiharmonicKernel
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
def value (a : V → ℝ) (r : ℝ) (f : C₀(V, ℂ)) (x : V) : ℂ :=
∫ y : V, kernel (a (x-r • y)) y * f (x-r • y)
lemma integrable_value (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (f : C₀(V, ℂ)) (x : V) :
Integrable (fun y : V => kernel (a (x-r • y)) y * f (x-r • y)) := by
obtain ⟨B,hB,hbound⟩ := kernel_majorant (V := V) α β hα
apply (hB.mul_const ‖f‖).mono'
· exact ((continuous_kernel_comp (fun y : V => a (x-r • y)) id
(ha.comp (by fun_prop)) continuous_id (fun y => hα.trans_le (hab _).1)).mul
(f.continuous.comp (by fun_prop))).aestronglyMeasurable
· filter_upwards with y
rw [norm_mul]
exact mul_le_mul (hbound _ (hab _) y) (C0Convolution.apply_norm_le f _)
(norm_nonneg _) ((norm_nonneg (kernel (a 0) y)).trans (hbound (a 0) (hab 0) y))
lemma continuous_value (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (f : C₀(V, ℂ)) :
Continuous (fun p : ℝ × V => value a p.1 f p.2) := by
obtain ⟨B,hB,hbound⟩ := kernel_majorant (V := V) α β hα
change Continuous (fun p : ℝ × V => ∫ y : V, kernel (a (p.2-p.1 • y)) y * f (p.2-p.1 • y))
apply continuous_of_dominated (bound := fun y => B y * ‖f‖)
· intro p
exact (integrable_value a ha α β hα hab p.1 f p.2).aestronglyMeasurable
· intro p
filter_upwards with y
rw [norm_mul]
exact mul_le_mul (hbound _ (hab _) y) (C0Convolution.apply_norm_le f _)
(norm_nonneg _) ((norm_nonneg (kernel (a 0) y)).trans (hbound (a 0) (hab 0) y))
· exact hB.mul_const ‖f‖
· filter_upwards with y
exact (continuous_kernel_comp (fun p : ℝ × V => a (p.2-p.1 • y)) (fun _ => y)
(ha.comp (by fun_prop)) continuous_const (fun p => hα.trans_le (hab _).1)).mul
(f.continuous.comp (by fun_prop))
lemma zero_at_infty_value (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (f : C₀(V, ℂ)) :
Tendsto (value a r f) (cocompact V) (𝓝 0) := by
have : (cocompact V).IsCountablyGenerated := by
rw [← comap_dist_left_atTop_eq_cocompact (0 : V)]
infer_instance
obtain ⟨B,hB,hbound⟩ := kernel_majorant (V := V) α β hα
have hlim (y : V) : Tendsto (fun x : V => kernel (a (x-r • y)) y * f (x-r • y))
(cocompact V) (𝓝 0) := by
have hf : Tendsto (fun x : V => f (x-r • y)) (cocompact V) (𝓝 0) :=
zero_at_infty (C0Convolution.translate (r • y) f)
apply tendsto_zero_iff_norm_tendsto_zero.mpr
apply squeeze_zero (fun x => norm_nonneg _) (fun x => ?_)
(by simpa using hf.norm.const_mul (B y))
rw [norm_mul]
exact mul_le_mul_of_nonneg_right (hbound _ (hab _) y) (norm_nonneg _)
have hi := tendsto_integral_filter_of_dominated_convergence
(fun y => B y * ‖f‖)
(Filter.Eventually.of_forall (fun x =>
(integrable_value a ha α β hα hab r f x).aestronglyMeasurable))
(Filter.Eventually.of_forall (fun x => Filter.Eventually.of_forall (fun y => by
rw [norm_mul]
exact mul_le_mul (hbound _ (hab _) y) (C0Convolution.apply_norm_le f _)
(norm_nonneg _) ((norm_nonneg (kernel (a 0) y)).trans (hbound (a 0) (hab 0) y)))))
(hB.mul_const ‖f‖) (Filter.Eventually.of_forall hlim)
change Tendsto (fun x : V => ∫ y : V, kernel (a (x-r • y)) y * f (x-r • y)) _ _
simpa only [integral_zero] using hi
def frozen (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (f : C₀(V, ℂ)) : C₀(V, ℂ) where
toFun := value a r f
continuous_toFun := by
change Continuous (fun x : V => value a r f x)
exact Continuous.comp (f := fun x : V => (r,x))
(continuous_value a ha α β hα hab f) (continuous_const.prodMk continuous_id)
zero_at_infty' := zero_at_infty_value a ha α β hα hab r f
end FrozenParametrix
open scoped Topology ZeroAtInfty BoundedContinuousFunction
open Set Filter MeasureTheory
namespace C0Multiplier
variable {V : Type*} [TopologicalSpace V]
def mul (g : V →ᵇ ℂ) (f : C₀(V,ℂ)) : C₀(V,ℂ) where
toFun x := g x * f x
continuous_toFun := g.continuous.mul f.continuous
zero_at_infty' := by
apply tendsto_zero_iff_norm_tendsto_zero.mpr
apply squeeze_zero (fun x => norm_nonneg _) (fun x => ?_)
(by simpa using (zero_at_infty f).norm.const_mul ‖g‖)
rw [norm_mul]
exact mul_le_mul_of_nonneg_right (g.norm_coe_le_norm x) (norm_nonneg _)
@[simp] lemma mul_apply (g : V →ᵇ ℂ) (f : C₀(V,ℂ)) (x : V) :
mul g f x = g x * f x := rfl
lemma norm_mul_le (g : V →ᵇ ℂ) (f : C₀(V,ℂ)) : ‖mul g f‖ ≤ ‖g‖ * ‖f‖ := by
change ‖(mul g f).toBCF‖ ≤ _
apply (BoundedContinuousFunction.norm_le (by positivity)).mpr
intro x
change ‖g x * f x‖ ≤ _
rw [norm_mul]
exact mul_le_mul (g.norm_coe_le_norm x) (f.toBCF.norm_coe_le_norm x)
(norm_nonneg _) (norm_nonneg _)
def mulCLM (f : C₀(V,ℂ)) : (V →ᵇ ℂ) →L[ℂ] C₀(V,ℂ) :=
LinearMap.mkContinuous
{ toFun := fun g => mul g f
map_add' := fun g h => by ext x; dsimp [mul]; ring
map_smul' := fun c g => by ext x; dsimp [mul]; ring }
‖f‖ (fun g => by
change ‖mul g f‖ ≤ ‖f‖ * ‖g‖
rw [mul_comm]
exact norm_mul_le g f)
lemma continuous_mul (f : C₀(V,ℂ)) : Continuous (fun g : V →ᵇ ℂ => mul g f) :=
(mulCLM f).continuous
end C0Multiplier
namespace C0Convolution
open scoped ZeroAtInfty
variable {V : Type*} [NormedAddCommGroup V]
@[simp] lemma translate_sub (y : V) (f g : C₀(V,ℂ)) :
translate y (f-g) = translate y f - translate y g := rfl
lemma continuous_translate_comp {X : Type*} [TopologicalSpace X]
(y : X → V) (f : X → C₀(V,ℂ)) (hy : Continuous y) (hf : Continuous f) :
Continuous (fun x => translate (y x) (f x)) := by
apply continuous_iff_continuousAt.mpr
intro x
have hb := ((continuous_translate (f x)).comp hy).tendsto x
apply hb.congr_dist
change Tendsto (fun z => dist (translate (y z) (f x)) (translate (y z) (f z))) (𝓝 x) (𝓝 0)
have he (z : X) : dist (translate (y z) (f x)) (translate (y z) (f z)) =
dist (f x) (f z) := by
rw [dist_eq_norm, ← translate_sub, norm_translate, ← dist_eq_norm]
simp_rw [he]
simpa only [dist_self] using
(tendsto_const_nhds (x := f x) (f := 𝓝 x)).dist (hf.tendsto x)
end C0Convolution
namespace FrozenParametrix
open scoped SchwartzMap ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel C0Convolution
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
def kernelFamily (α β : ℝ) (hα : 0 < α) (y : V) : C(Icc α β,ℂ) where
toFun t := kernel t.val y
continuous_toFun := continuous_kernel_comp Subtype.val (fun _ => y)
continuous_subtype_val continuous_const (fun t => hα.trans_le t.property.1)
lemma continuous_kernelFamily (α β : ℝ) (hα : 0 < α) :
Continuous (kernelFamily (V := V) α β hα) := by
apply ContinuousMap.continuous_of_continuous_uncurry
exact continuous_kernel_comp (fun p : V × Icc α β => p.2.val) Prod.fst
(continuous_subtype_val.comp continuous_snd) continuous_fst
(fun p => hα.trans_le p.2.property.1)
def sourceMultiplier (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (y : V) : V →ᵇ ℂ :=
(BoundedContinuousFunction.mkOfCompact (kernelFamily α β hα y)).compContinuous
⟨fun x => ⟨a x,hab x⟩, ha.subtype_mk _⟩
lemma continuous_sourceMultiplier (a : V → ℝ) (ha : Continuous a) (α β : ℝ)
(hα : 0 < α) (hab : ∀ x, a x ∈ Icc α β) :
Continuous (sourceMultiplier a ha α β hα hab) := by
exact (BoundedContinuousFunction.continuous_compContinuous
⟨fun x => ⟨a x,hab x⟩, ha.subtype_mk _⟩).comp
((ContinuousMap.isometryEquivBoundedOfCompact (Icc α β) ℂ).continuous.comp
(continuous_kernelFamily (V := V) α β hα))
def sourceData (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (f : C₀(V,ℂ)) (y : V) : C₀(V,ℂ) :=
C0Multiplier.mul (sourceMultiplier a ha α β hα hab y) f
lemma continuous_sourceData (a : V → ℝ) (ha : Continuous a) (α β : ℝ)
(hα : 0 < α) (hab : ∀ x, a x ∈ Icc α β) (f : C₀(V,ℂ)) :
Continuous (sourceData a ha α β hα hab f) :=
(C0Multiplier.continuous_mul f).comp (continuous_sourceMultiplier a ha α β hα hab)
@[simp] lemma sourceData_apply (a : V → ℝ) (ha : Continuous a) (α β : ℝ)
(hα : 0 < α) (hab : ∀ x, a x ∈ Icc α β) (f : C₀(V,ℂ)) (y x : V) :
sourceData a ha α β hα hab f y x = kernel (a x) y * f x := rfl
lemma sourceData_norm_le (a : V → ℝ) (ha : Continuous a) (α β : ℝ)
(hα : 0 < α) (hab : ∀ x, a x ∈ Icc α β) (f : C₀(V,ℂ)) (y : V)
(B : ℝ) (hB : ∀ t ∈ Icc α β, ‖kernel t y‖ ≤ B) :
‖sourceData a ha α β hα hab f y‖ ≤ B * ‖f‖ := by
have hBn : 0 ≤ B := (norm_nonneg (kernel (a 0) y)).trans (hB (a 0) (hab 0))
apply (C0Convolution.norm_le_iff _ (mul_nonneg hBn (norm_nonneg f))).mpr
intro x
rw [sourceData_apply, norm_mul]
exact mul_le_mul (hB (a x) (hab x)) (apply_norm_le f x) (norm_nonneg _) hBn
lemma integrable_translated_sourceData (a : V → ℝ) (ha : Continuous a) (α β : ℝ)
(hα : 0 < α) (hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (f : C₀(V,ℂ)) :
Integrable (fun y : V => C0Convolution.translate (r • y) (sourceData a ha α β hα hab f y)) := by
obtain ⟨B,hB,hbound⟩ := kernel_majorant (V := V) α β hα
apply (hB.mul_const ‖f‖).mono'
· exact (continuous_translate_comp (fun y : V => r • y)
(sourceData a ha α β hα hab f) (by fun_prop)
(continuous_sourceData a ha α β hα hab f)).aestronglyMeasurable
· filter_upwards with y
rw [norm_translate]
exact sourceData_norm_le a ha α β hα hab f y (B y) (fun t ht => hbound t ht y)
lemma frozen_eq_integral (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (f : C₀(V,ℂ)) :
frozen a ha α β hα hab r f =
∫ y : V, C0Convolution.translate (r • y) (sourceData a ha α β hα hab f y) := by
ext x
change value a r f x = (eval x) (∫ y : V, C0Convolution.translate (r • y)
(sourceData a ha α β hα hab f y))
rw [← (eval x).integral_comp_comm (integrable_translated_sourceData a ha α β hα hab r f)]
rfl
lemma continuous_frozen (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (f : C₀(V,ℂ)) :
Continuous (fun r : ℝ => frozen a ha α β hα hab r f) := by
simp_rw [frozen_eq_integral]
obtain ⟨B,hB,hbound⟩ := kernel_majorant (V := V) α β hα
apply continuous_of_dominated (bound := fun y => B y * ‖f‖)
· intro r
exact (integrable_translated_sourceData a ha α β hα hab r f).aestronglyMeasurable
· intro r
filter_upwards with y
rw [norm_translate]
exact sourceData_norm_le a ha α β hα hab f y (B y) (fun t ht => hbound t ht y)
· exact hB.mul_const ‖f‖
· filter_upwards with y
exact (continuous_translate (sourceData a ha α β hα hab f y)).comp
(continuous_id.smul (continuous_const : Continuous (fun _ : ℝ => y)))
@[simp] lemma frozen_zero (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (f : C₀(V,ℂ)) :
frozen a ha α β hα hab 0 f = f := by
ext x
change (∫ y : V, kernel (a (x-0 • y)) y * f (x-0 • y)) = f x
simp only [zero_smul, sub_zero, integral_mul_const]
rw [← heatKernel_eq_kernel (a x) (hα.trans_le (hab x).1), integral_heatKernel, one_mul]
lemma frozen_tendsto_identity (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (f : C₀(V,ℂ)) :
Tendsto (fun r : ℝ => frozen a ha α β hα hab r f) (𝓝 0) (𝓝 f) := by
simpa only [frozen_zero] using (continuous_frozen a ha α β hα hab f).tendsto 0
lemma norm_frozen_le (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (f : C₀(V,ℂ)) (B : V → ℝ)
(hB : Integrable B) (hbound : ∀ t ∈ Icc α β, ∀ y : V, ‖kernel t y‖ ≤ B y) :
‖frozen a ha α β hα hab r f‖ ≤ (∫ y : V, B y) * ‖f‖ := by
rw [frozen_eq_integral, ← integral_mul_const]
apply norm_integral_le_of_norm_le (hB.mul_const ‖f‖)
filter_upwards with y
rw [norm_translate]
exact sourceData_norm_le a ha α β hα hab f y (B y) (fun t ht => hbound t ht y)
lemma frozen_add (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (f g : C₀(V,ℂ)) :
frozen a ha α β hα hab r (f+g) = frozen a ha α β hα hab r f +
frozen a ha α β hα hab r g := by
ext x
change (∫ y : V, kernel (a (x-r • y)) y * (f (x-r • y)+g (x-r • y))) =
(∫ y : V, kernel (a (x-r • y)) y * f (x-r • y)) +
(∫ y : V, kernel (a (x-r • y)) y * g (x-r • y))
simp_rw [mul_add]
exact integral_add (integrable_value a ha α β hα hab r f x)
(integrable_value a ha α β hα hab r g x)
lemma frozen_smul (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (c : ℂ) (f : C₀(V,ℂ)) :
frozen a ha α β hα hab r (c • f) = c • frozen a ha α β hα hab r f := by
ext x
change (∫ y : V, kernel (a (x-r • y)) y * (c * f (x-r • y))) =
c * (∫ y : V, kernel (a (x-r • y)) y * f (x-r • y))
simp_rw [mul_left_comm (kernel _ _) c, integral_const_mul]
lemma exists_uniform_norm_bound (α β : ℝ) (hα : 0 < α) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (a : V → ℝ) (ha : Continuous a)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (f : C₀(V,ℂ)),
‖frozen a ha α β hα hab r f‖ ≤ C * ‖f‖ := by
obtain ⟨B,hB,hbound⟩ := kernel_majorant (V := V) α β hα
refine ⟨∫ y : V, |B y|, integral_nonneg (fun y => abs_nonneg _), ?_⟩
intro a ha hab r f
exact norm_frozen_le a ha α β hα hab r f (fun y => |B y|) hB.abs
(fun t ht y => (hbound t ht y).trans (le_abs_self _))
lemma frozen_apply_unscaled (a : V → ℝ) (ha : Continuous a) (α β : ℝ) (hα : 0 < α)
(hab : ∀ x, a x ∈ Icc α β) (r : ℝ) (hr : 0 < r) (f : C₀(V,ℂ)) (x : V) :
frozen a ha α β hα hab r f x =
∫ y : V, kernel (r^4*a y) (x-y) * f y := by
have hscale (t : ℝ) (ht : 0 < t) (w : V) :
kernel (r^4*t) w = (r^Module.finrank ℝ V)⁻¹ • kernel t (r⁻¹ • w) := by
rw [← heatKernel_eq_kernel (r^4*t) (by positivity), ← heatKernel_eq_kernel t ht]
exact heatKernel_scaling t ht r hr w
rw [← integral_sub_left_eq_self
(fun y : V => kernel (r^4*a y) (x-y) * f y) volume x]
simp only [sub_sub_self]
simp_rw [hscale _ (hα.trans_le (hab _).1), smul_mul_assoc]
rw [integral_smul]
let F := fun y : V => kernel (a (x-r • y)) y * f (x-r • y)
have he : (fun y : V => kernel (a (x-y)) (r⁻¹ • y) * f (x-y)) =
fun y : V => F (r⁻¹ • y) := by
funext y
dsimp [F]
rw [smul_inv_smul₀ hr.ne']
rw [he, Measure.integral_comp_inv_smul_of_nonneg volume F hr.le,
inv_smul_smul₀ (pow_ne_zero _ hr.ne')]
rfl
end FrozenParametrix
open Set Filter MeasureTheory
open scoped SchwartzMap Topology
namespace SchwartzConvolution
variable {V E : Type*} [NormedAddCommGroup V] [NormedSpace ℝ V]
[FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)]
[NormedAddCommGroup E] [NormedSpace ℝ E]
lemma scaled_weighted_majorant (g : SchwartzMap V E) (a b : ℝ) (ha : 0 < a) (K L : ℕ) :
∃ B : V → ℝ, Integrable B ∧ Integrable (fun x => (1+‖x‖)^L * B x) ∧
(∀ x, 0 ≤ B x) ∧ ∀ c ∈ Icc a b, ∀ x,
‖(c⁻¹)^K • g (c⁻¹ • x)‖ ≤ B x := by
let N := Module.finrank ℝ V + 1 + L
let M := max b 1
let C := 2^N * (Finset.Iic (N,0)).sup (fun i => SchwartzMap.seminorm ℝ i.1 i.2) g
have hC : 0 ≤ C := by positivity
have hM : 0 < M := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
have hdec (z : V) : (1+‖z‖)^N * ‖g z‖ ≤ C := by
simpa only [norm_iteratedFDeriv_zero] using
SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) (m := (N,0)) le_rfl le_rfl g z
refine ⟨fun x => ((a⁻¹)^K*(M^N*C))/(1+‖x‖)^N, ?_, ?_, ?_, ?_⟩
· have hi : Integrable (fun x : V => (1+‖x‖)^(-(N : ℝ))) :=
integrable_one_add_norm (by dsimp [N]; push_cast; linarith)
simpa only [Real.rpow_neg (by positivity : (0:ℝ) ≤ 1+‖(_ : V)‖),
Real.rpow_natCast, div_eq_mul_inv] using hi.const_mul ((a⁻¹)^K*(M^N*C))
· have hi : Integrable (fun x : V => (1+‖x‖)^(-(Module.finrank ℝ V + 1 : ℝ))) :=
integrable_one_add_norm (by linarith)
have he (x : V) : (1+‖x‖)^L * (((a⁻¹)^K*(M^N*C))/(1+‖x‖)^N) =
((a⁻¹)^K*(M^N*C)) * (1+‖x‖)^(-(Module.finrank ℝ V + 1 : ℝ)) := by
rw [Real.rpow_neg (by positivity), ← Nat.cast_one, ← Nat.cast_add, Real.rpow_natCast]
dsimp [N]
rw [pow_add]
field_simp
rw [pow_add]
ring
simp_rw [he]
exact hi.const_mul _
· intro x
positivity
· intro c hc x
have hcpos : 0 < c := ha.trans_le hc.1
have hcM : c ≤ M := hc.2.trans (le_max_left _ _)
have hnx : ‖x‖ = c * ‖c⁻¹ • x‖ := by
rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hcpos),
← mul_assoc, mul_inv_cancel₀ hcpos.ne', one_mul]
have hs : 1+‖x‖ ≤ M*(1+‖c⁻¹ • x‖) := by
rw [hnx, mul_add, mul_one]
exact add_le_add (le_max_right b 1) (mul_le_mul_of_nonneg_right hcM (norm_nonneg _))
have hg : ‖g (c⁻¹ • x)‖ * (1+‖x‖)^N ≤ M^N*C := by
calc
_ ≤ ‖g (c⁻¹ • x)‖ * (M * (1+‖c⁻¹ • x‖))^N := by gcongr
_ = M^N * ((1+‖c⁻¹ • x‖)^N * ‖g (c⁻¹ • x)‖) := by rw [mul_pow]; ring
_ ≤ _ := mul_le_mul_of_nonneg_left (hdec _) (by positivity)
rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
apply (le_div_iff₀ (by positivity)).mpr
calc
_ = (c⁻¹)^K * (‖g (c⁻¹ • x)‖ * (1+‖x‖)^N) := by ring
_ ≤ (a⁻¹)^K * (‖g (c⁻¹ • x)‖ * (1+‖x‖)^N) := by
gcongr
exact hc.1
_ ≤ _ := mul_le_mul_of_nonneg_left hg (by positivity)
end SchwartzConvolution
namespace BiharmonicKernel
open scoped SchwartzMap Laplacian ContDiff Topology
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
def bilapKernel (t : ℝ) (x : V) : ℂ := Δ (Δ (kernel (V := V) t)) x
lemma bilapKernel_eq_schwartz (t : ℝ) (ht : 0 < t) (x : V) :
bilapKernel t x = (Δ (Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : SchwartzMap V ℂ) x := by
have he : ((Δ (heatKernel (V := V) t ht) : SchwartzMap V ℂ) : V → ℂ) =
Δ (kernel (V := V) t) := by
funext y
rw [SchwartzMap.laplacian_apply, heatKernel_eq_kernel t ht]
rw [SchwartzMap.laplacian_apply, he]
rfl
lemma bilapKernel_eq_scaled (t : ℝ) (ht : 0 < t) (x : V) :
bilapKernel t x = ((Real.sqrt (Real.sqrt t))⁻¹)^(Module.finrank ℝ V+4) •
(Δ (Δ (heatKernel (V := V) 1 zero_lt_one) : SchwartzMap V ℂ) : SchwartzMap V ℂ)
((Real.sqrt (Real.sqrt t))⁻¹ • x) := by
let r := Real.sqrt (Real.sqrt t)
have hr : 0 < r := Real.sqrt_pos.mpr (Real.sqrt_pos.mpr ht)
have he : r^4 = t := by
dsimp [r]
calc
_ = ((Real.sqrt (Real.sqrt t))^2)^2 := by ring
_ = t := by rw [Real.sq_sqrt (Real.sqrt_nonneg t), Real.sq_sqrt ht.le]
have hs := congrFun (biharmonic_kernel_scaling (V := V) 1 zero_lt_one r hr) x
simp only [mul_one, he] at hs
rw [bilapKernel_eq_schwartz t ht]
exact hs
lemma bilapKernel_contDiffAt (q : ℝ × V) (hq : 0 < q.1) :
ContDiffAt ℝ ∞ (fun p : ℝ × V => bilapKernel p.1 p.2) q := by
have hr : ContDiffAt ℝ ∞ (fun p : ℝ × V => Real.sqrt (Real.sqrt p.1)) q :=
(contDiffAt_fst.sqrt (ne_of_gt hq)).sqrt (ne_of_gt (Real.sqrt_pos.mpr hq))
have hpos : 0 < Real.sqrt (Real.sqrt q.1) := Real.sqrt_pos.mpr (Real.sqrt_pos.mpr hq)
let g : SchwartzMap V ℂ := Δ (Δ (heatKernel (V := V) 1 zero_lt_one) : SchwartzMap V ℂ)
have hs : ContDiffAt ℝ ∞ (fun p : ℝ × V =>
((Real.sqrt (Real.sqrt p.1))⁻¹)^(Module.finrank ℝ V+4) •
g ((Real.sqrt (Real.sqrt p.1))⁻¹ • p.2)) q :=
((hr.inv hpos.ne').pow _).smul
((g.smooth ⊤).contDiffAt.comp q ((hr.inv hpos.ne').smul contDiffAt_snd))
apply hs.congr_of_eventuallyEq
filter_upwards [continuous_fst.continuousAt.eventually (Ioi_mem_nhds hq)] with p hp
exact bilapKernel_eq_scaled _ hp _
lemma continuous_bilapKernel_comp {X : Type*} [TopologicalSpace X]
(a : X → ℝ) (v : X → V) (ha : Continuous a) (hv : Continuous v)
(hpos : ∀ x, 0 < a x) : Continuous (fun x => bilapKernel (a x) (v x)) := by
apply continuous_iff_continuousAt.mpr
intro x
exact ContinuousAt.comp (f := fun u => (a u,v u))
(bilapKernel_contDiffAt (a x,v x) (hpos x)).continuousAt
(ha.continuousAt.prodMk hv.continuousAt)
lemma bilapKernel_weighted_majorant (a b : ℝ) (ha : 0 < a) :
∃ B : V → ℝ, Integrable B ∧ Integrable (fun x => (1+‖x‖) * B x) ∧
(∀ x, 0 ≤ B x) ∧ ∀ t ∈ Icc a b, ∀ x : V, ‖bilapKernel t x‖ ≤ B x := by
let r := fun t : ℝ => Real.sqrt (Real.sqrt t)
obtain ⟨B,hB,hBw,hBn,hbound⟩ := SchwartzConvolution.scaled_weighted_majorant
(Δ (Δ (heatKernel (V := V) 1 zero_lt_one) : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(r a) (r b) (Real.sqrt_pos.mpr (Real.sqrt_pos.mpr ha)) (Module.finrank ℝ V+4) 1
refine ⟨B,hB,by simpa only [pow_one] using hBw,hBn,fun t ht x => ?_⟩
rw [bilapKernel_eq_scaled t (ha.trans_le ht.1) x]
exact hbound (r t) ⟨Real.sqrt_le_sqrt (Real.sqrt_le_sqrt ht.1),
Real.sqrt_le_sqrt (Real.sqrt_le_sqrt ht.2)⟩ x
end BiharmonicKernel
namespace C0Multiplier
variable {V : Type*} [TopologicalSpace V]
def mulLeftCLM (g : V →ᵇ ℂ) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
LinearMap.mkContinuous
{ toFun := mul g
map_add' := fun f h => by ext x; dsimp [mul]; ring
map_smul' := fun c f => by ext x; dsimp [mul]; ring }
‖g‖ (norm_mul_le g)
lemma continuous_mul_left (g : V →ᵇ ℂ) : Continuous (mul g) :=
(mulLeftCLM g).continuous
end C0Multiplier
namespace FrozenFamily
open C0Convolution
variable {V P : Type*} [NormedAddCommGroup V]
[TopologicalSpace P] [CompactSpace P]
def family (g : C(P × V,ℂ)) (y : V) : C(P,ℂ) :=
⟨fun t => g (t,y), g.continuous.comp (by fun_prop)⟩
omit [CompactSpace P] in
lemma continuous_family (g : C(P × V,ℂ)) : Continuous (family g) := by
apply ContinuousMap.continuous_of_continuous_uncurry
exact g.continuous.comp (by fun_prop)
def multiplier (g : C(P × V,ℂ)) (a : C(V,P)) (y : V) : V →ᵇ ℂ :=
(BoundedContinuousFunction.mkOfCompact (family g y)).compContinuous a
lemma continuous_multiplier (g : C(P × V,ℂ)) (a : C(V,P)) :
Continuous (multiplier g a) :=
(BoundedContinuousFunction.continuous_compContinuous a).comp
((ContinuousMap.isometryEquivBoundedOfCompact P ℂ).continuous.comp (continuous_family g))
def data (g : C(P × V,ℂ)) (a : C(V,P)) (f : C₀(V,ℂ)) (y : V) : C₀(V,ℂ) :=
C0Multiplier.mul (multiplier g a y) f
@[simp] lemma data_apply (g : C(P × V,ℂ)) (a : C(V,P)) (f : C₀(V,ℂ)) (y x : V) :
data g a f y x = g (a x,y) * f x := rfl
lemma continuous_data (g : C(P × V,ℂ)) (a : C(V,P)) (f : C₀(V,ℂ)) :
Continuous (data g a f) :=
(C0Multiplier.continuous_mul f).comp (continuous_multiplier g a)
lemma norm_data_le (g : C(P × V,ℂ)) (a : C(V,P)) (f : C₀(V,ℂ)) (y : V)
(B : ℝ) (hB : 0 ≤ B) (hbound : ∀ p, ‖g (p,y)‖ ≤ B) :
‖data g a f y‖ ≤ B * ‖f‖ := by
apply (norm_le_iff _ (mul_nonneg hB (norm_nonneg f))).mpr
intro x
rw [data_apply, norm_mul]
exact mul_le_mul (hbound _) (apply_norm_le f x) (norm_nonneg _) hB
variable [NormedSpace ℝ V]
def residualData (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) (y : V) : C₀(V,ℂ) :=
C0Multiplier.mul c₁ (C0Convolution.translate (r • y) (data g a f y)) -
C0Convolution.translate (r • y) (data g a (C0Multiplier.mul c₀ f) y)
lemma residualData_apply (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) (y x : V) :
residualData g a c₀ c₁ r f y x =
(c₁ x - c₀ (x-r • y)) * g (a (x-r • y),y) * f (x-r • y) := by
change c₁ x * (g (a (x-r • y),y) * f (x-r • y)) -
g (a (x-r • y),y) * (c₀ (x-r • y) * f (x-r • y)) = _
ring
lemma continuous_residualData (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) : Continuous (residualData g a c₀ c₁ r f) :=
((C0Multiplier.continuous_mul_left c₁).comp
(continuous_translate_comp (fun y : V => r • y) (data g a f)
(by fun_prop) (continuous_data g a f))).sub
(continuous_translate_comp (fun y : V => r • y) (data g a (C0Multiplier.mul c₀ f))
(by fun_prop) (continuous_data g a (C0Multiplier.mul c₀ f)))
lemma norm_residualData_le (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (hr : 0 ≤ r) (f : C₀(V,ℂ)) (y : V)
(B L δ : ℝ) (hB : 0 ≤ B) (hL : 0 ≤ L) (hδ : 0 ≤ δ)
(hbound : ∀ p, ‖g (p,y)‖ ≤ B)
(hLip : ∀ x z, ‖c₁ x-c₀ z‖ ≤ L*(‖x-z‖+δ)) :
‖residualData g a c₀ c₁ r f y‖ ≤ L*(r*‖y‖+δ)*B*‖f‖ := by
apply (norm_le_iff _ (by positivity)).mpr
intro x
rw [residualData_apply, norm_mul, norm_mul]
have hc : ‖c₁ x-c₀ (x-r • y)‖ ≤ L*(r*‖y‖+δ) := by
simpa only [sub_sub_cancel, norm_smul, Real.norm_eq_abs, abs_of_nonneg hr] using
hLip x (x-r • y)
exact mul_le_mul (mul_le_mul hc (hbound _) (norm_nonneg _) (by positivity))
(apply_norm_le f _) (norm_nonneg _) (by positivity)
variable [MeasureSpace V] [BorelSpace V] [SecondCountableTopology V]
lemma integrable_residualData (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) (B : V → ℝ) (hB : Integrable B)
(hBn : ∀ y, 0 ≤ B y) (hbound : ∀ p y, ‖g (p,y)‖ ≤ B y) :
Integrable (residualData g a c₀ c₁ r f) := by
apply (hB.const_mul ((‖c₁‖+‖c₀‖)*‖f‖)).mono'
· exact (continuous_residualData g a c₀ c₁ r f).aestronglyMeasurable
· filter_upwards with y
have hBy := hBn y
apply (norm_le_iff _ (by positivity)).mpr
intro x
rw [residualData_apply, norm_mul, norm_mul]
have hc : ‖c₁ x-c₀ (x-r • y)‖ ≤ ‖c₁‖+‖c₀‖ :=
(norm_sub_le _ _).trans (add_le_add (c₁.norm_coe_le_norm _) (c₀.norm_coe_le_norm _))
calc
_ ≤ (‖c₁‖+‖c₀‖)*B y*‖f‖ :=
mul_le_mul (mul_le_mul hc (hbound _ y) (norm_nonneg _) (by positivity))
(apply_norm_le f _) (norm_nonneg _) (by positivity)
_ = _ := by ring
def residual (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) : C₀(V,ℂ) :=
∫ y : V, residualData g a c₀ c₁ r f y
lemma residual_apply (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) (B : V → ℝ) (hB : Integrable B)
(hBn : ∀ y, 0 ≤ B y) (hbound : ∀ p y, ‖g (p,y)‖ ≤ B y) (x : V) :
residual g a c₀ c₁ r f x =
∫ y : V, (c₁ x-c₀ (x-r • y))*g (a (x-r • y),y)*f (x-r • y) := by
change (eval x) (∫ y : V, residualData g a c₀ c₁ r f y) = _
rw [← (eval x).integral_comp_comm (integrable_residualData g a c₀ c₁ r f B hB hBn hbound)]
simp only [eval_apply, residualData_apply]
omit [BorelSpace V] [SecondCountableTopology V] in
lemma norm_residual_le (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (hr : 0 ≤ r) (f : C₀(V,ℂ)) (B : V → ℝ)
(hB : Integrable B) (hBw : Integrable (fun y => ‖y‖*B y))
(hBn : ∀ y, 0 ≤ B y) (hbound : ∀ p y, ‖g (p,y)‖ ≤ B y)
(L δ : ℝ) (hL : 0 ≤ L) (hδ : 0 ≤ δ)
(hLip : ∀ x z, ‖c₁ x-c₀ z‖ ≤ L*(‖x-z‖+δ)) :
‖residual g a c₀ c₁ r f‖ ≤
L*(r*(∫ y : V, ‖y‖*B y)+δ*(∫ y : V, B y))*‖f‖ := by
have hi : Integrable (fun y : V => L*(r*‖y‖+δ)*B y*‖f‖) := by
convert ((hBw.const_mul r).add (hB.const_mul δ)).const_mul L |>.mul_const ‖f‖ using 1
ext y
simp only [Pi.add_apply]
ring
calc
_ ≤ ∫ y : V, L*(r*‖y‖+δ)*B y*‖f‖ := by
apply norm_integral_le_of_norm_le hi
filter_upwards with y
exact norm_residualData_le g a c₀ c₁ r hr f y (B y) L δ (hBn y) hL hδ
(fun p => hbound p y) hLip
_ = _ := by
have he (y : V) : L*(r*‖y‖+δ)*B y*‖f‖ =
L*(r*(‖y‖*B y)+δ*B y)*‖f‖ := by ring
simp_rw [he]
rw [integral_mul_const, integral_const_mul, integral_add (hBw.const_mul r) (hB.const_mul δ),
integral_const_mul, integral_const_mul]
end FrozenFamily
namespace BiharmonicKernel
open scoped SchwartzMap Laplacian
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma bilapKernel_scaling (t : ℝ) (ht : 0 < t) (r : ℝ) (hr : 0 < r) (x : V) :
bilapKernel (r^4*t) x = (r⁻¹)^(Module.finrank ℝ V+4) •
bilapKernel t (r⁻¹ • x) := by
rw [bilapKernel_eq_schwartz _ (by positivity), bilapKernel_eq_schwartz _ ht]
exact congrFun (biharmonic_kernel_scaling t ht r hr) x
end BiharmonicKernel
namespace FrozenParametrix
open scoped ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel C0Convolution
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
def bilapFamily (α β : ℝ) (hα : 0 < α) : C(Icc α β × V,ℂ) :=
⟨fun p => bilapKernel p.1.val p.2,
continuous_bilapKernel_comp (fun p : Icc α β × V => p.1.val) Prod.snd
(continuous_subtype_val.comp continuous_fst) continuous_snd
(fun p => hα.trans_le p.1.property.1)⟩
def coefficient {α β : ℝ} (a : C(V,Icc α β)) : V →ᵇ ℂ :=
(BoundedContinuousFunction.mkOfCompact
(⟨fun t : Icc α β => (t.val : ℂ), by fun_prop⟩ : C(Icc α β,ℂ))).compContinuous a
omit [InnerProductSpace ℝ V] [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
@[simp] lemma coefficient_apply {α β : ℝ} (a : C(V,Icc α β)) (x : V) :
coefficient a x = ((a x).val : ℂ) := rfl
def principalResidual {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β))
(r : ℝ) (f : C₀(V,ℂ)) : C₀(V,ℂ) :=
(r⁻¹)^4 • FrozenFamily.residual (bilapFamily α β hα) a₀
(coefficient a₀) (coefficient a₁) r f
lemma principalResidual_apply_scaled {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β))
(r : ℝ) (f : C₀(V,ℂ)) (x : V) :
principalResidual hα a₀ a₁ r f x = (r⁻¹)^4 •
∫ y : V, (((a₁ x).val-(a₀ (x-r • y)).val : ℝ) : ℂ) *
bilapKernel (a₀ (x-r • y)).val y * f (x-r • y) := by
obtain ⟨B,hB,_,hBn,hbound⟩ := bilapKernel_weighted_majorant (V := V) α β hα
change (r⁻¹)^4 • FrozenFamily.residual (bilapFamily α β hα) a₀
(coefficient a₀) (coefficient a₁) r f x = _
rw [FrozenFamily.residual_apply _ _ _ _ _ _ B hB hBn
(fun p y => hbound p.val p.property y)]
simp only [coefficient_apply, Complex.ofReal_sub]
rfl
lemma principalResidual_apply_unscaled {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β))
(r : ℝ) (hr : 0 < r) (f : C₀(V,ℂ)) (x : V) :
principalResidual hα a₀ a₁ r f x =
∫ y : V, (((a₁ x).val-(a₀ y).val : ℝ) : ℂ) *
bilapKernel (r^4*(a₀ y).val) (x-y) * f y := by
rw [principalResidual_apply_scaled]
rw [← integral_sub_left_eq_self
(fun y : V => (((a₁ x).val-(a₀ y).val : ℝ) : ℂ) *
bilapKernel (r^4*(a₀ y).val) (x-y) * f y) volume x]
simp only [sub_sub_self]
simp_rw [bilapKernel_scaling _ (hα.trans_le (a₀ _).property.1) r hr,
mul_smul_comm, smul_mul_assoc]
rw [integral_smul]
let F := fun y : V => (((a₁ x).val-(a₀ (x-r • y)).val : ℝ) : ℂ) *
bilapKernel (a₀ (x-r • y)).val y * f (x-r • y)
have he : (fun y : V => (((a₁ x).val-(a₀ (x-y)).val : ℝ) : ℂ) *
bilapKernel (a₀ (x-y)).val (r⁻¹ • y) * f (x-y)) =
fun y : V => F (r⁻¹ • y) := by
funext y
dsimp [F]
rw [smul_inv_smul₀ hr.ne']
rw [he, Measure.integral_comp_inv_smul_of_nonneg volume F hr.le, smul_smul]
congr 1
rw [pow_add, mul_right_comm, ← mul_pow, inv_mul_cancel₀ hr.ne', one_pow, one_mul]
lemma norm_principalResidual_le {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β))
(r : ℝ) (hr : 0 ≤ r) (f : C₀(V,ℂ)) (B : V → ℝ)
(hB : Integrable B) (hBw : Integrable (fun y => ‖y‖*B y))
(hBn : ∀ y, 0 ≤ B y)
(hbound : ∀ t ∈ Icc α β, ∀ y : V, ‖bilapKernel t y‖ ≤ B y)
(L : ℝ) (hL : 0 ≤ L)
(hLip : ∀ x z, |(a₁ x).val-(a₀ z).val| ≤ L*(‖x-z‖+r^4)) :
‖principalResidual hα a₀ a₁ r f‖ ≤
(r⁻¹)^4 * (L*(r*(∫ y : V, ‖y‖*B y)+r^4*(∫ y : V, B y))*‖f‖) := by
rw [principalResidual, norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
apply mul_le_mul_of_nonneg_left _ (by positivity)
apply FrozenFamily.norm_residual_le _ _ _ _ r hr f B hB hBw hBn
(fun p y => hbound p.val p.property y) L (r^4) hL (by positivity)
intro x z
simpa only [coefficient_apply, ← Complex.ofReal_sub, Complex.norm_real, Real.norm_eq_abs]
using hLip x z
lemma exists_uniform_principalResidual_bound (α β : ℝ) (hα : 0 < α) (L : ℝ) (hL : 0 ≤ L) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (a₀ a₁ : C(V,Icc α β)) (r : ℝ), 0 < r → r ≤ 1 →
(∀ x z, |(a₁ x).val-(a₀ z).val| ≤ L*(‖x-z‖+r^4)) →
∀ f : C₀(V,ℂ), ‖principalResidual hα a₀ a₁ r f‖ ≤ C*(r⁻¹)^3*‖f‖ := by
obtain ⟨B,hB,hBw,hBn,hbound⟩ := bilapKernel_weighted_majorant (V := V) α β hα
have hBw' : Integrable (fun y : V => ‖y‖*B y) := by
have hi : Integrable (fun y : V => (1+‖y‖)*B y-B y) := hBw.sub hB
have he : (fun y : V => (1+‖y‖)*B y-B y) = (fun y : V => ‖y‖*B y) := by
funext y
ring
rwa [he] at hi
let M₀ := ∫ y : V, B y
let M₁ := ∫ y : V, ‖y‖*B y
have hM₀ : 0 ≤ M₀ := integral_nonneg hBn
have hM₁ : 0 ≤ M₁ := integral_nonneg (fun y => mul_nonneg (norm_nonneg _) (hBn y))
refine ⟨L*(M₁+M₀),by positivity,fun a₀ a₁ r hr hr1 hLip f => ?_⟩
apply (norm_principalResidual_le hα a₀ a₁ r hr.le f B hB hBw' hBn hbound L hL hLip).trans
have hrinv : 1 ≤ (r⁻¹)^3 := one_le_pow₀ (by exact (one_le_inv₀ hr).mpr hr1)
have he : (r⁻¹)^4 * (L*(r*M₁+r^4*M₀)*‖f‖) =
L*((r⁻¹)^3*M₁+M₀)*‖f‖ := by
field_simp
change (r⁻¹)^4 * (L*(r*M₁+r^4*M₀)*‖f‖) ≤ _
rw [he]
calc
_ ≤ L*((r⁻¹)^3*M₁+(r⁻¹)^3*M₀)*‖f‖ := by gcongr; exact le_mul_of_one_le_left hM₀ hrinv
_ = _ := by ring
end FrozenParametrix
open Set Filter MeasureTheory
open scoped Topology ZeroAtInfty BoundedContinuousFunction
namespace CompactComposition
variable {V P F : Type*} [TopologicalSpace V] [PseudoMetricSpace P] [CompactSpace P]
[PseudoMetricSpace F]
def compose (g : C(P,F)) (a : V →ᵇ P) : V →ᵇ F :=
(BoundedContinuousFunction.mkOfCompact g).compContinuous a.toContinuousMap
@[simp] lemma compose_apply (g : C(P,F)) (a : V →ᵇ P) (x : V) :
compose g a x = g (a x) := rfl
lemma continuous_compose : Continuous (fun p : C(P,F) × (V →ᵇ P) => compose p.1 p.2) := by
apply continuous_iff_continuousAt.mpr
rintro ⟨g₀,a₀⟩
apply Metric.continuousAt_iff.mpr
intro ε hε
obtain ⟨δ,hδ,hg⟩ := Metric.uniformContinuous_iff.mp (CompactSpace.uniformContinuous_of_continuous g₀.continuous) (ε/4) (by positivity)
refine ⟨min (ε/4) δ, lt_min (by positivity) hδ, ?_⟩
rintro ⟨g,a⟩ hp
change max (dist g g₀) (dist a a₀) < min (ε/4) δ at hp
have hgdist : dist g g₀ < ε/4 := (le_max_left _ _).trans_lt (lt_of_lt_of_le hp (min_le_left _ _))
have hadist : dist a a₀ < δ := (le_max_right _ _).trans_lt (lt_of_lt_of_le hp (min_le_right _ _))
apply lt_of_le_of_lt ((BoundedContinuousFunction.dist_le (show (0 : ℝ) ≤ ε/2 by positivity)).mpr ?_) (by linarith)
intro x
calc
dist (g (a x)) (g₀ (a₀ x)) ≤ dist (g (a x)) (g₀ (a x)) + dist (g₀ (a x)) (g₀ (a₀ x)) := dist_triangle _ _ _
_ ≤ ε/2 := by
have h₁ := (ContinuousMap.dist_apply_le_dist (f := g) (g := g₀) (a x)).trans_lt hgdist
have h₂ := hg ((BoundedContinuousFunction.dist_coe_le_dist (f := a) (g := a₀) x).trans_lt hadist)
linarith
end CompactComposition
namespace C0Multiplier
variable {V : Type*} [TopologicalSpace V]
lemma continuous_mul_joint : Continuous (fun p : (V →ᵇ ℂ) × C₀(V,ℂ) => mul p.1 p.2) := by
apply ZeroAtInftyContinuousMap.isometry_toBCF.isUniformInducing.isInducing.continuous_iff.mpr
change Continuous (fun p : (V →ᵇ ℂ) × C₀(V,ℂ) => p.1*p.2.toBCF)
exact continuous_fst.mul (ZeroAtInftyContinuousMap.isometry_toBCF.continuous.comp continuous_snd)
end C0Multiplier
namespace FrozenFamily
open C0Convolution
variable {V P : Type*} [NormedAddCommGroup V] [NormedSpace ℝ V]
[PseudoMetricSpace P] [CompactSpace P]
omit [NormedSpace ℝ V] in
lemma continuous_multiplier_comp {X : Type*} [TopologicalSpace X]
(g : C(P × V,ℂ)) (a : X → V →ᵇ P) (y : X → V)
(ha : Continuous a) (hy : Continuous y) :
Continuous (fun x => multiplier g (a x).toContinuousMap (y x)) := by
exact CompactComposition.continuous_compose.comp
(((continuous_family g).comp hy).prodMk ha)
omit [NormedSpace ℝ V] in
lemma continuous_data_comp {X : Type*} [TopologicalSpace X]
(g : C(P × V,ℂ)) (a : X → V →ᵇ P) (f : X → C₀(V,ℂ)) (y : X → V)
(ha : Continuous a) (hf : Continuous f) (hy : Continuous y) :
Continuous (fun x => data g (a x).toContinuousMap (f x) (y x)) :=
C0Multiplier.continuous_mul_joint.comp ((continuous_multiplier_comp g a y ha hy).prodMk hf)
lemma continuous_residualData_comp {X : Type*} [TopologicalSpace X]
(g : C(P × V,ℂ)) (a : X → V →ᵇ P) (c₀ c₁ : X → V →ᵇ ℂ)
(r : X → ℝ) (f : X → C₀(V,ℂ)) (y : X → V)
(ha : Continuous a) (h₀ : Continuous c₀) (h₁ : Continuous c₁)
(hr : Continuous r) (hf : Continuous f) (hy : Continuous y) :
Continuous (fun x => residualData g (a x).toContinuousMap (c₀ x) (c₁ x) (r x) (f x) (y x)) := by
apply Continuous.sub
· exact C0Multiplier.continuous_mul_joint.comp (h₁.prodMk
(continuous_translate_comp _ _ (hr.smul hy) (continuous_data_comp g a f y ha hf hy)))
· exact continuous_translate_comp _ _ (hr.smul hy) (continuous_data_comp g a
(fun x => C0Multiplier.mul (c₀ x) (f x)) y ha
(C0Multiplier.continuous_mul_joint.comp (h₀.prodMk hf)) hy)
variable [MeasureSpace V] [BorelSpace V] [SecondCountableTopology V]
omit [MeasureSpace V] [BorelSpace V] [SecondCountableTopology V] in
lemma norm_residualData_le_uniform (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) (y : V) (B M : ℝ) (hB : 0 ≤ B) (hM : 0 ≤ M)
(hbound : ∀ p, ‖g (p,y)‖ ≤ B) (hc : ‖c₀‖+‖c₁‖ ≤ M) :
‖residualData g a c₀ c₁ r f y‖ ≤ M*‖f‖*B := by
apply (norm_le_iff _ (by positivity)).mpr
intro x
rw [residualData_apply, norm_mul, norm_mul]
have hn : ‖c₁ x-c₀ (x-r • y)‖ ≤ M :=
(norm_sub_le _ _).trans <| (add_le_add (c₁.norm_coe_le_norm _) (c₀.norm_coe_le_norm _)).trans (by linarith)
calc
_ ≤ M*B*‖f‖ := mul_le_mul (mul_le_mul hn (hbound _) (norm_nonneg _) hM)
(apply_norm_le f _) (norm_nonneg _) (by positivity)
_ = _ := by ring
lemma continuous_residual_comp {X : Type*} [TopologicalSpace X] [FirstCountableTopology X]
(g : C(P × V,ℂ)) (a : X → V →ᵇ P) (c₀ c₁ : X → V →ᵇ ℂ)
(r : X → ℝ) (f : C₀(V,ℂ)) (ha : Continuous a) (h₀ : Continuous c₀) (h₁ : Continuous c₁)
(hr : Continuous r) (B : V → ℝ) (hB : Integrable B) (hBn : ∀ y, 0 ≤ B y)
(hbound : ∀ p y, ‖g (p,y)‖ ≤ B y) (M : ℝ) (hM : 0 ≤ M)
(hc : ∀ x, ‖c₀ x‖+‖c₁ x‖ ≤ M) :
Continuous (fun x => residual g (a x).toContinuousMap (c₀ x) (c₁ x) (r x) f) := by
apply continuous_of_dominated
(fun x => (integrable_residualData g (a x).toContinuousMap (c₀ x) (c₁ x) (r x) f B hB hBn hbound).aestronglyMeasurable)
(fun x => Eventually.of_forall (fun y => norm_residualData_le_uniform g (a x).toContinuousMap
(c₀ x) (c₁ x) (r x) f y (B y) M (hBn y) hM (fun p => hbound p y) (hc x)))
(hB.const_mul (M*‖f‖))
exact Eventually.of_forall (fun y => continuous_residualData_comp g a c₀ c₁ r
(fun _ => f) (fun _ => y) ha h₀ h₁ hr continuous_const continuous_const)
lemma residual_add (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f h : C₀(V,ℂ)) (B : V → ℝ) (hB : Integrable B)
(hBn : ∀ y, 0 ≤ B y) (hbound : ∀ p y, ‖g (p,y)‖ ≤ B y) :
residual g a c₀ c₁ r (f+h) = residual g a c₀ c₁ r f + residual g a c₀ c₁ r h := by
have he : residualData g a c₀ c₁ r (f+h) =
fun y => residualData g a c₀ c₁ r f y + residualData g a c₀ c₁ r h y := by
funext y
ext x
simp only [residualData_apply, ZeroAtInftyContinuousMap.add_apply]
ring
rw [residual, he, integral_add
(integrable_residualData g a c₀ c₁ r f B hB hBn hbound)
(integrable_residualData g a c₀ c₁ r h B hB hBn hbound)]
rfl
omit [BorelSpace V] [SecondCountableTopology V] in
lemma residual_smul (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (c : ℂ) (f : C₀(V,ℂ)) :
residual g a c₀ c₁ r (c • f) = c • residual g a c₀ c₁ r f := by
have he : residualData g a c₀ c₁ r (c • f) = fun y => c • residualData g a c₀ c₁ r f y := by
funext y
ext x
simp only [residualData_apply, ZeroAtInftyContinuousMap.smul_apply, smul_eq_mul]
ring
rw [residual, he, integral_smul]
rfl
omit [BorelSpace V] [SecondCountableTopology V] in
lemma norm_residual_le_uniform (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) (B : V → ℝ) (hB : Integrable B)
(hBn : ∀ y, 0 ≤ B y) (hbound : ∀ p y, ‖g (p,y)‖ ≤ B y) :
‖residual g a c₀ c₁ r f‖ ≤ ((‖c₀‖+‖c₁‖)*(∫ y, B y))*‖f‖ := by
calc
_ ≤ ∫ y, (‖c₀‖+‖c₁‖)*‖f‖*B y := norm_integral_le_of_norm_le
(hB.const_mul _) (Eventually.of_forall (fun y => norm_residualData_le_uniform g a c₀ c₁ r f y
(B y) (‖c₀‖+‖c₁‖) (hBn y) (by positivity) (fun p => hbound p y) le_rfl))
_ = _ := by rw [integral_const_mul]; ring
def residualCLM (g : C(P × V,ℂ)) (a : C(V,P)) (c₀ c₁ : V →ᵇ ℂ)
(r : ℝ) (B : V → ℝ) (hB : Integrable B) (hBn : ∀ y, 0 ≤ B y)
(hbound : ∀ p y, ‖g (p,y)‖ ≤ B y) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
LinearMap.mkContinuous
{ toFun := residual g a c₀ c₁ r
map_add' := fun f h => residual_add g a c₀ c₁ r f h B hB hBn hbound
map_smul' := fun c f => residual_smul g a c₀ c₁ r c f }
((‖c₀‖+‖c₁‖)*(∫ y, B y))
(fun f => norm_residual_le_uniform g a c₀ c₁ r f B hB hBn hbound)
end FrozenFamily
namespace FrozenParametrix
open scoped SchwartzMap ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel C0Convolution
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
def frozenOp {α β : ℝ} (hα : 0 < α) (a : C(V,Icc α β)) (r : ℝ) (f : C₀(V,ℂ)) : C₀(V,ℂ) :=
frozen (fun x => (a x).val) (continuous_subtype_val.comp a.continuous) α β hα
(fun x => (a x).property) r f
lemma kernel_majorant_nonneg (α β : ℝ) (hα : 0 < α) :
∃ B : V → ℝ, Integrable B ∧ (∀ y, 0 ≤ B y) ∧
∀ t ∈ Icc α β, ∀ y : V, ‖kernel t y‖ ≤ B y := by
obtain ⟨B,hB,hbound⟩ := kernel_majorant (V := V) α β hα
exact ⟨fun y => |B y|, hB.norm, fun y => abs_nonneg _,
fun t ht y => (hbound t ht y).trans (le_abs_self _)⟩
def kernelMajorant (α β : ℝ) (hα : 0 < α) : V → ℝ :=
(kernel_majorant_nonneg (V := V) α β hα).choose
lemma kernelMajorant_spec (α β : ℝ) (hα : 0 < α) :
Integrable (kernelMajorant (V := V) α β hα) ∧
(∀ y, 0 ≤ kernelMajorant (V := V) α β hα y) ∧
∀ t ∈ Icc α β, ∀ y : V, ‖kernel t y‖ ≤ kernelMajorant α β hα y :=
(kernel_majorant_nonneg (V := V) α β hα).choose_spec
def frozenCLM {α β : ℝ} (hα : 0 < α) (a : C(V,Icc α β)) (r : ℝ) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
LinearMap.mkContinuous
{ toFun := frozenOp hα a r
map_add' := fun f g => frozen_add (fun x => (a x).val) (continuous_subtype_val.comp a.continuous) α β hα (fun x => (a x).property) r f g
map_smul' := fun c f => frozen_smul (fun x => (a x).val) (continuous_subtype_val.comp a.continuous) α β hα (fun x => (a x).property) r c f }
(∫ y : V, kernelMajorant α β hα y)
(fun f => norm_frozen_le (fun x => (a x).val) (continuous_subtype_val.comp a.continuous) α β hα (fun x => (a x).property) r f _
(kernelMajorant_spec α β hα).1 (kernelMajorant_spec α β hα).2.2)
@[simp] lemma frozenCLM_apply {α β : ℝ} (hα : 0 < α) (a : C(V,Icc α β)) (r : ℝ) (f : C₀(V,ℂ)) :
frozenCLM hα a r f = frozenOp hα a r f := rfl
lemma norm_frozenCLM_le {α β : ℝ} (hα : 0 < α) (a : C(V,Icc α β)) (r : ℝ) :
‖frozenCLM hα a r‖ ≤ ∫ y : V, kernelMajorant α β hα y := by
apply ContinuousLinearMap.opNorm_le_bound (frozenCLM hα a r)
(integral_nonneg (kernelMajorant_spec α β hα).2.1)
intro f
exact norm_frozen_le (fun x => (a x).val) (continuous_subtype_val.comp a.continuous) α β hα (fun x => (a x).property) r f _
(kernelMajorant_spec α β hα).1 (kernelMajorant_spec α β hα).2.2
def kernelFamilyCM (α β : ℝ) (hα : 0 < α) : C(Icc α β × V,ℂ) :=
⟨fun p => kernel p.1.val p.2,
continuous_kernel_comp (fun p : Icc α β × V => p.1.val) Prod.snd
(continuous_subtype_val.comp continuous_fst) continuous_snd
(fun p => hα.trans_le p.1.property.1)⟩
lemma continuous_frozenOp_comp {X : Type*} [TopologicalSpace X] [FirstCountableTopology X]
{α β : ℝ} (hα : 0 < α) (a : X → V →ᵇ Icc α β) (r : X → ℝ)
(ha : Continuous a) (hr : Continuous r) (f : C₀(V,ℂ)) :
Continuous (fun x => frozenOp hα (a x).toContinuousMap (r x) f) := by
have he (x : X) : frozenOp hα (a x).toContinuousMap (r x) f =
∫ y : V, C0Convolution.translate (r x • y) (FrozenFamily.data (kernelFamilyCM α β hα) (a x).toContinuousMap f y) :=
frozen_eq_integral (fun z => (a x z).val) (continuous_subtype_val.comp (a x).continuous) α β hα (fun z => (a x z).property) (r x) f
simp_rw [he]
apply continuous_of_dominated (bound := fun y => kernelMajorant α β hα y*‖f‖)
· intro x
exact (integrable_translated_sourceData (fun z => (a x z).val) (continuous_subtype_val.comp (a x).continuous) α β hα (fun z => (a x z).property) (r x) f).aestronglyMeasurable
· intro x
filter_upwards with y
rw [norm_translate]
exact FrozenFamily.norm_data_le (kernelFamilyCM α β hα) (a x).toContinuousMap f y (kernelMajorant α β hα y) ((kernelMajorant_spec α β hα).2.1 y)
(fun p => (kernelMajorant_spec α β hα).2.2 p.val p.property y)
· exact (kernelMajorant_spec α β hα).1.mul_const ‖f‖
· exact Eventually.of_forall (fun y => continuous_translate_comp _ _
(hr.smul continuous_const) (FrozenFamily.continuous_data_comp (kernelFamilyCM α β hα)
a (fun _ => f) (fun _ => y) ha continuous_const continuous_const))
omit [InnerProductSpace ℝ V] [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
lemma continuous_coefficient_comp {X : Type*} [TopologicalSpace X] {α β : ℝ}
(a : X → V →ᵇ Icc α β) (ha : Continuous a) :
Continuous (fun x => coefficient (a x).toContinuousMap) := by
exact CompactComposition.continuous_compose.comp (continuous_const.prodMk ha)
omit [InnerProductSpace ℝ V] [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
lemma norm_coefficient_le {α β : ℝ} (a : C(V,Icc α β)) :
‖coefficient a‖ ≤ max |α| |β| := by
apply (BoundedContinuousFunction.norm_le (le_trans (abs_nonneg α) (le_max_left _ _))).mpr
intro x
simp only [coefficient_apply, Complex.norm_real, Real.norm_eq_abs]
apply abs_le.mpr
exact ⟨(neg_le_neg (le_max_left |α| |β|)).trans ((neg_abs_le α).trans (a x).property.1),
(a x).property.2.trans ((le_abs_self β).trans (le_max_right _ _))⟩
def bilapMajorant (α β : ℝ) (hα : 0 < α) : V → ℝ :=
(bilapKernel_weighted_majorant (V := V) α β hα).choose
lemma bilapMajorant_spec (α β : ℝ) (hα : 0 < α) :
Integrable (bilapMajorant (V := V) α β hα) ∧
Integrable (fun y : V => (1+‖y‖)*bilapMajorant α β hα y) ∧
(∀ y, 0 ≤ bilapMajorant (V := V) α β hα y) ∧
∀ t ∈ Icc α β, ∀ y : V, ‖bilapKernel t y‖ ≤ bilapMajorant α β hα y :=
(bilapKernel_weighted_majorant (V := V) α β hα).choose_spec
def principalCLM {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β)) (r : ℝ) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
(r⁻¹)^4 • FrozenFamily.residualCLM (bilapFamily α β hα) a₀
(coefficient a₀) (coefficient a₁) r (bilapMajorant α β hα)
(bilapMajorant_spec α β hα).1 (bilapMajorant_spec α β hα).2.2.1
(fun p y => (bilapMajorant_spec α β hα).2.2.2 p.val p.property y)
@[simp] lemma principalCLM_apply {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β)) (r : ℝ) (f : C₀(V,ℂ)) :
principalCLM hα a₀ a₁ r f = principalResidual hα a₀ a₁ r f := rfl
lemma continuous_principalCLM_apply {X : Type*} [TopologicalSpace X] [FirstCountableTopology X]
{α β : ℝ} (hα : 0 < α) (a₀ a₁ : X → V →ᵇ Icc α β) (r : X → ℝ)
(h₀ : Continuous a₀) (h₁ : Continuous a₁) (hr : Continuous r) (hr0 : ∀ x, r x ≠ 0) (f : C₀(V,ℂ)) :
Continuous (fun x => principalCLM hα (a₀ x).toContinuousMap (a₁ x).toContinuousMap (r x) f) := by
change Continuous (fun x => (r x)⁻¹^4 • FrozenFamily.residual (bilapFamily α β hα)
(a₀ x).toContinuousMap (coefficient (a₀ x).toContinuousMap) (coefficient (a₁ x).toContinuousMap) (r x) f)
apply ((hr.inv₀ hr0).pow 4).smul
apply FrozenFamily.continuous_residual_comp _ a₀ _ _ r f h₀
(continuous_coefficient_comp a₀ h₀) (continuous_coefficient_comp a₁ h₁) hr
(bilapMajorant α β hα) (bilapMajorant_spec α β hα).1 (bilapMajorant_spec α β hα).2.2.1
(fun p y => (bilapMajorant_spec α β hα).2.2.2 p.val p.property y)
(2*max |α| |β|) (by positivity)
intro x
linarith [norm_coefficient_le (a₀ x).toContinuousMap, norm_coefficient_le (a₁ x).toContinuousMap]
def fullResidualCLM {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β)) (b : V →ᵇ ℂ)
(r : ℝ) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
principalCLM hα a₀ a₁ r + (C0Multiplier.mulLeftCLM b).comp (frozenCLM hα a₀ r)
lemma fullResidualCLM_apply {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β)) (b : V →ᵇ ℂ)
(r : ℝ) (f : C₀(V,ℂ)) :
fullResidualCLM hα a₀ a₁ b r f = principalResidual hα a₀ a₁ r f + C0Multiplier.mul b (frozenOp hα a₀ r f) := rfl
lemma continuous_fullResidualCLM_apply {X : Type*} [TopologicalSpace X] [FirstCountableTopology X]
{α β : ℝ} (hα : 0 < α) (a₀ a₁ : X → V →ᵇ Icc α β) (b : X → V →ᵇ ℂ) (r : X → ℝ)
(h₀ : Continuous a₀) (h₁ : Continuous a₁) (hb : Continuous b)
(hr : Continuous r) (hr0 : ∀ x, r x ≠ 0) (f : C₀(V,ℂ)) :
Continuous (fun x => fullResidualCLM hα (a₀ x).toContinuousMap (a₁ x).toContinuousMap (b x) (r x) f) := by
simp_rw [fullResidualCLM_apply]
exact (continuous_principalCLM_apply hα a₀ a₁ r h₀ h₁ hr hr0 f).add
(C0Multiplier.continuous_mul_joint.comp (hb.prodMk (continuous_frozenOp_comp hα a₀ r h₀ hr f)))
lemma exists_uniform_fullResidual_bound (α β : ℝ) (hα : 0 < α) (L B : ℝ) (hL : 0 ≤ L) (hB : 0 ≤ B) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (a₀ a₁ : C(V,Icc α β)) (b : V →ᵇ ℂ) (r : ℝ),
0 < r → r ≤ 1 → ‖b‖ ≤ B →
(∀ x z, |(a₁ x).val-(a₀ z).val| ≤ L*(‖x-z‖+r^4)) →
‖fullResidualCLM hα a₀ a₁ b r‖ ≤ C*(r⁻¹)^3 := by
obtain ⟨C,hC,hbound⟩ := exists_uniform_principalResidual_bound (V := V) α β hα L hL
let M := ∫ y : V, kernelMajorant α β hα y
have hM : 0 ≤ M := integral_nonneg (kernelMajorant_spec α β hα).2.1
refine ⟨C+B*M,by positivity,fun a₀ a₁ b r hr hr1 hb hLip => ?_⟩
apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
intro f
rw [fullResidualCLM_apply]
have hrinv : 1 ≤ (r⁻¹)^3 := one_le_pow₀ ((one_le_inv₀ hr).mpr hr1)
have hK : ‖frozenOp hα a₀ r f‖ ≤ M*‖f‖ := by
exact norm_frozen_le (fun x => (a₀ x).val) (continuous_subtype_val.comp a₀.continuous)
α β hα (fun x => (a₀ x).property) r f _
(kernelMajorant_spec α β hα).1 (kernelMajorant_spec α β hα).2.2
calc
_ ≤ ‖principalResidual hα a₀ a₁ r f‖+‖C0Multiplier.mul b (frozenOp hα a₀ r f)‖ := norm_add_le _ _
_ ≤ C*(r⁻¹)^3*‖f‖+B*(M*‖f‖) := add_le_add (hbound a₀ a₁ r hr hr1 hLip f)
((C0Multiplier.norm_mul_le b _).trans (mul_le_mul hb hK (norm_nonneg _) hB))
_ ≤ C*(r⁻¹)^3*‖f‖+B*(M*‖f‖)*(r⁻¹)^3 :=
add_le_add le_rfl (le_mul_of_one_le_right (show 0 ≤ B*(M*‖f‖) by positivity) hrinv)
_ = _ := by ring
end FrozenParametrix
open Set Filter MeasureTheory
open scoped Topology BoundedContinuousFunction
namespace StrongWeightedVolterra
abbrev UnitTime := Ioo (0 : ℝ) 1
abbrev Time (T : ℝ) := Ioc (0 : ℝ) T
instance : MeasureSpace UnitTime := Measure.Subtype.measureSpace
def weight (u : UnitTime) : ℝ := u.val ^ (-3/4 : ℝ) * (1-u.val)^(-3/4 : ℝ)
lemma weight_nonneg (u : UnitTime) : 0 ≤ weight u := by
exact mul_nonneg (Real.rpow_nonneg u.property.1.le _) (Real.rpow_nonneg (by linarith [u.property.2]) _)
lemma continuous_weight : Continuous weight := by
apply Continuous.mul
· exact continuous_subtype_val.rpow_const (fun u => Or.inl u.property.1.ne')
· exact (continuous_const.sub continuous_subtype_val).rpow_const
(fun u => Or.inl (sub_pos.mpr u.property.2).ne')
lemma integrable_weight : Integrable weight := by
have hb := (Complex.betaIntegral_convergent
(u := (1/4 : ℂ)) (v := (1/4 : ℂ)) (by norm_num) (by norm_num)).norm.1
have hi := hb.mono_set Ioo_subset_Ioc_self
have he : EqOn (fun x : ℝ => ‖(x : ℂ)^((1/4 : ℂ)-1) *
(1-(x : ℂ))^((1/4 : ℂ)-1)‖)
(fun x : ℝ => x^(-3/4 : ℝ)*(1-x)^(-3/4 : ℝ)) (Ioo 0 1) := by
intro x hx
dsimp only
rw [norm_mul]
have hq : (1/4 : ℂ)-1 = ((-3/4 : ℝ) : ℂ) := by norm_num
rw [hq, show (1 : ℂ)-(x : ℂ) = ((1-x : ℝ) : ℂ) by push_cast; rfl,
Complex.norm_cpow_real, Complex.norm_cpow_real,
Complex.norm_real, Complex.norm_real, Real.norm_eq_abs, Real.norm_eq_abs,
abs_of_pos hx.1, abs_of_pos (sub_pos.mpr hx.2)]
have hw := hi.congr_fun he measurableSet_Ioo
exact (integrableOn_iff_comap_subtypeVal measurableSet_Ioo).mp hw
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
variable {T : ℝ}
def lag (t : Time T) (u : UnitTime) : Time T :=
⟨t.val*u.val, mul_pos t.property.1 u.property.1,
(mul_le_of_le_one_right t.property.1.le u.property.2.le).trans t.property.2⟩
lemma continuous_lag : Continuous (fun p : Time T × UnitTime => lag p.1 p.2) := by
exact (continuous_subtype_val.comp continuous_fst |>.mul
(continuous_subtype_val.comp continuous_snd)).subtype_mk _
structure Kernel (T : ℝ) (E : Type*) [NormedAddCommGroup E] [NormedSpace ℂ E] where
toFun : Time T × UnitTime → E →L[ℂ] E
continuous_apply : Continuous (fun p : (Time T × UnitTime) × E => toFun p.1 p.2)
instance : CoeFun (Kernel T E) (fun _ => Time T × UnitTime → E →L[ℂ] E) := ⟨Kernel.toFun⟩
lemma continuous_apply_of_strong {X : Type*} [TopologicalSpace X]
(A : X → E →L[ℂ] E) (hA : ∀ f, Continuous (fun x => A x f))
(C : ℝ) (_hC : 0 ≤ C) (hbound : ∀ x, ‖A x‖ ≤ C) :
Continuous (fun p : X × E => A p.1 p.2) := by
apply continuous_iff_continuousAt.mpr
rintro ⟨x,f⟩
have hb := ((hA f).comp continuous_fst).tendsto (x,f)
apply hb.congr_dist
apply squeeze_zero (fun p => dist_nonneg) (fun p => ?_)
(show Tendsto (fun p : X × E => C*dist f p.2) (𝓝 (x,f)) (𝓝 0) from
by
have hd : Continuous (fun p : X × E => C*dist f p.2) := by fun_prop
simpa using hd.tendsto (x,f))
dsimp only [Function.comp_apply]
rw [dist_eq_norm, ← map_sub, dist_eq_norm]
exact (A p.1).le_opNorm _ |>.trans (mul_le_mul_of_nonneg_right (hbound _) (norm_nonneg _))
def Kernel.ofStrong (A : Time T × UnitTime → E →L[ℂ] E)
(hA : ∀ f, Continuous (fun p => A p f)) (C : ℝ) (hC : 0 ≤ C)
(hbound : ∀ p, ‖A p‖ ≤ C) : Kernel T E :=
⟨A, continuous_apply_of_strong A hA C hC hbound⟩
variable (N : Kernel T E) (C : ℝ)
(hC : 0 ≤ C) (hN : ∀ p, ‖N p‖ ≤ C)
def data (j : Time T →ᵇ E) (t : Time T) (u : UnitTime) : E :=
weight u • N (t,u) (j (lag t u))
lemma continuous_data (j : Time T →ᵇ E) :
Continuous (fun p : Time T × UnitTime => data N j p.1 p.2) := by
exact (continuous_weight.comp continuous_snd).smul
(N.continuous_apply.comp (continuous_id.prodMk (j.continuous.comp continuous_lag)))
include hC hN
lemma norm_data_le (j : Time T →ᵇ E) (t : Time T) (u : UnitTime) :
‖data N j t u‖ ≤ weight u * (C*‖j‖) := by
rw [data, norm_smul, Real.norm_eq_abs, abs_of_nonneg (weight_nonneg u)]
apply mul_le_mul_of_nonneg_left _ (weight_nonneg u)
exact (N (t,u)).le_opNorm _ |>.trans (mul_le_mul (hN _) (j.norm_coe_le_norm _)
(norm_nonneg _) hC)
lemma integrable_data (j : Time T →ᵇ E) (t : Time T) : Integrable (data N j t) := by
exact (integrable_weight.mul_const (C*‖j‖)).mono'
((continuous_data N j).comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable
(Eventually.of_forall (norm_data_le N C hC hN j t))
lemma continuous_integral_data (j : Time T →ᵇ E) :
Continuous (fun t => ∫ u : UnitTime, data N j t u) := by
apply continuous_of_dominated
(fun t => (integrable_data N C hC hN j t).aestronglyMeasurable)
(fun t => Eventually.of_forall (norm_data_le N C hC hN j t))
(integrable_weight.mul_const (C*‖j‖))
exact Eventually.of_forall (fun u =>
(continuous_data N j).comp (continuous_id.prodMk continuous_const))
lemma norm_integral_data_le (j : Time T →ᵇ E) (t : Time T) :
‖∫ u : UnitTime, data N j t u‖ ≤ (∫ u : UnitTime, weight u)*C*‖j‖ := by
calc
_ ≤ ∫ u : UnitTime, weight u*(C*‖j‖) :=
norm_integral_le_of_norm_le (integrable_weight.mul_const _) <|
Eventually.of_forall (norm_data_le N C hC hN j t)
_ = _ := by rw [integral_mul_const]; ring
omit hC hN in
def value (j : Time T →ᵇ E) (t : Time T) : E :=
t.val^(1/4 : ℝ) • ∫ u : UnitTime, data N j t u
lemma continuous_value (j : Time T →ᵇ E) : Continuous (value N j) :=
(continuous_subtype_val.rpow_const (fun t => Or.inl t.property.1.ne')).smul
(continuous_integral_data N C hC hN j)
lemma norm_value_le (hT : 0 ≤ T) (j : Time T →ᵇ E) (t : Time T) :
‖value N j t‖ ≤ (T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C)*‖j‖ := by
rw [value, norm_smul, Real.norm_eq_abs, abs_of_nonneg (Real.rpow_nonneg t.property.1.le _)]
calc
_ ≤ T^(1/4 : ℝ) * ((∫ u : UnitTime, weight u)*C*‖j‖) :=
mul_le_mul (Real.rpow_le_rpow t.property.1.le t.property.2 (by norm_num))
(norm_integral_data_le N C hC hN j t) (norm_nonneg _)
(Real.rpow_nonneg hT _)
_ = _ := by ring
def operator (hT : 0 ≤ T) (j : Time T →ᵇ E) : Time T →ᵇ E :=
.mkOfBound ⟨value N j, continuous_value N C hC hN j⟩
(2*((T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C)*‖j‖)) (by
intro x y
exact (dist_le_norm_add_norm _ _).trans <| by
dsimp
linarith [norm_value_le N C hC hN hT j x, norm_value_le N C hC hN hT j y])
@[simp] lemma operator_apply (hT : 0 ≤ T) (j : Time T →ᵇ E) (t : Time T) :
operator N C hC hN hT j t = value N j t := rfl
lemma norm_operator_le (hT : 0 ≤ T) (j : Time T →ᵇ E) :
‖operator N C hC hN hT j‖ ≤ (T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C)*‖j‖ := by
apply (BoundedContinuousFunction.norm_le (by
apply mul_nonneg _ (norm_nonneg _)
exact mul_nonneg (mul_nonneg (Real.rpow_nonneg hT _) (integral_nonneg weight_nonneg)) hC)).mpr
exact norm_value_le N C hC hN hT j
lemma operator_add (hT : 0 ≤ T) (j k : Time T →ᵇ E) :
operator N C hC hN hT (j+k) = operator N C hC hN hT j + operator N C hC hN hT k := by
ext t
simp only [operator_apply, BoundedContinuousFunction.add_apply, value]
have hd : (fun u => data N (j+k) t u) = (fun u => data N j t u+data N k t u) := by
funext u
simp [data, map_add, smul_add]
rw [hd, integral_add (integrable_data N C hC hN j t) (integrable_data N C hC hN k t), smul_add]
lemma operator_smul (hT : 0 ≤ T) (c : ℂ) (j : Time T →ᵇ E) :
operator N C hC hN hT (c • j) = c • operator N C hC hN hT j := by
ext t
simp only [operator_apply, BoundedContinuousFunction.smul_apply, value]
have hd : (fun u => data N (c • j) t u) = (fun u => c • data N j t u) := by
funext u
simp only [data, BoundedContinuousFunction.smul_apply, map_smul]
exact smul_comm _ _ _
rw [hd, integral_smul, smul_comm]
def operatorCLM (hT : 0 ≤ T) : (Time T →ᵇ E) →L[ℂ] (Time T →ᵇ E) :=
LinearMap.mkContinuous
{ toFun := operator N C hC hN hT
map_add' := operator_add N C hC hN hT
map_smul' := operator_smul N C hC hN hT }
(T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C)
(norm_operator_le N C hC hN hT)
lemma norm_operatorCLM_le (hT : 0 ≤ T) :
‖operatorCLM N C hC hN hT‖ ≤ T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C := by
apply ContinuousLinearMap.opNorm_le_bound _
(mul_nonneg (mul_nonneg (Real.rpow_nonneg hT _) (integral_nonneg weight_nonneg)) hC)
exact norm_operator_le N C hC hN hT
theorem exists_unique_solution [CompleteSpace E] (hT : 0 ≤ T)
(hsmall : T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C < 1) (g : Time T →ᵇ E) :
∃! j : Time T →ᵇ E, j + operator N C hC hN hT j = g := by
let A := operatorCLM N C hC hN hT
have hA : ‖A‖ < 1 := (norm_operatorCLM_le N C hC hN hT).trans_lt hsmall
let f : (Time T →ᵇ E) → (Time T →ᵇ E) := fun j => g-A j
have hf : ContractingWith ‖A‖₊ f := by
refine ⟨hA, LipschitzWith.of_dist_le_mul (fun j k => ?_)⟩
rw [dist_eq_norm, dist_eq_norm]
change ‖(g-A j)-(g-A k)‖ ≤ ‖A‖*‖j-k‖
rw [sub_sub_sub_cancel_left, ← A.map_sub, norm_sub_rev j k]
exact A.le_opNorm (k-j)
refine ⟨hf.fixedPoint, ?_, fun j hj => ?_⟩
· have hx := hf.fixedPoint_isFixedPt
change g-A hf.fixedPoint = hf.fixedPoint at hx
change hf.fixedPoint + A hf.fixedPoint = g
exact (eq_sub_iff_add_eq.mp hx.symm)
· apply hf.fixedPoint_unique
change g-A j = j
change j + A j = g at hj
exact (eq_sub_iff_add_eq.mpr hj).symm
lemma norm_solution_le (hT : 0 ≤ T)
(hsmall : T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C < 1)
(g j : Time T →ᵇ E) (hj : j+operator N C hC hN hT j=g) :
‖j‖ ≤ ‖g‖/(1-T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C) := by
have hpos := sub_pos.mpr hsmall
apply (le_div_iff₀ hpos).mpr
have hb := norm_operator_le N C hC hN hT j
have hjg : j = g-operator N C hC hN hT j := eq_sub_iff_add_eq.mpr hj
have hn := norm_sub_le g (operator N C hC hN hT j)
rw [← hjg] at hn
nlinarith
omit hC hN in
def unweighted (j : Time T →ᵇ E) (r : ℝ) : E :=
if hr : r ∈ Time T then r^(-3/4 : ℝ) • j ⟨r,hr⟩ else 0
omit hC hN in
lemma unweighted_lag (j : Time T →ᵇ E) (t : Time T) (u : UnitTime) :
unweighted j (t.val*u.val) = (t.val*u.val)^(-3/4 : ℝ) • j (lag t u) := by
have hr : t.val*u.val ∈ Time T := (lag t u).property
rw [unweighted, dite_eq_left hr]
rfl
omit hC hN in
def normalizedArg (t : Time T) (r : ℝ) (hr : r ∈ Ioo 0 t.val) : UnitTime :=
⟨r/t.val, div_pos hr.1 t.property.1, (div_lt_one t.property.1).mpr hr.2⟩
omit hC hN in
def kernel (t : Time T) (r : ℝ) : E →L[ℂ] E :=
if hr : r ∈ Ioo 0 t.val then
(t.val-r)^(-3/4 : ℝ) • N (t,normalizedArg t r hr) else 0
omit hC hN in
lemma normalizedArg_lag (t : Time T) (u : UnitTime)
(hr : t.val*u.val ∈ Ioo 0 t.val) : normalizedArg t (t.val*u.val) hr = u := by
apply Subtype.ext
change t.val*u.val/t.val = u.val
field_simp [t.property.1.ne']
omit hC hN in
lemma kernel_lag (t : Time T) (u : UnitTime) :
kernel N t (t.val*u.val) = (t.val*(1-u.val))^(-3/4 : ℝ) • N (t,u) := by
have hr : t.val*u.val ∈ Ioo 0 t.val :=
⟨mul_pos t.property.1 u.property.1, mul_lt_of_lt_one_right t.property.1 u.property.2⟩
rw [kernel, dite_eq_left hr, normalizedArg_lag]
congr 2
ring
omit hC hN in
lemma rescaling_scalar (t u : ℝ) (ht : 0 < t) (hu : 0 < u) (hu1 : u < 1) :
t^(3/4 : ℝ)*t*((t*(1-u))^(-3/4 : ℝ)*(t*u)^(-3/4 : ℝ)) =
t^(1/4 : ℝ)*(u^(-3/4 : ℝ)*(1-u)^(-3/4 : ℝ)) := by
rw [Real.mul_rpow ht.le (sub_pos.mpr hu1).le, Real.mul_rpow ht.le hu.le]
have hprod : t^(3/4 : ℝ)*t*t^(-3/4 : ℝ)*t^(-3/4 : ℝ) = t^(1/4 : ℝ) := by
calc
_ = t^(3/4 : ℝ)*t^(1 : ℝ)*t^(-3/4 : ℝ)*t^(-3/4 : ℝ) := by rw [Real.rpow_one]
_ = t^((3/4:ℝ)+1+(-3/4)+(-3/4)) := by rw [Real.rpow_add ht, Real.rpow_add ht, Real.rpow_add ht]
_ = _ := by norm_num
calc
_ = (t^(3/4 : ℝ)*t*t^(-3/4 : ℝ)*t^(-3/4 : ℝ))*
(u^(-3/4 : ℝ)*(1-u)^(-3/4 : ℝ)) := by ring
_ = _ := by rw [hprod]
omit hC hN in
lemma value_eq_volterra (j : Time T →ᵇ E) (t : Time T) :
value N j t = t.val^(3/4 : ℝ) •
∫ r in 0..t.val, kernel N t r (unweighted j r) := by
let F : ℝ → E := fun r => kernel N t r (unweighted j r)
have hc := intervalIntegral.smul_integral_comp_mul_left (a := 0) (b := 1) F t.val
simp only [mul_zero, mul_one] at hc
change value N j t = t.val^(3/4 : ℝ) • ∫ r in 0..t.val, F r
rw [← hc, intervalIntegral.integral_of_le (by norm_num : (0:ℝ) ≤ 1),
integral_Ioc_eq_integral_Ioo, ← integral_subtype measurableSet_Ioo]
rw [← integral_smul, ← integral_smul]
unfold value
rw [← integral_smul]
apply integral_congr_ae
apply Eventually.of_forall
intro u
dsimp [F]
rw [kernel_lag, unweighted_lag, smul_apply, ContinuousLinearMap.map_smul_of_tower]
simp only [data, smul_smul]
congr 1
simpa only [weight, mul_assoc] using
(rescaling_scalar t.val u.val t.property.1 u.property.1 u.property.2).symm
omit hC hN in
lemma unweighted_at_time (j : Time T →ᵇ E) (t : Time T) :
unweighted j t.val = t.val^(-3/4 : ℝ) • j t := by
rw [unweighted, dite_eq_left t.property]
omit hC hN in
lemma kernel_unweighted_lag (j : Time T →ᵇ E) (t : Time T) (u : UnitTime) :
kernel N t (t.val*u.val) (unweighted j (t.val*u.val)) =
(t.val^(-3/4 : ℝ)*t.val^(-3/4 : ℝ)) • data N j t u := by
rw [kernel_lag, unweighted_lag, smul_apply, ContinuousLinearMap.map_smul_of_tower]
simp only [data, smul_smul]
congr 1
rw [Real.mul_rpow t.property.1.le (sub_pos.mpr u.property.2).le,
Real.mul_rpow t.property.1.le u.property.1.le, weight]
ring
lemma intervalIntegrable_kernel_unweighted (j : Time T →ᵇ E) (t : Time T) :
IntervalIntegrable (fun r => kernel N t r (unweighted j r)) volume 0 t.val := by
have hi : Integrable (fun u : UnitTime =>
kernel N t (t.val*u.val) (unweighted j (t.val*u.val))) := by
simp_rw [kernel_unweighted_lag]
exact (integrable_data N C hC hN j t).smul _
have hs : IntegrableOn (fun u : ℝ =>
kernel N t (t.val*u) (unweighted j (t.val*u))) (Ioo 0 1) :=
(integrableOn_iff_comap_subtypeVal measurableSet_Ioo).mpr hi
have hii := (intervalIntegrable_iff_integrableOn_Ioo_of_le (by norm_num : (0:ℝ) ≤ 1)).mpr hs
apply (IntervalIntegrable.comp_mul_left_iff (a := 0) (b := t.val) t.property.1.ne').mp
simpa only [zero_div, div_self t.property.1.ne'] using hii
lemma unweighted_solves (hT : 0 ≤ T) (g j : Time T →ᵇ E)
(hj : j+operator N C hC hN hT j=g) (t : Time T) :
unweighted j t.val + ∫ r in 0..t.val, kernel N t r (unweighted j r) =
unweighted g t.val := by
have ht : t.val^(-3/4 : ℝ)*t.val^(3/4 : ℝ)=1 := by
rw [← Real.rpow_add t.property.1]
norm_num
have he : j t+value N j t=g t := congrArg (fun k : Time T →ᵇ E => k t) hj
rw [unweighted_at_time, unweighted_at_time]
calc
_ = t.val^(-3/4 : ℝ) • (j t+value N j t) := by
rw [smul_add, value_eq_volterra, smul_smul, ht, one_smul]
_ = _ := by rw [he]
theorem exists_unweighted_solution [CompleteSpace E] (hT : 0 ≤ T)
(hsmall : T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C < 1)
(g : Time T →ᵇ E) :
∃ j : Time T →ᵇ E,
(∀ t : Time T, IntervalIntegrable (fun r => kernel N t r (unweighted j r)) volume 0 t.val) ∧
(∀ t : Time T, unweighted j t.val +
∫ r in 0..t.val, kernel N t r (unweighted j r) = unweighted g t.val) ∧
(∀ t : Time T, ‖unweighted j t.val‖ ≤ t.val^(-3/4 : ℝ) *
(‖g‖/(1-T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C))) := by
obtain ⟨j,hj,_⟩ := exists_unique_solution N C hC hN hT hsmall g
refine ⟨j, intervalIntegrable_kernel_unweighted N C hC hN j,
unweighted_solves N C hC hN hT g j hj, fun t => ?_⟩
rw [unweighted_at_time, norm_smul, Real.norm_eq_abs,
abs_of_nonneg (Real.rpow_nonneg t.property.1.le _)]
exact mul_le_mul_of_nonneg_left
((j.norm_coe_le_norm t).trans (norm_solution_le N C hC hN hT hsmall g j hj))
(Real.rpow_nonneg t.property.1.le _)
end StrongWeightedVolterra
open Set Filter
open scoped Topology
namespace ParabolicRadius
def radius (q : ℝ) : ℝ := q^(1/4 : ℝ)
lemma pos {q : ℝ} (hq : 0 < q) : 0 < radius q := Real.rpow_pos_of_pos hq _
lemma nonneg {q : ℝ} (hq : 0 ≤ q) : 0 ≤ radius q := Real.rpow_nonneg hq _
lemma pow_four {q : ℝ} (hq : 0 ≤ q) : radius q ^ 4 = q := by
rw [radius, ← Real.rpow_natCast, ← Real.rpow_mul hq]
norm_num
lemma pow_three {q : ℝ} (hq : 0 ≤ q) : radius q ^ 3 = q^(3/4 : ℝ) := by
rw [radius, ← Real.rpow_natCast, ← Real.rpow_mul hq]
norm_num
lemma inv_pow_three {q : ℝ} (hq : 0 ≤ q) : (radius q)⁻¹ ^ 3 = q^(-3/4 : ℝ) := by
rw [inv_pow, pow_three hq, ← Real.rpow_neg hq]
congr 1
norm_num
lemma le_one {q : ℝ} (hq : 0 ≤ q) (hq1 : q ≤ 1) : radius q ≤ 1 :=
Real.rpow_le_one hq hq1 (by positivity)
lemma continuous_comp {X : Type*} [TopologicalSpace X] (q : X → ℝ)
(hq : Continuous q) : Continuous (fun x => radius (q x)) :=
hq.rpow_const (fun _ => Or.inr (by positivity))
lemma normalized_cancel {q : ℝ} (hq : 0 < q) :
q^(-3/4 : ℝ)*radius q^3=1 := by
rw [pow_three hq.le, ← Real.rpow_add hq]
norm_num
end ParabolicRadius
namespace ParametrixVolterra
section Slab
open scoped ZeroAtInfty BoundedContinuousFunction
open FrozenParametrix C0Convolution
open StrongWeightedVolterra
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {T α β : ℝ}
abbrev Slab (T : ℝ) := Icc (0 : ℝ) T
def now (t : Time T) : Slab T := ⟨t.val,t.property.1.le,t.property.2⟩
def before (p : Time T × UnitTime) : Slab T := now (lag p.1 p.2)
def elapsed (p : Time T × UnitTime) : ℝ := p.1.val*(1-p.2.val)
lemma continuous_now : Continuous (now : Time T → Slab T) := continuous_subtype_val.subtype_mk _
lemma continuous_before : Continuous (before : Time T × UnitTime → Slab T) :=
continuous_now.comp continuous_lag
lemma continuous_elapsed : Continuous (elapsed : Time T × UnitTime → ℝ) := by
unfold elapsed
fun_prop
lemma elapsed_pos (p : Time T × UnitTime) : 0 < elapsed p :=
mul_pos p.1.property.1 (sub_pos.mpr p.2.property.2)
lemma elapsed_le (p : Time T × UnitTime) : elapsed p ≤ T := by
have hu : 1-p.2.val ≤ 1 := by linarith [p.2.property.1]
exact (mul_le_of_le_one_right p.1.property.1.le hu).trans p.1.property.2
lemma elapsed_eq_sub (p : Time T × UnitTime) : elapsed p = (now p.1).val-(before p).val := by
dsimp [elapsed, now, before, lag]
ring
variable (hα : 0 < α) (A : C(Slab T, V →ᵇ Icc α β)) (b : C(Slab T, V →ᵇ ℂ))
def actualResidual (t : Time T) (s : Slab T) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
fullResidualCLM hα (A s).toContinuousMap (A (now t)).toContinuousMap (b (now t))
(ParabolicRadius.radius (t.val-s.val))
def normalized (p : Time T × UnitTime) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
ParabolicRadius.radius (elapsed p)^3 • actualResidual hα A b p.1 (before p)
lemma continuous_actualResidual_before (f : C₀(V,ℂ)) :
Continuous (fun p : Time T × UnitTime => actualResidual hα A b p.1 (before p) f) := by
have he (p : Time T × UnitTime) : p.1.val-(before p).val=elapsed p := (elapsed_eq_sub p).symm
unfold actualResidual
simp_rw [he]
apply continuous_fullResidualCLM_apply hα
(fun p => A (before p)) (fun p => A (now p.1)) (fun p => b (now p.1))
(fun p => ParabolicRadius.radius (elapsed p))
(A.continuous.comp continuous_before) (A.continuous.comp (continuous_now.comp continuous_fst))
(b.continuous.comp (continuous_now.comp continuous_fst))
(ParabolicRadius.continuous_comp _ continuous_elapsed)
exact fun p => (ParabolicRadius.pos (elapsed_pos p)).ne'
lemma continuous_normalized_apply (f : C₀(V,ℂ)) :
Continuous (fun p : Time T × UnitTime => normalized hα A b p f) := by
change Continuous (fun p => ParabolicRadius.radius (elapsed p)^3 • actualResidual hα A b p.1 (before p) f)
exact ((ParabolicRadius.continuous_comp _ continuous_elapsed).pow 3).smul
(continuous_actualResidual_before hα A b f)
lemma exists_normalized_bound (hT : T ≤ 1) (L B : ℝ) (hL : 0 ≤ L) (hB : 0 ≤ B)
(hb : ∀ s, ‖b s‖ ≤ B)
(hLip : ∀ s r : Slab T, ∀ x z : V,
|(A s x).val-(A r z).val| ≤ L*(‖x-z‖+|s.val-r.val|)) :
∃ C : ℝ, 0 ≤ C ∧ ∀ p : Time T × UnitTime, ‖normalized hα A b p‖ ≤ C := by
obtain ⟨C,hC,hbound⟩ := exists_uniform_fullResidual_bound (V := V) α β hα L B hL hB
refine ⟨C,hC,fun p => ?_⟩
let r := ParabolicRadius.radius (elapsed p)
have hr : 0 < r := ParabolicRadius.pos (elapsed_pos p)
have hr1 : r ≤ 1 := ParabolicRadius.le_one (elapsed_pos p).le ((elapsed_le p).trans hT)
have hgap : |(now p.1).val-(before p).val| = r^4 := by
rw [← elapsed_eq_sub, abs_of_pos (elapsed_pos p), ParabolicRadius.pow_four (elapsed_pos p).le]
have hR : ‖actualResidual hα A b p.1 (before p)‖ ≤ C*(r⁻¹)^3 := by
unfold actualResidual
rw [show p.1.val-(before p).val = elapsed p from (elapsed_eq_sub p).symm]
apply hbound _ _ _ r hr hr1 (hb _)
intro x z
simpa only [hgap, BoundedContinuousFunction.coe_toContinuousMap] using hLip (now p.1) (before p) x z
apply ContinuousLinearMap.opNorm_le_bound _ hC
intro f
change ‖r^3 • actualResidual hα A b p.1 (before p) f‖ ≤ C*‖f‖
rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (pow_nonneg hr.le _)]
calc
_ ≤ r^3*(C*(r⁻¹)^3*‖f‖) := mul_le_mul_of_nonneg_left
((actualResidual hα A b p.1 (before p)).le_opNorm f |>.trans
(mul_le_mul_of_nonneg_right hR (norm_nonneg f))) (pow_nonneg hr.le _)
_ = C*‖f‖ := by field_simp
theorem exists_correction (hT₀ : 0 ≤ T) (hT : T ≤ 1) (L B : ℝ) (hL : 0 ≤ L) (hB : 0 ≤ B)
(hb : ∀ s, ‖b s‖ ≤ B)
(hLip : ∀ s r : Slab T, ∀ x z : V,
|(A s x).val-(A r z).val| ≤ L*(‖x-z‖+|s.val-r.val|)) :
∃ C : ℝ, 0 ≤ C ∧
(T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*C < 1 →
∀ g : Time T →ᵇ C₀(V,ℂ), ∃ j : Time T →ᵇ C₀(V,ℂ),
∀ t : Time T, j t +
t.val^(1/4 : ℝ) • ∫ u : UnitTime,
weight u • normalized hα A b (t,u) (j (lag t u)) = g t) := by
obtain ⟨C,hC,hbound⟩ := exists_normalized_bound hα A b hT L B hL hB hb hLip
refine ⟨C,hC,fun hsmall g => ?_⟩
let N : Kernel T C₀(V,ℂ) := Kernel.ofStrong (normalized hα A b)
(continuous_normalized_apply hα A b) C hC hbound
obtain ⟨j,hj,_⟩ := exists_unique_solution N C hC hbound hT₀ hsmall g
refine ⟨j,fun t => ?_⟩
exact congrArg (fun f : Time T →ᵇ C₀(V,ℂ) => f t) hj
lemma exists_actualResidual_bound (hT : T ≤ 1) (L B : ℝ) (hL : 0 ≤ L) (hB : 0 ≤ B)
(hb : ∀ s, ‖b s‖ ≤ B)
(hLip : ∀ s r : Slab T, ∀ x z : V,
|(A s x).val-(A r z).val| ≤ L*(‖x-z‖+|s.val-r.val|)) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (t : Time T) (s : Slab T), s.val<t.val →
‖actualResidual hα A b t s‖ ≤ C*(t.val-s.val)^(-3/4 : ℝ) := by
obtain ⟨C,hC,hbound⟩ := exists_uniform_fullResidual_bound (V := V) α β hα L B hL hB
refine ⟨C,hC,fun t s hst => ?_⟩
have hq : 0 < t.val-s.val := sub_pos.mpr hst
have hq1 : t.val-s.val ≤ 1 := by linarith [t.property.2, s.property.1]
have he : |(now t).val-s.val| = ParabolicRadius.radius (t.val-s.val)^4 := by
rw [ParabolicRadius.pow_four hq.le]
exact abs_of_pos hq
unfold actualResidual
rw [← ParabolicRadius.inv_pow_three hq.le]
apply hbound _ _ _ _ (ParabolicRadius.pos hq) (ParabolicRadius.le_one hq.le hq1) (hb _)
intro x z
simpa only [he, BoundedContinuousFunction.coe_toContinuousMap] using hLip (now t) s x z
def initial (hT₀ : 0 ≤ T) : Slab T := ⟨0,le_rfl,hT₀⟩
lemma continuous_initialResidual (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) :
Continuous (fun t : Time T => actualResidual hα A b t (initial hT₀) d) := by
unfold actualResidual initial
simp only [sub_zero]
apply continuous_fullResidualCLM_apply hα
(fun _ => A ⟨0,le_rfl,hT₀⟩) (fun t => A (now t)) (fun t => b (now t))
(fun t => ParabolicRadius.radius t.val)
continuous_const (A.continuous.comp continuous_now) (b.continuous.comp continuous_now)
(ParabolicRadius.continuous_comp _ continuous_subtype_val)
exact fun t => (ParabolicRadius.pos t.property.1).ne'
def sourceRHS (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) (l : Time T →ᵇ C₀(V,ℂ)) (t : Time T) : C₀(V,ℂ) :=
t.val^(3/4 : ℝ) • (l t-actualResidual hα A b t (initial hT₀) d)
lemma continuous_sourceRHS (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) (l : Time T →ᵇ C₀(V,ℂ)) :
Continuous (sourceRHS hα A b hT₀ d l) :=
(continuous_subtype_val.rpow_const (fun t => Or.inl t.property.1.ne')).smul
(l.continuous.sub (continuous_initialResidual hα A b hT₀ d))
lemma norm_sourceRHS_le (hT₀ : 0 ≤ T) (hT : T ≤ 1) (C : ℝ) (_hC : 0 ≤ C)
(hR : ∀ t : Time T, ‖actualResidual hα A b t (initial hT₀)‖ ≤ C*t.val^(-3/4 : ℝ))
(d : C₀(V,ℂ)) (l : Time T →ᵇ C₀(V,ℂ)) (t : Time T) :
‖sourceRHS hα A b hT₀ d l t‖ ≤ ‖l‖+C*‖d‖ := by
have ht : 0 ≤ t.val^(3/4 : ℝ) := Real.rpow_nonneg t.property.1.le _
have ht1 : t.val^(3/4 : ℝ) ≤ 1 := Real.rpow_le_one t.property.1.le (t.property.2.trans hT) (by positivity)
have hc : t.val^(3/4 : ℝ)*t.val^(-3/4 : ℝ)=1 := by
rw [← Real.rpow_add t.property.1]
norm_num
rw [sourceRHS, norm_smul, Real.norm_eq_abs, abs_of_nonneg ht]
calc
_ ≤ t.val^(3/4 : ℝ)*(‖l‖+C*t.val^(-3/4 : ℝ)*‖d‖) :=
mul_le_mul_of_nonneg_left ((norm_sub_le _ _).trans <|
add_le_add (l.norm_coe_le_norm t) ((actualResidual hα A b t (initial hT₀)).le_opNorm d |>.trans
(mul_le_mul_of_nonneg_right (hR t) (norm_nonneg d)))) ht
_ = t.val^(3/4 : ℝ)*‖l‖+C*‖d‖*(t.val^(3/4 : ℝ)*t.val^(-3/4 : ℝ)) := by ring
_ = t.val^(3/4 : ℝ)*‖l‖+C*‖d‖ := by rw [hc,mul_one]
_ ≤ ‖l‖+C*‖d‖ := add_le_add (mul_le_of_le_one_left (norm_nonneg l) ht1) le_rfl
def weightedSource (hT₀ : 0 ≤ T) (hT : T ≤ 1) (C : ℝ) (hC : 0 ≤ C)
(hR : ∀ t : Time T, ‖actualResidual hα A b t (initial hT₀)‖ ≤ C*t.val^(-3/4 : ℝ))
(d : C₀(V,ℂ)) (l : Time T →ᵇ C₀(V,ℂ)) : Time T →ᵇ C₀(V,ℂ) :=
.mkOfBound ⟨sourceRHS hα A b hT₀ d l, continuous_sourceRHS hα A b hT₀ d l⟩
(2*(‖l‖+C*‖d‖)) (by
intro t s
exact (dist_le_norm_add_norm _ _).trans <| by
dsimp
linarith [norm_sourceRHS_le hα A b hT₀ hT C hC hR d l t,
norm_sourceRHS_le hα A b hT₀ hT C hC hR d l s])
lemma unweighted_weightedSource (hT₀ : 0 ≤ T) (hT : T ≤ 1) (C : ℝ) (hC : 0 ≤ C)
(hR : ∀ t : Time T, ‖actualResidual hα A b t (initial hT₀)‖ ≤ C*t.val^(-3/4 : ℝ))
(d : C₀(V,ℂ)) (l : Time T →ᵇ C₀(V,ℂ)) (t : Time T) :
unweighted (weightedSource hα A b hT₀ hT C hC hR d l) t.val =
l t-actualResidual hα A b t (initial hT₀) d := by
rw [unweighted_at_time]
change t.val^(-3/4 : ℝ) • (t.val^(3/4 : ℝ) •
(l t-actualResidual hα A b t (initial hT₀) d)) = _
rw [smul_smul, ← Real.rpow_add t.property.1]
norm_num
def residualKernel (hT₀ : 0 ≤ T) (t : Time T) (r : ℝ) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
if r ∈ Ioo 0 t.val then actualResidual hα A b t (projIcc 0 T hT₀ r) else 0
lemma elapsed_normalizedArg (t : Time T) (r : ℝ) (hr : r ∈ Ioo 0 t.val) :
elapsed (t,normalizedArg t r hr) = t.val-r := by
dsimp [elapsed, normalizedArg]
field_simp [t.property.1.ne']
lemma before_normalizedArg (hT₀ : 0 ≤ T) (t : Time T) (r : ℝ) (hr : r ∈ Ioo 0 t.val) :
before (t,normalizedArg t r hr) = projIcc 0 T hT₀ r := by
have hmem : r ∈ Icc 0 T := ⟨hr.1.le,hr.2.le.trans t.property.2⟩
rw [projIcc_of_mem hT₀ hmem]
apply Subtype.ext
dsimp [before,now,lag,normalizedArg]
field_simp [t.property.1.ne']
lemma kernel_eq_residualKernel (hT₀ : 0 ≤ T) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p : Time T × UnitTime, ‖normalized hα A b p‖ ≤ C) (t : Time T) (r : ℝ) :
kernel (Kernel.ofStrong (normalized hα A b) (continuous_normalized_apply hα A b) C hC hN) t r =
residualKernel hα A b hT₀ t r := by
classical
by_cases hr : r ∈ Ioo 0 t.val
· rw [kernel,dite_eq_left hr,residualKernel,ite_eq_left hr]
change (t.val-r)^(-3/4 : ℝ) •
(ParabolicRadius.radius (elapsed (t,normalizedArg t r hr))^3 •
actualResidual hα A b t (before (t,normalizedArg t r hr))) = _
rw [elapsed_normalizedArg,before_normalizedArg hT₀]
apply ContinuousLinearMap.ext
intro f
change (t.val-r)^(-3/4 : ℝ) • (ParabolicRadius.radius (t.val-r)^3 •
actualResidual hα A b t (projIcc 0 T hT₀ r) f) = _
rw [smul_smul,ParabolicRadius.normalized_cancel (sub_pos.mpr hr.2),one_smul]
· simp only [kernel,dite_eq_right hr,residualKernel,ite_eq_right hr]
end Slab
open scoped ZeroAtInfty BoundedContinuousFunction
open FrozenParametrix C0Convolution StrongWeightedVolterra
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {T α β : ℝ}
theorem exists_parametrix_correction (hα : 0 < α)
(A : C(Slab T, V →ᵇ Icc α β)) (b : C(Slab T, V →ᵇ ℂ))
(hT₀ : 0 ≤ T) (hT : T ≤ 1) (L B : ℝ) (hL : 0 ≤ L) (hB : 0 ≤ B)
(hb : ∀ s, ‖b s‖ ≤ B)
(hLip : ∀ s r : Slab T, ∀ x z : V,
|(A s x).val-(A r z).val| ≤ L*(‖x-z‖+|s.val-r.val|)) :
∃ C D : ℝ, 0 ≤ C ∧ 0 ≤ D ∧
(T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*D < 1 →
∀ (d : C₀(V,ℂ)) (l : Time T →ᵇ C₀(V,ℂ)), ∃ j : Time T →ᵇ C₀(V,ℂ),
(∀ t : Time T, IntervalIntegrable
(fun r => residualKernel hα A b hT₀ t r (unweighted j r)) volume 0 t.val) ∧
(∀ t : Time T, unweighted j t.val + ∫ r in 0..t.val,
residualKernel hα A b hT₀ t r (unweighted j r) =
l t-actualResidual hα A b t (initial hT₀) d) ∧
(∀ t : Time T, ‖unweighted j t.val‖ ≤ t.val^(-3/4 : ℝ) *
((‖l‖+C*‖d‖)/(1-T^(1/4 : ℝ)*(∫ u : UnitTime, weight u)*D)))) := by
obtain ⟨C,hC,hR⟩ := exists_actualResidual_bound hα A b hT L B hL hB hb hLip
obtain ⟨D,hD,hN⟩ := exists_normalized_bound hα A b hT L B hL hB hb hLip
have hR₀ : ∀ t : Time T, ‖actualResidual hα A b t (initial hT₀)‖ ≤ C*t.val^(-3/4 : ℝ) := by
intro t
simpa only [initial, sub_zero] using hR t (initial hT₀) t.property.1
refine ⟨C,D,hC,hD,fun hsmall d l => ?_⟩
let N : Kernel T C₀(V,ℂ) := Kernel.ofStrong (normalized hα A b)
(continuous_normalized_apply hα A b) D hD hN
let g := weightedSource hα A b hT₀ hT C hC hR₀ d l
obtain ⟨j,hi,hj,hbound⟩ := exists_unweighted_solution N D hD hN hT₀ hsmall g
have he : ∀ t r, kernel N t r = residualKernel hα A b hT₀ t r :=
kernel_eq_residualKernel hα A b hT₀ D hD hN
simp_rw [he] at hi hj
have hg : ∀ t : Time T, unweighted g t.val = l t-actualResidual hα A b t (initial hT₀) d :=
unweighted_weightedSource hα A b hT₀ hT C hC hR₀ d l
simp_rw [hg] at hj
refine ⟨j,hi,hj,fun t => (hbound t).trans ?_⟩
have hgnorm : ‖g‖ ≤ ‖l‖+C*‖d‖ := by
apply (BoundedContinuousFunction.norm_le (by positivity)).mpr
exact norm_sourceRHS_le hα A b hT₀ hT C hC hR₀ d l
exact mul_le_mul_of_nonneg_left
(div_le_div_of_nonneg_right hgnorm (by linarith)) (Real.rpow_nonneg t.property.1.le _)
end ParametrixVolterra
namespace MildVolterra
open StrongWeightedVolterra
def massWeight (u : UnitTime) : ℝ := u.val^(-3/4 : ℝ)
lemma massWeight_nonneg (u : UnitTime) : 0 ≤ massWeight u := Real.rpow_nonneg u.property.1.le _
lemma continuous_massWeight : Continuous massWeight :=
continuous_subtype_val.rpow_const (fun u => Or.inl u.property.1.ne')
lemma integrable_massWeight : Integrable massWeight := by
have hi := (intervalIntegral.intervalIntegrable_rpow' (a := 0) (b := 1)
(r := (-3/4 : ℝ)) (by norm_num)).1.mono_set Ioo_subset_Ioc_self
exact (integrableOn_iff_comap_subtypeVal measurableSet_Ioo).mp hi
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
variable {T : ℝ}
variable (K : Kernel T E) (C : ℝ) (hC : 0 ≤ C) (hK : ∀ p, ‖K p‖ ≤ C)
def data (j : Time T →ᵇ E) (t : Time T) (u : UnitTime) : E :=
massWeight u • K (t,u) (j (lag t u))
lemma continuous_data (j : Time T →ᵇ E) :
Continuous (fun p : Time T × UnitTime => data K j p.1 p.2) := by
exact (continuous_massWeight.comp continuous_snd).smul
(K.continuous_apply.comp (continuous_id.prodMk (j.continuous.comp continuous_lag)))
include hC hK
lemma norm_data_le (j : Time T →ᵇ E) (t : Time T) (u : UnitTime) :
‖data K j t u‖ ≤ massWeight u*(C*‖j‖) := by
rw [data,norm_smul,Real.norm_eq_abs,abs_of_nonneg (massWeight_nonneg u)]
apply mul_le_mul_of_nonneg_left _ (massWeight_nonneg u)
exact (K (t,u)).le_opNorm _ |>.trans
(mul_le_mul (hK _) (j.norm_coe_le_norm _) (norm_nonneg _) hC)
lemma integrable_data (j : Time T →ᵇ E) (t : Time T) : Integrable (data K j t) :=
(integrable_massWeight.mul_const (C*‖j‖)).mono'
((continuous_data K j).comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable
(Eventually.of_forall (norm_data_le K C hC hK j t))
lemma continuous_integral_data (j : Time T →ᵇ E) :
Continuous (fun t => ∫ u : UnitTime, data K j t u) := by
apply continuous_of_dominated
(fun t => (integrable_data K C hC hK j t).aestronglyMeasurable)
(fun t => Eventually.of_forall (norm_data_le K C hC hK j t))
(integrable_massWeight.mul_const (C*‖j‖))
exact Eventually.of_forall (fun u =>
(continuous_data K j).comp (continuous_id.prodMk continuous_const))
lemma norm_integral_data_le (j : Time T →ᵇ E) (t : Time T) :
‖∫ u : UnitTime, data K j t u‖ ≤ (∫ u : UnitTime, massWeight u)*C*‖j‖ := by
calc
_ ≤ ∫ u : UnitTime, massWeight u*(C*‖j‖) :=
norm_integral_le_of_norm_le (integrable_massWeight.mul_const _) <|
Eventually.of_forall (norm_data_le K C hC hK j t)
_ = _ := by rw [integral_mul_const]; ring
omit hC hK in
def value (j : Time T →ᵇ E) (t : Time T) : E :=
t.val^(1/4 : ℝ) • ∫ u : UnitTime, data K j t u
lemma continuous_value (j : Time T →ᵇ E) : Continuous (value K j) :=
(continuous_subtype_val.rpow_const (fun t => Or.inl t.property.1.ne')).smul
(continuous_integral_data K C hC hK j)
lemma norm_value_le (j : Time T →ᵇ E) (t : Time T) :
‖value K j t‖ ≤ t.val^(1/4 : ℝ)*((∫ u : UnitTime, massWeight u)*C*‖j‖) := by
rw [value,norm_smul,Real.norm_eq_abs,abs_of_nonneg (Real.rpow_nonneg t.property.1.le _)]
exact mul_le_mul_of_nonneg_left (norm_integral_data_le K C hC hK j t)
(Real.rpow_nonneg t.property.1.le _)
lemma tendsto_value_zero (j : Time T →ᵇ E) :
Tendsto (value K j) (comap Subtype.val (𝓝[>] (0 : ℝ))) (𝓝 0) := by
apply tendsto_zero_iff_norm_tendsto_zero.mpr
apply squeeze_zero (fun t => norm_nonneg _) (norm_value_le K C hC hK j)
have ht : Tendsto (fun t : Time T => t.val) (comap Subtype.val (𝓝[>] (0 : ℝ))) (𝓝 0) :=
tendsto_comap.mono_right nhdsWithin_le_nhds
have hp := (Real.continuous_rpow_const (by norm_num : (0:ℝ) ≤ 1/4)).continuousAt.tendsto.comp ht
simpa using hp.mul_const ((∫ u : UnitTime, massWeight u)*C*‖j‖)
omit hC hK in
def rawKernel (t : Time T) (r : ℝ) : E →L[ℂ] E :=
if hr : r ∈ Ioo 0 t.val then K (t,normalizedArg t r hr) else 0
omit hC hK in
lemma rawKernel_lag (t : Time T) (u : UnitTime) :
rawKernel K t (t.val*u.val) = K (t,u) := by
have hr : t.val*u.val ∈ Ioo 0 t.val :=
⟨mul_pos t.property.1 u.property.1, mul_lt_of_lt_one_right t.property.1 u.property.2⟩
rw [rawKernel,dite_eq_left hr,normalizedArg_lag]
omit hC hK in
lemma rescaling_scalar (t u : ℝ) (ht : 0 < t) (hu : 0 < u) :
t*(t*u)^(-3/4 : ℝ) = t^(1/4 : ℝ)*u^(-3/4 : ℝ) := by
rw [Real.mul_rpow ht.le hu.le]
have he : t*t^(-3/4 : ℝ) = t^(1/4 : ℝ) := by
calc
_ = t^(1 : ℝ)*t^(-3/4 : ℝ) := by rw [Real.rpow_one]
_ = t^((1:ℝ)+(-3/4)) := (Real.rpow_add ht _ _).symm
_ = _ := by norm_num
rw [← mul_assoc,he]
omit hC hK in
lemma value_eq_integral (j : Time T →ᵇ E) (t : Time T) :
value K j t = ∫ r in 0..t.val, rawKernel K t r (unweighted j r) := by
let F : ℝ → E := fun r => rawKernel K t r (unweighted j r)
have hc := intervalIntegral.smul_integral_comp_mul_left (a := 0) (b := 1) F t.val
simp only [mul_zero,mul_one] at hc
change value K j t = ∫ r in 0..t.val, F r
rw [← hc,intervalIntegral.integral_of_le (by norm_num : (0:ℝ) ≤ 1),
integral_Ioc_eq_integral_Ioo,← integral_subtype measurableSet_Ioo,← integral_smul]
unfold value
rw [← integral_smul]
apply integral_congr_ae
apply Eventually.of_forall
intro u
dsimp [F]
rw [rawKernel_lag,unweighted_lag,ContinuousLinearMap.map_smul_of_tower]
simp only [data,smul_smul,massWeight]
rw [rescaling_scalar t.val u.val t.property.1 u.property.1]
omit hC hK in
lemma rawKernel_unweighted_lag (j : Time T →ᵇ E) (t : Time T) (u : UnitTime) :
rawKernel K t (t.val*u.val) (unweighted j (t.val*u.val)) =
t.val^(-3/4 : ℝ) • data K j t u := by
rw [rawKernel_lag,unweighted_lag,ContinuousLinearMap.map_smul_of_tower]
simp only [data,smul_smul,massWeight]
rw [Real.mul_rpow t.property.1.le u.property.1.le]
lemma intervalIntegrable_rawKernel_unweighted (j : Time T →ᵇ E) (t : Time T) :
IntervalIntegrable (fun r => rawKernel K t r (unweighted j r)) volume 0 t.val := by
have hi : Integrable (fun u : UnitTime =>
rawKernel K t (t.val*u.val) (unweighted j (t.val*u.val))) := by
simp_rw [rawKernel_unweighted_lag]
exact (integrable_data K C hC hK j t).smul _
have hs : IntegrableOn (fun u : ℝ =>
rawKernel K t (t.val*u) (unweighted j (t.val*u))) (Ioo 0 1) :=
(integrableOn_iff_comap_subtypeVal measurableSet_Ioo).mpr hi
have hii := (intervalIntegrable_iff_integrableOn_Ioo_of_le (by norm_num : (0:ℝ) ≤ 1)).mpr hs
apply (IntervalIntegrable.comp_mul_left_iff (a := 0) (b := t.val) t.property.1.ne').mp
simpa only [zero_div,div_self t.property.1.ne'] using hii
end MildVolterra
namespace ParametrixVolterra
open scoped ZeroAtInfty BoundedContinuousFunction
open FrozenParametrix C0Convolution StrongWeightedVolterra
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {T α β : ℝ}
variable (hα : 0 < α) (A : C(Slab T, V →ᵇ Icc α β))
def actualFrozen (t : Time T) (s : Slab T) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
frozenCLM hα (A s).toContinuousMap (ParabolicRadius.radius (t.val-s.val))
lemma continuous_actualFrozen_before (d : C₀(V,ℂ)) :
Continuous (fun p : Time T × UnitTime => actualFrozen hα A p.1 (before p) d) := by
unfold actualFrozen
simp_rw [show ∀ p : Time T × UnitTime, p.1.val-(before p).val=elapsed p from fun p => (elapsed_eq_sub p).symm]
exact continuous_frozenOp_comp hα (fun p => A (before p))
(fun p => ParabolicRadius.radius (elapsed p)) (A.continuous.comp continuous_before)
(ParabolicRadius.continuous_comp _ continuous_elapsed) d
def frozenBound : ℝ := ∫ y : V, kernelMajorant α β hα y
lemma frozenBound_nonneg : 0 ≤ frozenBound (V := V) (β := β) hα :=
integral_nonneg (kernelMajorant_spec α β hα).2.1
lemma norm_actualFrozen_le (t : Time T) (s : Slab T) :
‖actualFrozen hα A t s‖ ≤ frozenBound (V := V) (β := β) hα :=
norm_frozenCLM_le hα _ _
def mildKernel : Kernel T C₀(V,ℂ) :=
Kernel.ofStrong (fun p => actualFrozen hα A p.1 (before p))
(continuous_actualFrozen_before hα A) (frozenBound (V := V) (β := β) hα)
(frozenBound_nonneg hα) (fun p => norm_actualFrozen_le hα A p.1 (before p))
lemma norm_mildKernel_le (p : Time T × UnitTime) :
‖mildKernel hα A p‖ ≤ frozenBound (V := V) (β := β) hα :=
norm_actualFrozen_le hα A p.1 (before p)
lemma continuous_frozen_initial (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) :
Continuous (fun t : Time T => actualFrozen hα A t (initial hT₀) d) := by
change Continuous (fun t : Time T => frozenOp hα (A (initial hT₀)).toContinuousMap
(ParabolicRadius.radius (t.val-0)) d)
simp only [sub_zero]
exact continuous_frozenOp_comp hα (fun _ : Time T => A (initial hT₀))
(fun t : Time T => ParabolicRadius.radius t.val) continuous_const
(ParabolicRadius.continuous_comp _ continuous_subtype_val) d
lemma tendsto_frozen_initial (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) :
Tendsto (fun t : Time T => actualFrozen hα A t (initial hT₀) d)
(comap Subtype.val (𝓝[>] (0 : ℝ))) (𝓝 d) := by
have ht : Tendsto (fun t : Time T => t.val) (comap Subtype.val (𝓝[>] (0 : ℝ))) (𝓝 0) :=
tendsto_comap.mono_right nhdsWithin_le_nhds
have hf : Continuous (fun q : ℝ => frozenOp hα (A (initial hT₀)).toContinuousMap (ParabolicRadius.radius q) d) :=
continuous_frozenOp_comp hα (fun _ => A (initial hT₀)) ParabolicRadius.radius continuous_const
(ParabolicRadius.continuous_comp _ continuous_id) d
have hz : frozenOp hα (A (initial hT₀)).toContinuousMap (ParabolicRadius.radius 0) d = d := by
rw [show ParabolicRadius.radius 0 = 0 from Real.zero_rpow (by norm_num)]
exact frozen_zero _ _ _ _ _ _ d
change Tendsto (fun t : Time T => frozenOp hα (A (initial hT₀)).toContinuousMap
(ParabolicRadius.radius (t.val-0)) d) _ (𝓝 d)
simp only [sub_zero]
have hout := (hf.tendsto 0).comp ht
rw [hz] at hout
exact hout
def mild (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T) : C₀(V,ℂ) :=
actualFrozen hα A t (initial hT₀) d + MildVolterra.value (mildKernel hα A) j t
lemma continuous_mild (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) (j : Time T →ᵇ C₀(V,ℂ)) :
Continuous (mild hα A hT₀ d j) :=
(continuous_frozen_initial hα A hT₀ d).add
(MildVolterra.continuous_value (mildKernel hα A) (frozenBound (V := V) (β := β) hα)
(frozenBound_nonneg hα) (norm_mildKernel_le hα A) j)
lemma tendsto_mild_initial (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) (j : Time T →ᵇ C₀(V,ℂ)) :
Tendsto (mild hα A hT₀ d j) (comap Subtype.val (𝓝[>] (0 : ℝ))) (𝓝 d) := by
have ht := (tendsto_frozen_initial hα A hT₀ d).add
(MildVolterra.tendsto_value_zero (mildKernel hα A) (frozenBound (V := V) (β := β) hα)
(frozenBound_nonneg hα) (norm_mildKernel_le hα A) j)
unfold mild
simpa only [add_zero] using ht
def frozenRaw (hT₀ : 0 ≤ T) (t : Time T) (r : ℝ) : C₀(V,ℂ) →L[ℂ] C₀(V,ℂ) :=
if r ∈ Ioo 0 t.val then actualFrozen hα A t (projIcc 0 T hT₀ r) else 0
lemma rawKernel_eq_frozenRaw (hT₀ : 0 ≤ T) (t : Time T) (r : ℝ) :
MildVolterra.rawKernel (mildKernel hα A) t r = frozenRaw hα A hT₀ t r := by
classical
by_cases hr : r ∈ Ioo 0 t.val
· rw [MildVolterra.rawKernel,dite_eq_left hr,frozenRaw,ite_eq_left hr]
change actualFrozen hα A t (before (t,normalizedArg t r hr)) = _
rw [before_normalizedArg hT₀]
· simp only [MildVolterra.rawKernel,dite_eq_right hr,frozenRaw,ite_eq_right hr]
lemma intervalIntegrable_frozenRaw (hT₀ : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T) :
IntervalIntegrable (fun r => frozenRaw hα A hT₀ t r (unweighted j r)) volume 0 t.val := by
simpa only [rawKernel_eq_frozenRaw hα A hT₀] using
MildVolterra.intervalIntegrable_rawKernel_unweighted (mildKernel hα A)
(frozenBound (V := V) (β := β) hα) (frozenBound_nonneg hα) (norm_mildKernel_le hα A) j t
lemma mild_eq_integral (hT₀ : 0 ≤ T) (d : C₀(V,ℂ)) (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T) :
mild hα A hT₀ d j t = actualFrozen hα A t (initial hT₀) d +
∫ r in 0..t.val, frozenRaw hα A hT₀ t r (unweighted j r) := by
rw [mild,MildVolterra.value_eq_integral]
simp_rw [rawKernel_eq_frozenRaw hα A hT₀]
end ParametrixVolterra
open Set Filter MeasureTheory
open scoped SchwartzMap Topology ContDiff BoundedContinuousFunction
namespace ScaledSchwartzConvolution
section ScaledDecay
universe u
variable {V E : Type u} [NormedAddCommGroup V] [NormedSpace ℝ V]
[FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)]
[NormedAddCommGroup E] [NormedSpace ℝ E]
omit [FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)] in
lemma scaled_decay (g : SchwartzMap V E) (a b : ℝ) (ha : 0 < a) (K N : ℕ) :
∃ C : ℝ, 0 ≤ C ∧ ∀ c ∈ Icc a b, ∀ z,
(1+‖z‖)^N * ‖(c⁻¹)^K • g (c⁻¹ • z)‖ ≤ C := by
let M := max b 1
let D := 2^N * (Finset.Iic (N,0)).sup (fun i => SchwartzMap.seminorm ℝ i.1 i.2) g
have hD : 0 ≤ D := by positivity
have hM : 0 < M := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
have hdec (z : V) : (1+‖z‖)^N * ‖g z‖ ≤ D := by
simpa only [norm_iteratedFDeriv_zero] using
SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) (m := (N,0)) le_rfl le_rfl g z
refine ⟨(a⁻¹)^K*(M^N*D), by positivity, ?_⟩
intro c hc z
have hcpos : 0 < c := ha.trans_le hc.1
have hcM : c ≤ M := hc.2.trans (le_max_left _ _)
have hn : ‖z‖ = c * ‖c⁻¹ • z‖ := by
rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hcpos),
← mul_assoc, mul_inv_cancel₀ hcpos.ne', one_mul]
have hs : 1+‖z‖ ≤ M*(1+‖c⁻¹ • z‖) := by
rw [hn, mul_add, mul_one]
exact add_le_add (le_max_right b 1) (mul_le_mul_of_nonneg_right hcM (norm_nonneg _))
have hg : (1+‖z‖)^N * ‖g (c⁻¹ • z)‖ ≤ M^N*D := by
calc
_ ≤ (M*(1+‖c⁻¹ • z‖))^N * ‖g (c⁻¹ • z)‖ := by gcongr
_ = M^N * ((1+‖c⁻¹ • z‖)^N * ‖g (c⁻¹ • z)‖) := by rw [mul_pow]; ring
_ ≤ _ := mul_le_mul_of_nonneg_left (hdec _) (by positivity)
rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
calc
_ = (c⁻¹)^K * ((1+‖z‖)^N * ‖g (c⁻¹ • z)‖) := by ring
_ ≤ (a⁻¹)^K * ((1+‖z‖)^N * ‖g (c⁻¹ • z)‖) := by gcongr; exact hc.1
_ ≤ _ := mul_le_mul_of_nonneg_left hg (by positivity)
lemma shifted_majorant (g : SchwartzMap V E) (a b : ℝ) (ha : 0 < a) (K : ℕ) (x₀ : V) :
∃ B : V → ℝ, Integrable B ∧ ∀ c ∈ Icc a b, ∀ x ∈ Metric.ball x₀ 1, ∀ y,
‖(c⁻¹)^K • g (c⁻¹ • (x-y))‖ ≤ B y := by
let N := Module.finrank ℝ V + 1
obtain ⟨C,hC,hdec⟩ := scaled_decay g a b ha K N
refine ⟨fun y => (2^N*C)/(1+‖x₀-y‖)^N, ?_, ?_⟩
· have hi : Integrable (fun z : V => (1+‖z‖)^(-(N : ℝ))) :=
integrable_one_add_norm (by dsimp [N]; norm_num)
simpa only [Real.rpow_neg (by positivity : (0:ℝ) ≤ 1+‖x₀-_‖),
Real.rpow_natCast, div_eq_mul_inv] using (hi.comp_sub_left x₀).const_mul (2^N*C)
· intro c hc x hx y
have hd : ‖x₀-x‖ < 1 := by simpa only [Metric.mem_ball,dist_eq_norm,norm_sub_rev] using hx
have hn : ‖x₀-y‖ ≤ ‖x₀-x‖ + ‖x-y‖ := by simpa only [sub_add_sub_cancel] using norm_add_le (x₀-x) (x-y)
have hs : 1+‖x₀-y‖ ≤ 2*(1+‖x-y‖) := by nlinarith [norm_nonneg (x-y)]
apply (le_div_iff₀ (by positivity)).mpr
calc
_ ≤ ‖(c⁻¹)^K • g (c⁻¹ • (x-y))‖ * (2*(1+‖x-y‖))^N := by gcongr
_ = 2^N * ((1+‖x-y‖)^N * ‖(c⁻¹)^K • g (c⁻¹ • (x-y))‖) := by rw [mul_pow]; ring
_ ≤ _ := mul_le_mul_of_nonneg_left (hdec c hc _) (by positivity)
variable {A F : Type u} [NormedAddCommGroup A] [NormedSpace ℝ A]
[NormedAddCommGroup F] [NormedSpace ℝ F]
variable {a b : ℝ} (ha : 0 < a) (c : V → ℝ) (hc : Continuous c) (hcb : ∀ y, c y ∈ Icc a b)
def value (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A) (g : SchwartzMap V E) (K : ℕ) (x : V) : F :=
∫ y, L (f y) ((c y)⁻¹^K • g ((c y)⁻¹ • (x-y)))
include ha hc hcb
lemma integrable_integrand (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) (x : V) :
Integrable (fun y => L (f y) ((c y)⁻¹^K • g ((c y)⁻¹ • (x-y)))) := by
obtain ⟨B,hB,hbound⟩ := shifted_majorant g a b ha K x
have hci : Continuous (fun y => (c y)⁻¹) := hc.inv₀ (fun y => (ha.trans_le (hcb y).1).ne')
refine (hB.const_mul (‖L‖*‖f‖)).mono' ?_ (Eventually.of_forall fun y => ?_)
· exact ((L.continuous.comp f.continuous).clm_apply
((hci.pow K).smul (g.continuous.comp (hci.smul (continuous_const.sub continuous_id))))).aestronglyMeasurable
· exact (L.le_opNorm₂ _ _).trans <| mul_le_mul
(mul_le_mul_of_nonneg_left (f.norm_coe_le_norm y) (norm_nonneg L))
(hbound (c y) (hcb y) x (Metric.mem_ball_self zero_lt_one) y)
(norm_nonneg _) (by positivity)
lemma hasFDerivAt_value (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) (x₀ : V) :
HasFDerivAt (value c L f g K)
(value c (L.precompR V) f (SchwartzMap.fderivCLM ℝ V E g) (K+1) x₀) x₀ := by
let g' := SchwartzMap.fderivCLM ℝ V E g
obtain ⟨B,hB,hbound⟩ := shifted_majorant g' a b ha (K+1) x₀
have hd (x y : V) : HasFDerivAt (fun x => (c y)⁻¹^K • g ((c y)⁻¹ • (x-y)))
((c y)⁻¹^(K+1) • g' ((c y)⁻¹ • (x-y))) x := by
have h := ((g.hasFDerivAt ((c y)⁻¹ • (x-y))).comp x
(((hasFDerivAt_id x).sub (hasFDerivAt_const y x)).const_smul (c y)⁻¹)).const_smul ((c y)⁻¹^K)
convert h using 1
· rfl
· ext v
simp [g',SchwartzMap.fderivCLM_apply,pow_succ,smul_smul]
apply hasFDerivAt_integral_of_dominated_of_fderiv_le (Metric.ball_mem_nhds x₀ zero_lt_one)
· exact Eventually.of_forall fun x => (integrable_integrand ha c hc hcb L f g K x).aestronglyMeasurable
· exact integrable_integrand ha c hc hcb L f g K x₀
· exact (integrable_integrand ha c hc hcb (L.precompR V) f g' (K+1) x₀).aestronglyMeasurable
· filter_upwards with y x hx
change ‖(L (f y)).comp ((c y)⁻¹^(K+1) • g' ((c y)⁻¹ • (x-y)))‖ ≤ _
calc
_ ≤ ‖L (f y)‖ * ‖(c y)⁻¹^(K+1) • g' ((c y)⁻¹ • (x-y))‖ := ContinuousLinearMap.opNorm_comp_le _ _
_ ≤ (‖L‖*‖f‖) * ‖(c y)⁻¹^(K+1) • g' ((c y)⁻¹ • (x-y))‖ := by
gcongr
exact (L.le_opNorm _).trans (mul_le_mul_of_nonneg_left (f.norm_coe_le_norm y) (norm_nonneg L))
_ ≤ (‖L‖*‖f‖)*B y := mul_le_mul_of_nonneg_left (hbound (c y) (hcb y) x hx y) (by positivity)
· exact hB.const_mul (‖L‖*‖f‖)
· filter_upwards with y x _
exact (L (f y)).hasFDerivAt.comp x (hd x y)
lemma contDiff_value_nat (n : ℕ) (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) : ContDiff ℝ n (value c L f g K) := by
induction n generalizing E F K with
| zero =>
rw [Nat.cast_zero,contDiff_zero]
exact continuous_iff_continuousAt.mpr (fun x => (hasFDerivAt_value ha c hc hcb L f g K x).continuousAt)
| succ n ih =>
rw [Nat.cast_add,Nat.cast_one,contDiff_succ_iff_hasFDerivAt]
exact ⟨value c (L.precompR V) f (SchwartzMap.fderivCLM ℝ V E g) (K+1),
ih (L.precompR V) (SchwartzMap.fderivCLM ℝ V E g) (K+1), hasFDerivAt_value ha c hc hcb L f g K⟩
lemma contDiff_value (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) : ContDiff ℝ ∞ (value c L f g K) :=
contDiff_infty.mpr (fun n => contDiff_value_nat ha c hc hcb n L f g K)
lemma fderiv_value (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) :
fderiv ℝ (value c L f g K) = value c (L.precompR V) f (SchwartzMap.fderivCLM ℝ V E g) (K+1) := by
funext x
exact (hasFDerivAt_value ha c hc hcb L f g K x).fderiv
lemma fderiv_value_apply (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) (x v : V) :
fderiv ℝ (value c L f g K) x v =
∫ y, L (f y) ((c y)⁻¹^(K+1) • fderiv ℝ g ((c y)⁻¹ • (x-y)) v) := by
rw [fderiv_value ha c hc hcb L f g K, value,
ContinuousLinearMap.integral_apply
(integrable_integrand ha c hc hcb (L.precompR V) f (SchwartzMap.fderivCLM ℝ V E g) (K+1) x)]
rfl
lemma second_fderiv_value_apply (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) (x v w : V) :
fderiv ℝ (fderiv ℝ (value c L f g K)) x v w =
∫ y, L (f y) ((c y)⁻¹^(K+2) • fderiv ℝ (fderiv ℝ g) ((c y)⁻¹ • (x-y)) v w) := by
rw [fderiv_value ha c hc hcb L f g K, fderiv_value_apply ha c hc hcb]
rw [ContinuousLinearMap.integral_apply]
· rfl
· exact integrable_integrand ha c hc hcb (L.precompR V) f
(SchwartzMap.evalCLM ℝ V (V →L[ℝ] E) v
(SchwartzMap.fderivCLM ℝ V (V →L[ℝ] E) (SchwartzMap.fderivCLM ℝ V E g))) (K+2) x
end ScaledDecay
open scoped Laplacian
universe u
variable {V E F A : Type u} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)]
[NormedAddCommGroup E] [NormedSpace ℝ E]
[NormedAddCommGroup F] [NormedSpace ℝ F]
[NormedAddCommGroup A] [NormedSpace ℝ A]
variable {a b : ℝ} (ha : 0 < a) (c : V → ℝ) (hc : Continuous c) (hcb : ∀ y, c y ∈ Icc a b)
include ha hc hcb
lemma laplacian_value (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) :
Δ (value c L f g K) = value c L f (Δ g : SchwartzMap V E) (K+2) := by
funext x
rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis]
simp only [iteratedFDeriv_two_apply, Matrix.cons_val_zero, Matrix.cons_val_one,
second_fderiv_value_apply ha c hc hcb]
rw [value]
simp_rw [SchwartzMap.laplacian_apply,
InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis,
iteratedFDeriv_two_apply, Matrix.cons_val_zero, Matrix.cons_val_one,
Finset.smul_sum, map_sum]
rw [integral_finsetSum]
· rfl
· intro i _
exact integrable_integrand ha c hc hcb L f
(SchwartzMap.evalCLM ℝ V E ((stdOrthonormalBasis ℝ V) i)
(SchwartzMap.evalCLM ℝ V (V →L[ℝ] E) ((stdOrthonormalBasis ℝ V) i)
(SchwartzMap.fderivCLM ℝ V (V →L[ℝ] E) (SchwartzMap.fderivCLM ℝ V E g)))) (K+2) x
lemma bilaplacian_value (L : A →L[ℝ] E →L[ℝ] F) (f : V →ᵇ A)
(g : SchwartzMap V E) (K : ℕ) :
Δ (Δ (value c L f g K)) = value c L f (Δ (Δ g : SchwartzMap V E) : SchwartzMap V E) (K+4) := by
rw [laplacian_value ha c hc hcb, laplacian_value ha c hc hcb]
end ScaledSchwartzConvolution
namespace FrozenParametrix
open scoped SchwartzMap Laplacian ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {α β : ℝ}
def sourceScale (a : C(V,Icc α β)) (q : ℝ) (y : V) : ℝ :=
Real.sqrt (Real.sqrt (q*(a y).val))
omit [InnerProductSpace ℝ V] [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
lemma continuous_sourceScale (a : C(V,Icc α β)) (q : ℝ) : Continuous (sourceScale a q) :=
Real.continuous_sqrt.comp (Real.continuous_sqrt.comp
(continuous_const.mul (continuous_subtype_val.comp a.continuous)))
omit [InnerProductSpace ℝ V] [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
lemma sourceScale_bounds (a : C(V,Icc α β)) (q : ℝ) (hq : 0 ≤ q) (y : V) :
sourceScale a q y ∈ Icc (Real.sqrt (Real.sqrt (q*α))) (Real.sqrt (Real.sqrt (q*β))) := by
exact ⟨Real.sqrt_le_sqrt (Real.sqrt_le_sqrt (mul_le_mul_of_nonneg_left (a y).property.1 hq)),
Real.sqrt_le_sqrt (Real.sqrt_le_sqrt (mul_le_mul_of_nonneg_left (a y).property.2 hq))⟩
def timeValue (a : C(V,Icc α β)) (q : ℝ) (f : C₀(V,ℂ)) (x : V) : ℂ :=
∫ y, f y * kernel (q*(a y).val) (x-y)
lemma timeValue_eq_scaled (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) : timeValue a q f =
ScaledSchwartzConvolution.value (sourceScale a q) (ContinuousLinearMap.mul ℝ ℂ)
f.toBCF (heatKernel 1 zero_lt_one) (Module.finrank ℝ V) := by
funext x
unfold timeValue ScaledSchwartzConvolution.value
congr 1
funext y
rw [kernel_eq_scaled _ (mul_pos hq (hα.trans_le (a y).property.1)), ← inv_pow]
rfl
lemma timeValue_eq_frozenOp (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) : timeValue a q f = frozenOp hα a (ParabolicRadius.radius q) f := by
funext x
rw [frozenOp, frozen_apply_unscaled _ _ _ _ _ _ _ (ParabolicRadius.pos hq)]
rw [ParabolicRadius.pow_four hq.le]
unfold timeValue
congr 1
funext y
exact mul_comm _ _
lemma contDiff_timeValue (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) : ContDiff ℝ ∞ (timeValue a q f) := by
rw [timeValue_eq_scaled hα a q hq f]
exact ScaledSchwartzConvolution.contDiff_value
(Real.sqrt_pos.mpr (Real.sqrt_pos.mpr (mul_pos hq hα))) (sourceScale a q)
(continuous_sourceScale a q) (sourceScale_bounds a q hq.le)
(ContinuousLinearMap.mul ℝ ℂ) f.toBCF
(heatKernel 1 zero_lt_one) (Module.finrank ℝ V)
lemma bilaplacian_timeValue (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (x : V) :
Δ (Δ (timeValue a q f)) x = ∫ y, f y * bilapKernel (q*(a y).val) (x-y) := by
rw [timeValue_eq_scaled hα a q hq f,
ScaledSchwartzConvolution.bilaplacian_value
(Real.sqrt_pos.mpr (Real.sqrt_pos.mpr (mul_pos hq hα))) (sourceScale a q)
(continuous_sourceScale a q) (sourceScale_bounds a q hq.le)]
unfold ScaledSchwartzConvolution.value
congr 1
funext y
rw [bilapKernel_eq_scaled _ (mul_pos hq (hα.trans_le (a y).property.1))]
rfl
lemma integrable_timeValue_integrand (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (x : V) : Integrable (fun y => f y * kernel (q*(a y).val) (x-y)) := by
have he (y : V) : kernel (q*(a y).val) (x-y) =
(sourceScale a q y)⁻¹^(Module.finrank ℝ V) •
heatKernel (V := V) 1 zero_lt_one ((sourceScale a q y)⁻¹ • (x-y)) := by
rw [kernel_eq_scaled _ (mul_pos hq (hα.trans_le (a y).property.1)), ← inv_pow]
rfl
simp_rw [he]
exact ScaledSchwartzConvolution.integrable_integrand
(Real.sqrt_pos.mpr (Real.sqrt_pos.mpr (mul_pos hq hα))) (sourceScale a q)
(continuous_sourceScale a q) (sourceScale_bounds a q hq.le)
(ContinuousLinearMap.mul ℝ ℂ) f.toBCF
(heatKernel 1 zero_lt_one) (Module.finrank ℝ V) x
lemma integrable_bilapValue_integrand (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (x : V) : Integrable (fun y => f y * bilapKernel (q*(a y).val) (x-y)) := by
simp_rw [bilapKernel_eq_scaled _ (mul_pos hq (hα.trans_le (a _).property.1))]
exact ScaledSchwartzConvolution.integrable_integrand
(Real.sqrt_pos.mpr (Real.sqrt_pos.mpr (mul_pos hq hα))) (sourceScale a q)
(continuous_sourceScale a q) (sourceScale_bounds a q hq.le)
(ContinuousLinearMap.mul ℝ ℂ) f.toBCF
(Δ (Δ (heatKernel 1 zero_lt_one) : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Module.finrank ℝ V+4) x
end FrozenParametrix
namespace BiharmonicKernel
open scoped SchwartzMap Laplacian
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma bilapKernel_shifted_majorant (a b : ℝ) (ha : 0 < a) (x₀ : V) :
∃ B : V → ℝ, Integrable B ∧ ∀ t ∈ Icc a b, ∀ x ∈ Metric.ball x₀ 1, ∀ y,
‖bilapKernel t (x-y)‖ ≤ B y := by
obtain ⟨B,hB,hbound⟩ := ScaledSchwartzConvolution.shifted_majorant
(Δ (Δ (heatKernel (V := V) 1 zero_lt_one) : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Real.sqrt (Real.sqrt a)) (Real.sqrt (Real.sqrt b))
(Real.sqrt_pos.mpr (Real.sqrt_pos.mpr ha)) (Module.finrank ℝ V+4) x₀
refine ⟨B,hB,fun t ht x hx y => ?_⟩
rw [bilapKernel_eq_scaled t (ha.trans_le ht.1)]
exact hbound _ ⟨Real.sqrt_le_sqrt (Real.sqrt_le_sqrt ht.1),
Real.sqrt_le_sqrt (Real.sqrt_le_sqrt ht.2)⟩ x hx y
lemma hasDerivAt_kernel_bilap (t : ℝ) (ht : 0 < t) (x : V) :
HasDerivAt (fun s => kernel s x) (-bilapKernel t x) t := by
rw [bilapKernel_eq_schwartz t ht]
exact kernel_heat_equation t ht x
end BiharmonicKernel
namespace FrozenParametrix
open scoped SchwartzMap Laplacian ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {α β : ℝ}
lemma hasDerivAt_timeValue (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (x : V) :
HasDerivAt (fun s => timeValue a s f x)
(-(∫ y, ((a y).val : ℂ)*f y*bilapKernel (q*(a y).val) (x-y))) q := by
let F := fun s : ℝ => fun y : V => f y * kernel (s*(a y).val) (x-y)
let F' := fun s : ℝ => fun y : V => f y * ((a y).val • (-bilapKernel (s*(a y).val) (x-y)))
have hay (y : V) : 0 < (a y).val := hα.trans_le (a y).property.1
have hβ : 0 < β := (hay 0).trans_le (a 0).property.2
have hFi (s : ℝ) (hs : 0 < s) : Integrable (F s) := integrable_timeValue_integrand hα a s hs f x
have hF'cont (s : ℝ) (hs : 0 < s) : Continuous (F' s) :=
f.continuous.mul ((continuous_subtype_val.comp a.continuous).smul
(continuous_bilapKernel_comp (fun y : V => s*(a y).val) (fun y => x-y)
(continuous_const.mul (continuous_subtype_val.comp a.continuous))
(continuous_const.sub continuous_id) (fun y => mul_pos hs (hay y))).neg)
obtain ⟨B,hB,hbound⟩ := bilapKernel_shifted_majorant (V := V)
((q/2)*α) ((2*q)*β) (by positivity) x
have hspos (s : ℝ) (hs : s ∈ Ioo (q/2) (2*q)) : 0 < s := lt_trans (by positivity) hs.1
have hsb (s : ℝ) (hs : s ∈ Ioo (q/2) (2*q)) (y : V) :
s*(a y).val ∈ Icc ((q/2)*α) ((2*q)*β) :=
⟨mul_le_mul hs.1.le (a y).property.1 hα.le (hspos s hs).le,
mul_le_mul hs.2.le (a y).property.2 (hay y).le (by positivity)⟩
have hd := hasDerivAt_integral_of_dominated_loc_of_deriv_le
(F := F) (F' := F') (bound := fun y => (‖f‖*β)*B y)
(s := Ioo (q/2) (2*q)) (Ioo_mem_nhds (by linarith) (by linarith))
(by filter_upwards [Ioi_mem_nhds hq] with s hs; exact (hFi s hs).aestronglyMeasurable)
(hFi q hq) (hF'cont q hq).aestronglyMeasurable
(Eventually.of_forall (fun y s hs => by
simp only [F',norm_mul,norm_smul,Real.norm_eq_abs,abs_of_pos (hay y),norm_neg]
rw [← mul_assoc]
exact mul_le_mul
(mul_le_mul (f.toBCF.norm_coe_le_norm y) (a y).property.2 (hay y).le (norm_nonneg f))
(hbound _ (hsb s hs y) x (Metric.mem_ball_self zero_lt_one) y)
(norm_nonneg _) (by positivity)))
(hB.const_mul (‖f‖*β))
(Eventually.of_forall (fun y s hs => by
simpa [F,F',Function.comp_def,Complex.real_smul,mul_assoc] using
((hasDerivAt_kernel_bilap (s*(a y).val) (mul_pos (hspos s hs) (hay y)) (x-y)).scomp s
((hasDerivAt_id s).mul_const (a y).val)).const_mul (f y)))
have he : (∫ y, F' q y) = -(∫ y, ((a y).val : ℂ)*f y*bilapKernel (q*(a y).val) (x-y)) := by
rw [← integral_neg]
congr 1
funext y
dsimp [F']
ring
rw [he] at hd
exact hd.2
lemma frozen_pde_residual (hα : 0 < α) (a₀ a₁ : C(V,Icc α β)) (b : V →ᵇ ℂ)
(q : ℝ) (hq : 0 < q) (f : C₀(V,ℂ)) (x : V) :
deriv (fun s => timeValue a₀ s f x) q + ((a₁ x).val : ℂ) *
Δ (Δ (timeValue a₀ q f)) x + b x * timeValue a₀ q f x =
fullResidualCLM hα a₀ a₁ b (ParabolicRadius.radius q) f x := by
rw [(hasDerivAt_timeValue hα a₀ q hq f x).deriv, bilaplacian_timeValue hα a₀ q hq f x,
fullResidualCLM_apply]
change _ = principalResidual hα a₀ a₁ (ParabolicRadius.radius q) f x +
b x * frozenOp hα a₀ (ParabolicRadius.radius q) f x
rw [← timeValue_eq_frozenOp hα a₀ q hq f, principalResidual_apply_unscaled hα a₀ a₁ _
(ParabolicRadius.pos hq), ParabolicRadius.pow_four hq.le]
have hi₀ := integrable_bilapValue_integrand hα a₀ q hq f x
have hi₁ := integrable_bilapValue_integrand hα a₀ q hq
(C0Multiplier.mul (coefficient a₀) f) x
change Integrable (fun y => (((a₀ y).val : ℂ)*f y)*bilapKernel (q*(a₀ y).val) (x-y)) at hi₁
have he : (fun y => (((a₁ x).val-(a₀ y).val : ℝ) : ℂ) *
bilapKernel (q*(a₀ y).val) (x-y) * f y) =
fun y => ((a₁ x).val : ℂ)*(f y*bilapKernel (q*(a₀ y).val) (x-y)) -
(((a₀ y).val : ℂ)*f y)*bilapKernel (q*(a₀ y).val) (x-y) := by
funext y
rw [Complex.ofReal_sub]
ring
rw [he, integral_sub (hi₀.const_mul _) hi₁, integral_const_mul]
ring
end FrozenParametrix
open scoped Topology SchwartzMap ZeroAtInfty BoundedContinuousFunction
open Set Filter MeasureTheory
namespace KernelPairing
section IntegrableProdOfTranslationBound
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma integrable_prod_of_translation_bound (F : V × V → ℂ) (hF : Continuous F)
(φ B : V → ℝ) (hφ : Integrable φ)
(hB : Integrable B) (C : ℝ)
(hbound : ∀ x y, ‖F (x,y)‖ ≤ φ x * C * B (x-y)) :
Integrable F (volume.prod volume) := by
have hBi (x : V) : Integrable (fun y => B (x-y)) :=
(integrable_comp_sub_left B x).mpr hB
have hFi (x : V) : Integrable (fun y => F (x,y)) := by
apply ((hBi x).const_mul (φ x * C)).mono'
· exact (hF.comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable
· exact Eventually.of_forall (hbound x)
apply (integrable_prod_iff hF.aestronglyMeasurable).mpr
refine ⟨Eventually.of_forall hFi, ?_⟩
apply ((hφ.mul_const C).mul_const (∫ y, B y)).mono'
· exact hF.aestronglyMeasurable.norm.integral_prod_right'
· filter_upwards with x
rw [Real.norm_eq_abs, abs_of_nonneg (integral_nonneg (fun y => norm_nonneg _))]
calc
_ ≤ ∫ y, φ x*C*B (x-y) := integral_mono (hFi x).norm
((hBi x).const_mul _) (hbound x)
_ = φ x*C*(∫ y, B y) := by rw [integral_const_mul, integral_sub_left_eq_self]
lemma integrable_pair (φ : V → ℂ) (hφ : Integrable φ) (f : V →ᵇ ℂ) :
Integrable (fun x => φ x * f x) := by
apply (hφ.norm.mul_const ‖f‖).mono'
· exact hφ.aestronglyMeasurable.mul f.continuous.aestronglyMeasurable
· filter_upwards with x
rw [norm_mul]
exact mul_le_mul_of_nonneg_left (f.norm_coe_le_norm x) (norm_nonneg _)
lemma norm_pair_le (φ : V → ℂ) (hφ : Integrable φ) (f : V →ᵇ ℂ) :
‖∫ x, φ x*f x‖ ≤ (∫ x, ‖φ x‖)*‖f‖ := by
apply (norm_integral_le_integral_norm _).trans
rw [← integral_mul_const]
apply integral_mono (integrable_pair φ hφ f).norm (hφ.norm.mul_const _)
intro x
dsimp only
rw [norm_mul]
exact mul_le_mul_of_nonneg_left (f.norm_coe_le_norm x) (norm_nonneg _)
def pairCLM (φ : V → ℂ) (hφ : Integrable φ) : C₀(V,ℂ) →L[ℂ] ℂ :=
LinearMap.mkContinuous
{ toFun := fun f => ∫ x, φ x * f x
map_add' := by
intro f g
change (∫ x, φ x*(f x+g x)) = _
simp_rw [mul_add]
exact integral_add (integrable_pair φ hφ f.toBCF) (integrable_pair φ hφ g.toBCF)
map_smul' := by
intro c f
change (∫ x, φ x*(c*f x)) = c*(∫ x, φ x*f x)
simp_rw [mul_left_comm (φ _) c]
exact integral_const_mul _ _ }
(∫ x, ‖φ x‖) (fun f => norm_pair_le φ hφ f.toBCF)
@[simp] lemma pairCLM_apply (φ : V → ℂ) (hφ : Integrable φ) (f : C₀(V,ℂ)) :
pairCLM φ hφ f = ∫ x, φ x * f x := rfl
end IntegrableProdOfTranslationBound
open scoped Laplacian
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
omit [MeasurableSpace V] [BorelSpace V] in
lemma laplacian_translate (f : V → ℂ) (y : V) :
Δ (fun x => f (x-y)) = fun x => Δ f (x-y) := by
simp_rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis,
iteratedFDeriv_comp_sub]
omit [MeasurableSpace V] [BorelSpace V] in
lemma schwartz_laplacian_translate (f : SchwartzMap V ℂ) (y : V) :
Δ (f.compSubConstCLM ℂ y : SchwartzMap V ℂ) =
(Δ f : SchwartzMap V ℂ).compSubConstCLM ℂ y := by
ext x
rw [SchwartzMap.laplacian_apply, SchwartzMap.compSubConstCLM_apply,
SchwartzMap.laplacian_apply]
exact congrFun (laplacian_translate (f : V → ℂ) y) x
lemma schwartz_bilaplacian_pair (φ g : SchwartzMap V ℂ) :
(∫ x, φ x*(Δ (Δ g : SchwartzMap V ℂ) : SchwartzMap V ℂ) x) =
∫ x, (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ) x*g x := by
rw [SchwartzMap.integral_mul_laplacian_right_eq_left,
SchwartzMap.integral_mul_laplacian_right_eq_left]
lemma bilaplacian_pair_kernel (φ : SchwartzMap V ℂ) (f : V → ℂ)
(K : V → SchwartzMap V ℂ)
(h₀ : Integrable (fun p : V × V =>
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ) p.1 * (f p.2*K p.2 (p.1-p.2)))
(volume.prod volume))
(h₄ : Integrable (fun p : V × V =>
φ p.1*(f p.2*(Δ (Δ (K p.2) : SchwartzMap V ℂ) : SchwartzMap V ℂ) (p.1-p.2)))
(volume.prod volume)) :
(∫ x, φ x*(∫ y, f y*(Δ (Δ (K y) : SchwartzMap V ℂ) : SchwartzMap V ℂ) (x-y))) =
∫ x, (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ) x*(∫ y, f y*K y (x-y)) := by
simp_rw [← integral_const_mul]
conv_lhs => rw [integral_integral_swap h₄]
conv_rhs => rw [integral_integral_swap h₀]
apply integral_congr_ae
filter_upwards with y
have he := schwartz_bilaplacian_pair φ ((K y).compSubConstCLM ℂ y)
simp only [schwartz_laplacian_translate, SchwartzMap.compSubConstCLM_apply] at he
calc
_ = f y*(∫ x, φ x*(Δ (Δ (K y) : SchwartzMap V ℂ) : SchwartzMap V ℂ) (x-y)) := by
rw [← integral_const_mul]
congr 1
funext x
ring
_ = f y*(∫ x, (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ) x*K y (x-y)) := by rw [he]
_ = _ := by
rw [← integral_const_mul]
congr 1
funext x
ring
end KernelPairing
namespace FrozenParametrix
section IntegrableKernelPairProd
open scoped SchwartzMap Laplacian ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {α β : ℝ}
lemma integrable_kernel_pair_prod (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (φ : SchwartzMap V ℂ) :
Integrable (fun p : V × V => φ p.1 * (f p.2*kernel (q*(a p.2).val) (p.1-p.2)))
(volume.prod volume) := by
obtain ⟨B,hB,hbound⟩ := kernel_majorant (V := V) (q*α) (q*β) (mul_pos hq hα)
apply KernelPairing.integrable_prod_of_translation_bound _
(φ.continuous.comp continuous_fst |>.mul
((f.continuous.comp continuous_snd).mul
(continuous_kernel_comp (fun p : V × V => q*(a p.2).val) (fun p => p.1-p.2)
(continuous_const.mul (continuous_subtype_val.comp (a.continuous.comp continuous_snd)))
(continuous_fst.sub continuous_snd) (fun p => mul_pos hq (hα.trans_le (a p.2).property.1)))))
(fun x => ‖φ x‖) B φ.integrable.norm hB ‖f‖
intro x y
change ‖φ x * (f y * kernel (q*(a y).val) (x-y))‖ ≤ ‖φ x‖*‖f‖*B (x-y)
rw [norm_mul,norm_mul,mul_assoc]
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact mul_le_mul (f.toBCF.norm_coe_le_norm y)
(hbound _ ⟨mul_le_mul_of_nonneg_left (a y).property.1 hq.le,
mul_le_mul_of_nonneg_left (a y).property.2 hq.le⟩ (x-y))
(norm_nonneg _) (norm_nonneg _)
lemma integrable_bilap_pair_prod (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (φ : SchwartzMap V ℂ) :
Integrable (fun p : V × V => φ p.1 * (f p.2*bilapKernel (q*(a p.2).val) (p.1-p.2)))
(volume.prod volume) := by
obtain ⟨B,hB,_,_,hbound⟩ := bilapKernel_weighted_majorant (V := V) (q*α) (q*β) (mul_pos hq hα)
apply KernelPairing.integrable_prod_of_translation_bound _
(φ.continuous.comp continuous_fst |>.mul
((f.continuous.comp continuous_snd).mul
(continuous_bilapKernel_comp (fun p : V × V => q*(a p.2).val) (fun p => p.1-p.2)
(continuous_const.mul (continuous_subtype_val.comp (a.continuous.comp continuous_snd)))
(continuous_fst.sub continuous_snd) (fun p => mul_pos hq (hα.trans_le (a p.2).property.1)))))
(fun x => ‖φ x‖) B φ.integrable.norm hB ‖f‖
intro x y
change ‖φ x * (f y * bilapKernel (q*(a y).val) (x-y))‖ ≤ ‖φ x‖*‖f‖*B (x-y)
rw [norm_mul,norm_mul,mul_assoc]
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact mul_le_mul (f.toBCF.norm_coe_le_norm y)
(hbound _ ⟨mul_le_mul_of_nonneg_left (a y).property.1 hq.le,
mul_le_mul_of_nonneg_left (a y).property.2 hq.le⟩ (x-y))
(norm_nonneg _) (norm_nonneg _)
lemma pair_bilaplacian_timeValue (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (φ : SchwartzMap V ℂ) :
(∫ x, φ x * Δ (Δ (timeValue a q f)) x) =
∫ x, (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ) x * timeValue a q f x := by
let K : V → SchwartzMap V ℂ := fun y : V => heatKernel (q*(a y).val) (mul_pos hq (hα.trans_le (a y).property.1))
have he₀ (y x : V) : K y x = kernel (q*(a y).val) x := by
exact congrFun (heatKernel_eq_kernel _ _) x
have he₄ (y x : V) : (Δ (Δ (K y) : SchwartzMap V ℂ) : SchwartzMap V ℂ) x =
bilapKernel (q*(a y).val) x := (bilapKernel_eq_schwartz _ _ x).symm
have h₀ := integrable_kernel_pair_prod hα a q hq f (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
have h₄ := integrable_bilap_pair_prod hα a q hq f φ
simp_rw [bilaplacian_timeValue hα a q hq f]
unfold timeValue
have hp := KernelPairing.bilaplacian_pair_kernel φ f K
(by simpa only [he₀] using h₀) (by simpa only [he₄] using h₄)
simpa only [he₀,he₄] using hp
lemma norm_bilap_integral_le (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (B : V → ℝ) (hB : Integrable B)
(hbound : ∀ y z, ‖bilapKernel (q*(a y).val) z‖ ≤ B z) (x : V) :
‖∫ y, f y*bilapKernel (q*(a y).val) (x-y)‖ ≤ ‖f‖*(∫ y, B y) := by
apply (norm_integral_le_integral_norm _).trans
calc
_ ≤ ∫ y, ‖f‖*B (x-y) := by
apply integral_mono (integrable_bilapValue_integrand hα a q hq f x).norm
((hB.comp_sub_left x).const_mul _)
intro y
dsimp only
rw [norm_mul]
exact mul_le_mul (f.toBCF.norm_coe_le_norm y) (hbound y (x-y))
(norm_nonneg _) (norm_nonneg _)
_ = _ := by rw [integral_const_mul, integral_sub_left_eq_self]
lemma hasDerivAt_pair_timeValue (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (φ : SchwartzMap V ℂ) :
HasDerivAt (fun s => ∫ x, φ x*timeValue a s f x)
(-(∫ x, (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ) x *
timeValue a q (C0Multiplier.mul (coefficient a) f) x)) q := by
let f₁ := C0Multiplier.mul (coefficient a) f
let F := fun s : ℝ => fun x : V => φ x*timeValue a s f x
let F' := fun s : ℝ => fun x : V =>
-(φ x*(∫ y, f₁ y*bilapKernel (s*(a y).val) (x-y)))
have hay (y : V) : 0 < (a y).val := hα.trans_le (a y).property.1
have hβ : 0 < β := (hay 0).trans_le (a 0).property.2
have hFi (s : ℝ) (hs : 0 < s) : Integrable (F s) := by
have hh := (integrable_kernel_pair_prod hα a s hs f φ).integral_prod_left
simpa only [F,timeValue,integral_const_mul] using hh
have hF'i (s : ℝ) (hs : 0 < s) : Integrable (F' s) := by
have hh := (integrable_bilap_pair_prod hα a s hs f₁ φ).integral_prod_left.neg
change Integrable (fun x => -(∫ y, φ x * (f₁ y *
bilapKernel (s*(a y).val) (x-y)))) at hh
simpa only [F',integral_const_mul] using hh
obtain ⟨B,hB,_,_,hbound⟩ := bilapKernel_weighted_majorant (V := V)
((q/2)*α) ((2*q)*β) (by positivity)
have hspos (s : ℝ) (hs : s ∈ Ioo (q/2) (2*q)) : 0 < s := lt_trans (by positivity) hs.1
have hsb (s : ℝ) (hs : s ∈ Ioo (q/2) (2*q)) (y : V) :
s*(a y).val ∈ Icc ((q/2)*α) ((2*q)*β) :=
⟨mul_le_mul hs.1.le (a y).property.1 hα.le (hspos s hs).le,
mul_le_mul hs.2.le (a y).property.2 (hay y).le (by positivity)⟩
have hd := hasDerivAt_integral_of_dominated_loc_of_deriv_le
(F := F) (F' := F') (bound := fun x => ‖φ x‖*(‖f₁‖*(∫ y, B y)))
(s := Ioo (q/2) (2*q)) (Ioo_mem_nhds (by linarith) (by linarith))
(by filter_upwards [Ioi_mem_nhds hq] with s hs; exact (hFi s hs).aestronglyMeasurable)
(hFi q hq) (hF'i q hq).aestronglyMeasurable
(Eventually.of_forall (fun x s hs => by
simp only [F',norm_neg,norm_mul]
exact mul_le_mul_of_nonneg_left
(norm_bilap_integral_le hα a s (hspos s hs) f₁ B hB
(fun y z => hbound _ (hsb s hs y) z) x) (norm_nonneg _)))
(φ.integrable.norm.mul_const _)
(Eventually.of_forall (fun x s hs => by
convert (hasDerivAt_timeValue hα a s (hspos s hs) f x).const_mul (φ x) using 1
simp only [F',f₁,C0Multiplier.mul_apply,coefficient_apply,mul_neg]))
have he : (∫ x, F' q x) = -(∫ x, (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ) x *
timeValue a q f₁ x) := by
unfold F'
rw [integral_neg]
congr 1
simpa only [bilaplacian_timeValue hα a q hq f₁] using
pair_bilaplacian_timeValue hα a q hq f₁ φ
rw [he] at hd
exact hd.2
lemma integrable_pair_bilaplacian (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (φ : SchwartzMap V ℂ) :
Integrable (fun x => φ x * Δ (Δ (timeValue a q f)) x) := by
simp_rw [bilaplacian_timeValue hα a q hq f]
have hh := (integrable_bilap_pair_prod hα a q hq f φ).integral_prod_left
simpa only [integral_const_mul] using hh
lemma integrable_pair_timeValue (hα : 0 < α) (a : C(V,Icc α β)) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (φ : V → ℂ) (hφ : Integrable φ) :
Integrable (fun x => φ x * timeValue a q f x) := by
rw [timeValue_eq_frozenOp hα a q hq f]
exact KernelPairing.integrable_pair φ hφ (frozenOp hα a (ParabolicRadius.radius q) f).toBCF
lemma weak_frozen_residual (hα : 0 < α) (a₀ a₁ : C(V,Icc α β)) (b : V →ᵇ ℂ)
(q : ℝ) (hq : 0 < q) (f : C₀(V,ℂ)) (φ ψ : SchwartzMap V ℂ)
(hψ : ∀ x, ψ x = ((a₁ x).val : ℂ)*φ x) :
deriv (fun s => ∫ x, φ x*timeValue a₀ s f x) q +
(∫ x, (Δ (Δ ψ : SchwartzMap V ℂ) : SchwartzMap V ℂ) x*timeValue a₀ q f x) +
(∫ x, φ x*b x*timeValue a₀ q f x) =
∫ x, φ x*fullResidualCLM hα a₀ a₁ b (ParabolicRadius.radius q) f x := by
let f₁ := C0Multiplier.mul (coefficient a₀) f
have hD (x : V) : deriv (fun s => timeValue a₀ s f x) q =
-Δ (Δ (timeValue a₀ q f₁)) x := by
rw [(hasDerivAt_timeValue hα a₀ q hq f x).deriv,
bilaplacian_timeValue hα a₀ q hq f₁]
rfl
have hid : Integrable (fun x => -(φ x * Δ (Δ (timeValue a₀ q f₁)) x)) :=
(integrable_pair_bilaplacian hα a₀ q hq f₁ φ).neg
have his := integrable_pair_bilaplacian hα a₀ q hq f ψ
have hiz := integrable_pair_timeValue hα a₀ q hq f (fun x => φ x*b x)
(KernelPairing.integrable_pair φ φ.integrable b)
have he : (∫ x, -(φ x * Δ (Δ (timeValue a₀ q f₁)) x) +
ψ x * Δ (Δ (timeValue a₀ q f)) x + φ x*b x*timeValue a₀ q f x) =
∫ x, φ x*fullResidualCLM hα a₀ a₁ b (ParabolicRadius.radius q) f x := by
apply integral_congr_ae
filter_upwards with x
rw [← frozen_pde_residual hα a₀ a₁ b q hq f x, hD, hψ]
ring
have hids : Integrable (fun x => -(φ x * Δ (Δ (timeValue a₀ q f₁)) x) +
ψ x * Δ (Δ (timeValue a₀ q f)) x) := hid.add his
rw [integral_add hids hiz, integral_add hid his, integral_neg,
pair_bilaplacian_timeValue hα a₀ q hq f₁ φ,
pair_bilaplacian_timeValue hα a₀ q hq f ψ] at he
rw [(hasDerivAt_pair_timeValue hα a₀ q hq f φ).deriv]
exact he
end IntegrableKernelPairProd
open scoped SchwartzMap Laplacian ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel KernelPairing
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {α β : ℝ}
def c0Time (hα : 0 < α) (a : V →ᵇ Icc α β) (q : ℝ) (f : C₀(V,ℂ)) : C₀(V,ℂ) :=
frozenOp hα a.toContinuousMap (ParabolicRadius.radius q) f
lemma continuous_c0Time (hα : 0 < α) (a : V →ᵇ Icc α β) (f : C₀(V,ℂ)) :
Continuous (fun q : ℝ => c0Time hα a q f) :=
continuous_frozenOp_comp hα (fun _ => a) ParabolicRadius.radius continuous_const
(ParabolicRadius.continuous_comp _ continuous_id) f
lemma c0Time_zero (hα : 0 < α) (a : V →ᵇ Icc α β) (f : C₀(V,ℂ)) :
c0Time hα a 0 f = f := by
unfold c0Time ParabolicRadius.radius
rw [Real.zero_rpow (by norm_num : (1/4 : ℝ) ≠ 0)]
exact frozen_zero _ _ _ _ _ _ f
lemma c0Time_apply (hα : 0 < α) (a : V →ᵇ Icc α β) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (x : V) : c0Time hα a q f x = timeValue a.toContinuousMap q f x :=
(congrFun (timeValue_eq_frozenOp hα a.toContinuousMap q hq f) x).symm
lemma hasDerivAt_pair_c0Time (hα : 0 < α) (a : V →ᵇ Icc α β) (q : ℝ) (hq : 0 < q)
(f : C₀(V,ℂ)) (φ : SchwartzMap V ℂ) :
HasDerivAt (fun s => pairCLM φ φ.integrable (c0Time hα a s f))
(-pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
(c0Time hα a q (C0Multiplier.mul (coefficient a.toContinuousMap) f))) q := by
have he (s : ℝ) (hs : 0 < s) (g : C₀(V,ℂ)) (ψ : SchwartzMap V ℂ) :
pairCLM ψ ψ.integrable (c0Time hα a s g) = ∫ x, ψ x*timeValue a.toContinuousMap s g x := by
simp only [pairCLM_apply,c0Time_apply hα a s hs g]
rw [he q hq]
apply (hasDerivAt_pair_timeValue hα a.toContinuousMap q hq f φ).congr_of_eventuallyEq
filter_upwards [Ioi_mem_nhds hq] with s hs
exact he s hs f φ
lemma pair_c0Time_integral (hα : 0 < α) (a : V →ᵇ Icc α β) (q : ℝ) (hq : 0 ≤ q)
(f : C₀(V,ℂ)) (φ : SchwartzMap V ℂ) :
pairCLM φ φ.integrable (c0Time hα a q f) = pairCLM φ φ.integrable f -
∫ s in (0 : ℝ)..q,
pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
(c0Time hα a s (C0Multiplier.mul (coefficient a.toContinuousMap) f)) := by
let L := pairCLM φ φ.integrable
let M := pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
let f₁ := C0Multiplier.mul (coefficient a.toContinuousMap) f
have hc := L.continuous.comp (continuous_c0Time hα a f)
have hd := (M.continuous.comp (continuous_c0Time hα a f₁)).neg
have hh := intervalIntegral.integral_eq_sub_of_hasDerivAt_of_le hq hc.continuousOn
(fun s hs => hasDerivAt_pair_c0Time hα a s hs.1 f φ) (hd.intervalIntegrable 0 q)
change (∫ y in (0 : ℝ)..q, -M (c0Time hα a y f₁)) =
L (c0Time hα a q f) - L (c0Time hα a 0 f) at hh
rw [c0Time_zero, intervalIntegral.integral_neg] at hh
change L (c0Time hα a q f) = L f - ∫ s in (0 : ℝ)..q, M (c0Time hα a s f₁)
dsimp only [L] at hh ⊢
linear_combination -hh
end FrozenParametrix
namespace StrongWeightedVolterra
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
variable {T : ℝ}
lemma continuous_unweighted_on_time (j : Time T →ᵇ E) :
Continuous (fun t : Time T => unweighted j t.val) := by
simp_rw [unweighted_at_time]
exact (continuous_subtype_val.rpow_const (fun t => Or.inl t.property.1.ne')).smul j.continuous
lemma stronglyMeasurable_unweighted (j : Time T →ᵇ E) : StronglyMeasurable (unweighted j) := by
classical
unfold unweighted
apply StronglyMeasurable.dite (s := Time T)
(f := fun t : Time T => t.val^(-3/4 : ℝ) • j t)
(g := fun _ => (0 : E)) _ stronglyMeasurable_const measurableSet_Ioc
exact ((continuous_subtype_val.rpow_const (fun t : Time T => Or.inl t.property.1.ne')).smul
j.continuous).stronglyMeasurable
lemma norm_unweighted_le (j : Time T →ᵇ E) (r : ℝ) (hr : 0 < r) :
‖unweighted j r‖ ≤ r^(-3/4 : ℝ)*‖j‖ := by
by_cases hrt : r ≤ T
· rw [unweighted,dite_eq_left (show r ∈ Ioc 0 T from ⟨hr,hrt⟩),norm_smul,
Real.norm_eq_abs,abs_of_nonneg (Real.rpow_nonneg hr.le _)]
exact mul_le_mul_of_nonneg_left (j.norm_coe_le_norm _) (Real.rpow_nonneg hr.le _)
· rw [unweighted,dite_eq_right (by simpa only [mem_Ioc,not_and,not_le] using fun _ => lt_of_not_ge hrt),norm_zero]
positivity
lemma intervalIntegrable_unweighted (j : Time T →ᵇ E) (t : ℝ) (ht : 0 ≤ t) :
IntervalIntegrable (unweighted j) volume 0 t := by
apply (intervalIntegrable_iff_integrableOn_Ioo_of_le ht).mpr
have hp : IntegrableOn (fun r : ℝ => r^(-3/4 : ℝ)*‖j‖) (Ioo 0 t) := by
rcases eq_or_lt_of_le ht with he | ht'
· subst t; simp
· exact ((intervalIntegral.integrableOn_Ioo_rpow_iff ht').mpr (by norm_num)).mul_const ‖j‖
apply hp.mono' (stronglyMeasurable_unweighted j).aestronglyMeasurable
filter_upwards [ae_restrict_mem measurableSet_Ioo] with r hr
exact norm_unweighted_le j r hr.1
end StrongWeightedVolterra
namespace VolterraIntegral
section IntegralTriangleLeft
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
variable {T : ℝ}
lemma integral_triangle_left (F : ℝ → ℝ → E) (hT : 0 ≤ T) (r : ℝ)
(hr : r ∈ Icc 0 T) :
(∫ s in (0 : ℝ)..T, if s < r then F r s else 0) = ∫ s in (0 : ℝ)..r, F r s := by
rw [intervalIntegral.integral_of_le hT, intervalIntegral.integral_of_le hr.1]
change (∫ s in Ioc (0 : ℝ) T, (Iio r).indicator (F r) s) = _
rw [integral_indicator measurableSet_Iio, Measure.restrict_restrict measurableSet_Iio]
have he : Iio r ∩ Ioc (0 : ℝ) T = Ioo 0 r := by
ext x
simp only [mem_inter_iff, mem_Iio, mem_Ioc, mem_Ioo]
constructor
· rintro ⟨hxr,hx0,_⟩; exact ⟨hx0,hxr⟩
· rintro ⟨hx0,hxr⟩; exact ⟨hxr,hx0,hxr.le.trans hr.2⟩
rw [he, integral_Ioc_eq_integral_Ioo]
lemma integral_triangle_right (F : ℝ → ℝ → E) (hT : 0 ≤ T) (s : ℝ)
(hs : s ∈ Icc 0 T) :
(∫ r in (0 : ℝ)..T, if s < r then F r s else 0) = ∫ r in s..T, F r s := by
rw [intervalIntegral.integral_of_le hT, intervalIntegral.integral_of_le hs.2]
change (∫ r in Ioc (0 : ℝ) T, (Ioi s).indicator (fun r => F r s) r) = _
rw [integral_indicator measurableSet_Ioi, Measure.restrict_restrict measurableSet_Ioi]
have he : Ioi s ∩ Ioc (0 : ℝ) T = Ioc s T := by
ext x
simp only [mem_inter_iff, mem_Ioi, mem_Ioc]
constructor
· rintro ⟨hsx,_,hxT⟩; exact ⟨hsx,hxT⟩
· rintro ⟨hsx,hxT⟩; exact ⟨hsx,lt_of_le_of_lt hs.1 hsx,hxT⟩
rw [he]
lemma integral_triangle_swap (F : ℝ → ℝ → E) (hT : 0 ≤ T)
(hF : IntegrableOn (fun p : ℝ × ℝ => if p.2 < p.1 then F p.1 p.2 else 0)
(Ioc 0 T ×ˢ Ioc 0 T)) :
(∫ r in (0 : ℝ)..T, ∫ s in (0 : ℝ)..r, F r s) =
∫ s in (0 : ℝ)..T, ∫ r in s..T, F r s := by
have hh := intervalIntegral_intervalIntegral_swap
(F := fun r s => if s < r then F r s else 0)
(a := 0) (b := T) (c := 0) (d := T) (by simpa only [uIoc_of_le hT, Function.uncurry_def] using hF)
calc
_ = ∫ r in (0 : ℝ)..T, ∫ s in (0 : ℝ)..T, if s < r then F r s else 0 := by
apply intervalIntegral.integral_congr
intro r hr
exact (integral_triangle_left F hT r (by simpa only [uIcc_of_le hT] using hr)).symm
_ = _ := hh
_ = _ := by
apply intervalIntegral.integral_congr
intro s hs
exact integral_triangle_right F hT s (by simpa only [uIcc_of_le hT] using hs)
end IntegralTriangleLeft
section IntegrableOnTriangleOfBound
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
variable {T : ℝ}
omit [NormedSpace ℝ E] in
lemma integrableOn_triangle_of_bound (F : ℝ → ℝ → E)
(hF : AEStronglyMeasurable
(fun p : ℝ × ℝ => if p.2 < p.1 then F p.1 p.2 else 0)
(volume.restrict (Ioc 0 T ×ˢ Ioc 0 T)))
(B : ℝ → ℝ) (hB : IntegrableOn B (Ioc 0 T))
(hB0 : ∀ s ∈ Ioc 0 T, 0 ≤ B s)
(hbound : ∀ r ∈ Ioc 0 T, ∀ s ∈ Ioc 0 T, s < r → ‖F r s‖ ≤ B s) :
IntegrableOn (fun p : ℝ × ℝ => if p.2 < p.1 then F p.1 p.2 else 0)
(Ioc 0 T ×ˢ Ioc 0 T) := by
have hb : IntegrableOn (fun p : ℝ × ℝ => B p.2) (Ioc 0 T ×ˢ Ioc 0 T) := by
have hh := hB.comp_snd (volume.restrict (Ioc (0 : ℝ) T))
simpa only [Measure.prod_restrict, Measure.volume_eq_prod, IntegrableOn] using hh
refine hb.mono' hF ?_
filter_upwards [ae_restrict_mem (measurableSet_Ioc.prod measurableSet_Ioc)] with p hp
by_cases hlt : p.2 < p.1
· simpa only [ite_eq_left hlt] using hbound p.1 hp.1 p.2 hp.2 hlt
· simpa only [ite_eq_right hlt, norm_zero] using hB0 p.2 hp.2
lemma duhamel_integral_identity (A F : ℝ → ℝ → E) (d : ℝ → E) (hT : 0 ≤ T)
(hA : IntervalIntegrable (A T) volume 0 T)
(hd : IntervalIntegrable d volume 0 T)
(hF : IntegrableOn (fun p : ℝ × ℝ => if p.2 < p.1 then F p.1 p.2 else 0)
(Ioc 0 T ×ˢ Ioc 0 T))
(hFTC : ∀ s ∈ Ioo 0 T, A T s - d s = ∫ r in s..T, F r s) :
(∫ s in (0 : ℝ)..T, A T s) = (∫ s in (0 : ℝ)..T, d s) +
∫ r in (0 : ℝ)..T, ∫ s in (0 : ℝ)..r, F r s := by
rw [integral_triangle_swap F hT hF]
have he : (∫ s in (0 : ℝ)..T, A T s - d s) =
∫ s in (0 : ℝ)..T, ∫ r in s..T, F r s := by
exact intervalIntegral.integral_congr_Ioo_of_le hT hFTC
rw [intervalIntegral.integral_sub hA hd] at he
exact sub_eq_iff_eq_add'.mp he
end IntegrableOnTriangleOfBound
variable {E : Type*} [NormedAddCommGroup E]
variable {T : ℝ}
def sourceExtend (F : ℝ × Ioc (0 : ℝ) T → E) (r s : ℝ) : E :=
if hs : s ∈ Ioc (0 : ℝ) T then F (r,⟨s,hs⟩) else 0
lemma sourceExtend_apply (F : ℝ × Ioc (0 : ℝ) T → E) (r s : ℝ) (hs : s ∈ Ioc (0 : ℝ) T) :
sourceExtend F r s = F (r,⟨s,hs⟩) := by rw [sourceExtend,dite_eq_left hs]
lemma stronglyMeasurable_sourceExtend (F : ℝ × Ioc (0 : ℝ) T → E) (hF : Continuous F) :
StronglyMeasurable (fun p : ℝ × ℝ => sourceExtend F p.1 p.2) := by
classical
let D : Set (ℝ × ℝ) := {p | p.2 ∈ Ioc (0 : ℝ) T}
let G : D → ℝ × Ioc (0 : ℝ) T := fun p => (p.val.1,⟨p.val.2,p.property⟩)
have hG : Continuous G := by
exact (continuous_fst.comp continuous_subtype_val).prodMk
((continuous_snd.comp continuous_subtype_val).subtype_mk _)
have hD : MeasurableSet D := measurableSet_Ioc.preimage measurable_snd
exact StronglyMeasurable.dite (s := D) (f := F ∘ G) (g := fun _ => 0)
(hF.comp hG).stronglyMeasurable stronglyMeasurable_const hD
lemma integrableOn_sourceExtend (F : ℝ × Ioc (0 : ℝ) T → E) (hF : Continuous F)
(B : ℝ → ℝ) (hB : IntegrableOn B (Ioc 0 T))
(hbound : ∀ (r : ℝ) (s : Ioc (0 : ℝ) T), ‖F (r,s)‖ ≤ B s.val) (r : ℝ) :
IntegrableOn (sourceExtend F r) (Ioc 0 T) := by
apply hB.mono'
· exact ((stronglyMeasurable_sourceExtend F hF).comp_measurable
(measurable_const.prodMk measurable_id)).aestronglyMeasurable
· filter_upwards [ae_restrict_mem measurableSet_Ioc] with s hs
rw [sourceExtend_apply F r s hs]
exact hbound r ⟨s,hs⟩
lemma integrableOn_sourceExtend_triangle (F : ℝ × Ioc (0 : ℝ) T → E) (hF : Continuous F)
(B : ℝ → ℝ) (hB : IntegrableOn B (Ioc 0 T))
(hbound : ∀ (r : ℝ) (s : Ioc (0 : ℝ) T), ‖F (r,s)‖ ≤ B s.val) :
IntegrableOn (fun p : ℝ × ℝ => if p.2 < p.1 then sourceExtend F p.1 p.2 else 0)
(Ioc 0 T ×ˢ Ioc 0 T) := by
apply integrableOn_triangle_of_bound (sourceExtend F)
(((stronglyMeasurable_sourceExtend F hF).ite
(measurableSet_lt measurable_snd measurable_fst) stronglyMeasurable_const).aestronglyMeasurable)
B hB
· intro s hs
exact (norm_nonneg _).trans (hbound 0 ⟨s,hs⟩)
· intro r _ s hs _
rw [sourceExtend_apply F r s hs]
exact hbound r ⟨s,hs⟩
end VolterraIntegral
namespace FrozenParametrix
open scoped ZeroAtInfty BoundedContinuousFunction
open StrongWeightedVolterra ParametrixVolterra
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {α β : ℝ}
lemma continuous_c0Time_comp {X : Type*} [TopologicalSpace X] [FirstCountableTopology X]
(hα : 0 < α) (a : X → V →ᵇ Icc α β) (q : X → ℝ) (f : X → C₀(V,ℂ))
(ha : Continuous a) (hq : Continuous q) (hf : Continuous f) :
Continuous (fun x => c0Time hα (a x) (q x) (f x)) := by
have h := continuous_apply_of_strong
(fun x => frozenCLM hα (a x).toContinuousMap (ParabolicRadius.radius (q x)))
(fun d => continuous_frozenOp_comp hα a (fun x => ParabolicRadius.radius (q x)) ha
(ParabolicRadius.continuous_comp q hq) d)
(frozenBound (V := V) (β := β) hα) (frozenBound_nonneg hα)
(fun x => norm_frozenCLM_le hα (a x).toContinuousMap (ParabolicRadius.radius (q x)))
have hh := h.comp (continuous_id.prodMk hf)
simpa only [Function.comp_def, id_eq, frozenCLM_apply, c0Time] using hh
lemma norm_c0Time_le (hα : 0 < α) (a : V →ᵇ Icc α β) (q : ℝ) (f : C₀(V,ℂ)) :
‖c0Time hα a q f‖ ≤ frozenBound (V := V) (β := β) hα * ‖f‖ := by
exact (frozenCLM hα a.toContinuousMap (ParabolicRadius.radius q)).le_opNorm f |>.trans
(mul_le_mul_of_nonneg_right (norm_frozenCLM_le hα a.toContinuousMap _) (norm_nonneg _))
end FrozenParametrix
namespace ParametrixVolterra
section ContinuousSourceMultiply
open scoped ZeroAtInfty BoundedContinuousFunction SchwartzMap Laplacian
open FrozenParametrix StrongWeightedVolterra KernelPairing
variable {V : Type} [NormedAddCommGroup V]
variable {T α β : ℝ}
variable (A : C(Slab T,V →ᵇ Icc α β))
lemma continuous_sourceMultiply (j : Time T →ᵇ C₀(V,ℂ)) :
Continuous (fun t : Time T => C0Multiplier.mul (coefficient (A (now t)).toContinuousMap) (j t)) :=
C0Multiplier.continuous_mul_joint.comp
((continuous_coefficient_comp (fun t => A (now t)) (A.continuous.comp continuous_now)).prodMk j.continuous)
lemma norm_sourceMultiply_le (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T) :
‖C0Multiplier.mul (coefficient (A (now t)).toContinuousMap) (j t)‖ ≤ max |α| |β| * ‖j‖ :=
(C0Multiplier.norm_mul_le _ _).trans
(mul_le_mul (norm_coefficient_le _) (j.norm_coe_le_norm t) (norm_nonneg _)
((abs_nonneg α).trans (le_max_left _ _)))
def sourceMultiply (j : Time T →ᵇ C₀(V,ℂ)) : Time T →ᵇ C₀(V,ℂ) :=
.ofNormedAddCommGroup _ (continuous_sourceMultiply A j) _ (norm_sourceMultiply_le A j)
lemma sourceMultiply_apply (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T) :
sourceMultiply A j t = C0Multiplier.mul (coefficient (A (now t)).toContinuousMap) (j t) := rfl
lemma unweighted_sourceMultiply (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T) :
unweighted (sourceMultiply A j) t.val =
C0Multiplier.mul (coefficient (A (now t)).toContinuousMap) (unweighted j t.val) := by
rw [unweighted_at_time,unweighted_at_time,sourceMultiply_apply]
ext x
simp only [ZeroAtInftyContinuousMap.smul_apply,C0Multiplier.mul_apply]
rw [mul_smul_comm]
end ContinuousSourceMultiply
open scoped ZeroAtInfty BoundedContinuousFunction SchwartzMap Laplacian
open FrozenParametrix StrongWeightedVolterra KernelPairing VolterraIntegral
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {T α β : ℝ}
variable (hα : 0 < α) (A : C(Slab T,V →ᵇ Icc α β))
def sourceFrozen (j : Time T →ᵇ C₀(V,ℂ)) (p : ℝ × Time T) : C₀(V,ℂ) :=
c0Time hα (A (now p.2)) (p.1-p.2.val) (unweighted j p.2.val)
lemma continuous_sourceFrozen (j : Time T →ᵇ C₀(V,ℂ)) : Continuous (sourceFrozen hα A j) :=
continuous_c0Time_comp hα _ _ _
(A.continuous.comp (continuous_now.comp continuous_snd))
(continuous_fst.sub (continuous_subtype_val.comp continuous_snd))
((continuous_unweighted_on_time j).comp continuous_snd)
lemma norm_sourceFrozen_le (j : Time T →ᵇ C₀(V,ℂ)) (p : ℝ × Time T) :
‖sourceFrozen hα A j p‖ ≤ frozenBound (V := V) (β := β) hα *
(p.2.val^(-3/4 : ℝ)*‖j‖) :=
(norm_c0Time_le hα _ _ _).trans (mul_le_mul_of_nonneg_left
(norm_unweighted_le j p.2.val p.2.property.1) (frozenBound_nonneg hα))
lemma integrableOn_sourceFrozen_bound (j : Time T →ᵇ C₀(V,ℂ)) :
IntegrableOn (fun s : ℝ => frozenBound (V := V) (β := β) hα*(s^(-3/4 : ℝ)*‖j‖)) (Ioc 0 T) := by
have h := (intervalIntegral.intervalIntegrable_rpow' (a := 0) (b := T)
(by norm_num : (-1:ℝ) < -3/4)).mul_const ‖j‖ |>.const_mul (frozenBound (V := V) (β := β) hα)
exact h.1
lemma integrableOn_sourceFrozen_triangle (j : Time T →ᵇ C₀(V,ℂ)) :
IntegrableOn (fun p : ℝ × ℝ => if p.2 < p.1 then
sourceExtend (sourceFrozen hα A j) p.1 p.2 else 0) (Ioc 0 T ×ˢ Ioc 0 T) :=
integrableOn_sourceExtend_triangle _ (continuous_sourceFrozen hα A j) _
(integrableOn_sourceFrozen_bound hα j) (fun r s => norm_sourceFrozen_le hα A j (r,s))
lemma intervalIntegrable_sourceFrozen (j : Time T →ᵇ C₀(V,ℂ)) (r t : ℝ) (ht : t ∈ Icc 0 T) :
IntervalIntegrable (sourceExtend (sourceFrozen hα A j) r) volume 0 t := by
apply (intervalIntegrable_iff_integrableOn_Ioc_of_le ht.1).mpr
exact (integrableOn_sourceExtend _ (continuous_sourceFrozen hα A j) _
(integrableOn_sourceFrozen_bound hα j) (fun r s => norm_sourceFrozen_le hα A j (r,s)) r).mono_set
(Ioc_subset_Ioc le_rfl ht.2)
def duhamel (j : Time T →ᵇ C₀(V,ℂ)) (t : ℝ) : C₀(V,ℂ) :=
∫ s in (0 : ℝ)..t, sourceExtend (sourceFrozen hα A j) t s
lemma sourceFrozen_eq_frozenRaw (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ))
(t : Time T) (s : ℝ) (hs : s ∈ Ioo 0 t.val) :
sourceExtend (sourceFrozen hα A j) t.val s = frozenRaw hα A hT t s (unweighted j s) := by
have hsT : s ∈ Ioc (0 : ℝ) T := ⟨hs.1,hs.2.le.trans t.property.2⟩
have hsT' : s ∈ Icc (0 : ℝ) T := ⟨hs.1.le,hsT.2⟩
rw [sourceExtend_apply _ _ _ hsT,frozenRaw,ite_eq_left hs,projIcc_of_mem hT hsT']
rfl
lemma duhamel_eq_value (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T) :
duhamel hα A j t.val = MildVolterra.value (mildKernel hα A) j t := by
rw [duhamel,MildVolterra.value_eq_integral]
apply intervalIntegral.integral_congr_Ioo_of_le t.property.1.le
intro s hs
dsimp only
rw [rawKernel_eq_frozenRaw hα A hT]
exact sourceFrozen_eq_frozenRaw hα A hT j t s hs
lemma continuousOn_duhamel (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) :
ContinuousOn (duhamel hα A j) (Ioc 0 T) := by
apply continuousOn_iff_continuous_domRestrict.mpr
change Continuous (fun t : Time T => duhamel hα A j t.val)
simp_rw [duhamel_eq_value hα A hT j]
exact MildVolterra.continuous_value (mildKernel hα A) (frozenBound (V := V) (β := β) hα)
(frozenBound_nonneg hα) (norm_mildKernel_le hα A) j
lemma continuousAt_duhamel (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) (t : ℝ) (ht : t ∈ Ioo 0 T) :
ContinuousAt (duhamel hα A j) t :=
(continuousOn_duhamel hα A hT j).continuousAt (Ioc_mem_nhds ht.1 ht.2)
lemma integrableOn_pair_sourceFrozen_triangle (j : Time T →ᵇ C₀(V,ℂ))
(L : C₀(V,ℂ) →L[ℂ] ℂ) :
IntegrableOn (fun p : ℝ × ℝ => if p.2 < p.1 then
L (sourceExtend (sourceFrozen hα A j) p.1 p.2) else 0) (Ioc 0 T ×ˢ Ioc 0 T) := by
have hh := L.integrable_comp (integrableOn_sourceFrozen_triangle hα A j)
simpa only [IntegrableOn,apply_ite,map_zero] using hh
lemma sourceFrozen_weakFTC (j : Time T →ᵇ C₀(V,ℂ)) (φ : SchwartzMap V ℂ)
(t : ℝ) (ht : t ∈ Icc 0 T) (s : ℝ) (hs : s ∈ Ioo 0 t) :
pairCLM φ φ.integrable (sourceExtend (sourceFrozen hα A j) t s) -
pairCLM φ φ.integrable (unweighted j s) =
∫ r in s..t, -pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
(sourceExtend (sourceFrozen hα A (sourceMultiply A j)) r s) := by
have hsT : s ∈ Ioc (0 : ℝ) T := ⟨hs.1,hs.2.le.trans ht.2⟩
let s₁ : Time T := ⟨s,hsT⟩
let M := pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
let f₁ := C0Multiplier.mul (coefficient (A (now s₁)).toContinuousMap) (unweighted j s)
have he (r : ℝ) : sourceExtend (sourceFrozen hα A (sourceMultiply A j)) r s =
c0Time hα (A (now s₁)) (r-s) f₁ := by
rw [sourceExtend_apply _ _ _ hsT]
change c0Time hα (A (now s₁)) (r-s) (unweighted (sourceMultiply A j) s₁.val) = _
rw [unweighted_sourceMultiply]
have hh := pair_c0Time_integral hα (A (now s₁)) (t-s) (sub_nonneg.mpr hs.2.le)
(unweighted j s) φ
simp_rw [he]
change pairCLM φ φ.integrable (sourceExtend (sourceFrozen hα A j) t s) -
pairCLM φ φ.integrable (unweighted j s) = ∫ r in s..t, -M (c0Time hα (A (now s₁)) (r-s) f₁)
rw [intervalIntegral.integral_neg,intervalIntegral.integral_comp_sub_right
(fun q => M (c0Time hα (A (now s₁)) q f₁)) s,sub_self,
sourceExtend_apply _ _ _ hsT]
change pairCLM φ φ.integrable (c0Time hα (A (now s₁)) (t-s) (unweighted j s)) -
pairCLM φ φ.integrable (unweighted j s) = -∫ q in (0 : ℝ)..t-s, M (c0Time hα (A (now s₁)) q f₁)
exact sub_eq_iff_eq_add.mpr (by convert hh using 1; abel)
lemma pair_duhamel_integral (j : Time T →ᵇ C₀(V,ℂ)) (φ : SchwartzMap V ℂ)
(t : ℝ) (ht : t ∈ Icc 0 T) :
pairCLM φ φ.integrable (duhamel hα A j t) =
(∫ s in (0 : ℝ)..t, pairCLM φ φ.integrable (unweighted j s)) -
∫ r in (0 : ℝ)..t, pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
(duhamel hα A (sourceMultiply A j) r) := by
let L := pairCLM φ φ.integrable
let M := pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
let K := sourceExtend (sourceFrozen hα A j)
let Q := sourceExtend (sourceFrozen hα A (sourceMultiply A j))
have hK := intervalIntegrable_sourceFrozen hα A j t t ht
have hu := intervalIntegrable_unweighted j t ht.1
have hA : IntervalIntegrable (fun s => L (K t s)) volume 0 t :=
⟨L.integrable_comp hK.1,L.integrable_comp hK.2⟩
have hd : IntervalIntegrable (fun s => L (unweighted j s)) volume 0 t :=
⟨L.integrable_comp hu.1,L.integrable_comp hu.2⟩
have hQ := (integrableOn_pair_sourceFrozen_triangle hα A (sourceMultiply A j) M).neg
have hQt : IntegrableOn (fun p : ℝ × ℝ => if p.2 < p.1 then -M (Q p.1 p.2) else 0)
(Ioc 0 t ×ˢ Ioc 0 t) := by
have he : (fun p : ℝ × ℝ => if p.2 < p.1 then -M (Q p.1 p.2) else 0) =
(fun p : ℝ × ℝ => -(if p.2 < p.1 then M (Q p.1 p.2) else 0)) := by
funext p; split_ifs <;> simp
rw [he]
exact hQ.mono_set (Set.prod_mono (Ioc_subset_Ioc le_rfl ht.2) (Ioc_subset_Ioc le_rfl ht.2))
have hh := duhamel_integral_identity (fun r s => L (K r s)) (fun r s => -M (Q r s))
(fun s => L (unweighted j s)) ht.1 hA hd hQt (sourceFrozen_weakFTC hα A j φ t ht)
have he : (∫ r in (0 : ℝ)..t, ∫ s in (0 : ℝ)..r, -M (Q r s)) =
-(∫ r in (0 : ℝ)..t, M (duhamel hα A (sourceMultiply A j) r)) := by
rw [← intervalIntegral.integral_neg]
apply intervalIntegral.integral_congr_Ioo_of_le ht.1
intro r hr
dsimp only
rw [intervalIntegral.integral_neg]
congr 1
exact M.intervalIntegral_comp_comm (intervalIntegrable_sourceFrozen hα A (sourceMultiply A j) r r
⟨hr.1.le,hr.2.le.trans ht.2⟩)
rw [he] at hh
rw [L.intervalIntegral_comp_comm hK] at hh
exact hh
lemma duhamel_zero (j : Time T →ᵇ C₀(V,ℂ)) : duhamel hα A j 0 = 0 := by simp [duhamel]
lemma norm_duhamel_le (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) (t : ℝ) (ht : t ∈ Icc 0 T) :
‖duhamel hα A j t‖ ≤ t^(1/4 : ℝ)*
((∫ u : UnitTime, MildVolterra.massWeight u)*frozenBound (V := V) (β := β) hα*‖j‖) := by
rcases eq_or_lt_of_le ht.1 with he | ht0
· subst t; rw [duhamel_zero,norm_zero,Real.zero_rpow (by norm_num : (1/4 : ℝ) ≠ 0),zero_mul]
· let t₁ : Time T := ⟨t,ht0,ht.2⟩
change ‖duhamel hα A j t₁.val‖ ≤ _
rw [duhamel_eq_value hα A hT]
exact MildVolterra.norm_value_le (mildKernel hα A) (frozenBound (V := V) (β := β) hα)
(frozenBound_nonneg hα) (norm_mildKernel_le hα A) j t₁
lemma continuousWithinAt_duhamel_zero (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) :
ContinuousWithinAt (duhamel hα A j) (Icc 0 T) 0 := by
change Tendsto (duhamel hα A j) (𝓝[Icc 0 T] 0) (𝓝 (duhamel hα A j 0))
rw [duhamel_zero]
apply tendsto_zero_iff_norm_tendsto_zero.mpr
apply squeeze_zero' (Eventually.of_forall (fun t => norm_nonneg _))
(show ∀ᶠ t in 𝓝[Icc 0 T] 0, ‖duhamel hα A j t‖ ≤ t^(1/4 : ℝ)*
((∫ u : UnitTime, MildVolterra.massWeight u)*frozenBound (V := V) (β := β) hα*‖j‖) from
by
filter_upwards [self_mem_nhdsWithin] with t ht
exact norm_duhamel_le hα A hT j t ht)
have hc : Continuous (fun t : ℝ => t^(1/4 : ℝ)*
((∫ u : UnitTime, MildVolterra.massWeight u)*frozenBound (V := V) (β := β) hα*‖j‖)) :=
(Real.continuous_rpow_const (by norm_num : (0:ℝ) ≤ 1/4)).mul_const _
simpa only [Real.zero_rpow (by norm_num : (1/4 : ℝ) ≠ 0),zero_mul] using
(hc.tendsto 0).mono_left nhdsWithin_le_nhds
lemma continuousOn_duhamel_Icc (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) :
ContinuousOn (duhamel hα A j) (Icc 0 T) := by
intro t ht
rcases eq_or_lt_of_le ht.1 with he | ht0
· subst t; exact continuousWithinAt_duhamel_zero hα A hT j
· apply ((continuousOn_duhamel hα A hT j) t ⟨ht0,ht.2⟩).mono_of_mem_nhdsWithin
filter_upwards [self_mem_nhdsWithin,mem_nhdsWithin_of_mem_nhds (Ioi_mem_nhds ht0)] with r hr hr0
exact ⟨hr0,hr.2⟩
lemma intervalIntegrable_duhamel (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) (t : ℝ) (ht : t ∈ Icc 0 T) :
IntervalIntegrable (duhamel hα A j) volume 0 t := by
apply ContinuousOn.intervalIntegrable
rw [uIcc_of_le ht.1]
exact (continuousOn_duhamel_Icc hα A hT j).mono (Icc_subset_Icc le_rfl ht.2)
lemma hasDerivAt_pair_duhamel (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) (φ : SchwartzMap V ℂ)
(t : ℝ) (ht : t ∈ Ioo 0 T) :
HasDerivAt (fun r => pairCLM φ φ.integrable (duhamel hα A j r))
(pairCLM φ φ.integrable (unweighted j t) -
pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
(duhamel hα A (sourceMultiply A j) t)) t := by
let L := pairCLM φ φ.integrable
let M := pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
have hu := intervalIntegrable_unweighted j t ht.1.le
have hD := intervalIntegrable_duhamel hα A hT (sourceMultiply A j) t ⟨ht.1.le,ht.2.le⟩
have huc : ContinuousOn (unweighted j) (Ioc 0 T) :=
continuousOn_iff_continuous_domRestrict.mpr (continuous_unweighted_on_time j)
have hc₁ : ContinuousOn (fun r => L (unweighted j r)) (Ioo 0 T) :=
L.continuous.comp_continuousOn (huc.mono Ioo_subset_Ioc_self)
have hc₂ : ContinuousOn (fun r => M (duhamel hα A (sourceMultiply A j) r)) (Ioo 0 T) :=
M.continuous.comp_continuousOn ((continuousOn_duhamel hα A hT _).mono Ioo_subset_Ioc_self)
have hd₁ := intervalIntegral.integral_hasDerivAt_right
(show IntervalIntegrable (fun r => L (unweighted j r)) volume 0 t from
⟨L.integrable_comp hu.1,L.integrable_comp hu.2⟩)
(ContinuousOn.stronglyMeasurableAtFilter isOpen_Ioo hc₁ t ht)
(hc₁.continuousAt (Ioo_mem_nhds ht.1 ht.2))
have hd₂ := intervalIntegral.integral_hasDerivAt_right
(show IntervalIntegrable (fun r => M (duhamel hα A (sourceMultiply A j) r)) volume 0 t from
⟨M.integrable_comp hD.1,M.integrable_comp hD.2⟩)
(ContinuousOn.stronglyMeasurableAtFilter isOpen_Ioo hc₂ t ht)
(hc₂.continuousAt (Ioo_mem_nhds ht.1 ht.2))
apply (hd₁.sub hd₂).congr_of_eventuallyEq
filter_upwards [Ioo_mem_nhds ht.1 ht.2] with r hr
exact pair_duhamel_integral hα A j φ r ⟨hr.1.le,hr.2.le⟩
end ParametrixVolterra
namespace FrozenParametrix
open scoped SchwartzMap Laplacian ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel KernelPairing
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {α β : ℝ}
lemma pair_fullResidual (hα : 0 < α) (a₀ a₁ : V →ᵇ Icc α β) (b : V →ᵇ ℂ)
(q : ℝ) (hq : 0 < q) (f : C₀(V,ℂ)) (φ ψ : SchwartzMap V ℂ)
(hψ : ∀ x, ψ x = ((a₁ x).val : ℂ)*φ x) :
pairCLM φ φ.integrable (fullResidualCLM hα a₀.toContinuousMap a₁.toContinuousMap b
(ParabolicRadius.radius q) f) =
-pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
(c0Time hα a₀ q (C0Multiplier.mul (coefficient a₀.toContinuousMap) f)) +
pairCLM (Δ (Δ ψ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ ψ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable (c0Time hα a₀ q f) +
pairCLM (fun x => φ x*b x) (integrable_pair φ φ.integrable b) (c0Time hα a₀ q f) := by
have h := weak_frozen_residual hα a₀.toContinuousMap a₁.toContinuousMap b q hq f φ ψ hψ
rw [(hasDerivAt_pair_timeValue hα a₀.toContinuousMap q hq f φ).deriv] at h
simpa only [pairCLM_apply,c0Time_apply hα a₀ q hq] using h.symm
end FrozenParametrix
namespace ParametrixVolterra
open scoped ZeroAtInfty BoundedContinuousFunction SchwartzMap Laplacian
open FrozenParametrix StrongWeightedVolterra KernelPairing VolterraIntegral
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {T α β : ℝ}
variable (hα : 0 < α) (A : C(Slab T,V →ᵇ Icc α β)) (b : C(Slab T,V →ᵇ ℂ))
def adjointPair (t : Time T) (φ ψ : SchwartzMap V ℂ) : C₀(V,ℂ) →L[ℂ] ℂ :=
pairCLM (Δ (Δ ψ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ ψ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable +
pairCLM (fun x => φ x*b (now t) x) (integrable_pair φ φ.integrable (b (now t)))
lemma pair_residualKernel (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T)
(φ ψ : SchwartzMap V ℂ) (hψ : ∀ x, ψ x = ((A (now t) x).val : ℂ)*φ x)
(s : ℝ) (hs : s ∈ Ioo 0 t.val) :
pairCLM φ φ.integrable (residualKernel hα A b hT t s (unweighted j s)) =
-pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
(sourceExtend (sourceFrozen hα A (sourceMultiply A j)) t.val s) +
adjointPair b t φ ψ (sourceExtend (sourceFrozen hα A j) t.val s) := by
have hsT : s ∈ Ioc (0:ℝ) T := ⟨hs.1,hs.2.le.trans t.property.2⟩
have hsT' : s ∈ Icc (0:ℝ) T := ⟨hs.1.le,hsT.2⟩
let s₁ : Time T := ⟨s,hsT⟩
rw [residualKernel,ite_eq_left hs,projIcc_of_mem hT hsT']
rw [sourceExtend_apply _ _ _ hsT,sourceExtend_apply _ _ _ hsT]
change pairCLM φ φ.integrable (actualResidual hα A b t (now s₁) (unweighted j s)) = _
dsimp only [sourceFrozen]
rw [show unweighted (sourceMultiply A j) s =
C0Multiplier.mul (coefficient (A (now s₁)).toContinuousMap) (unweighted j s) from
unweighted_sourceMultiply A j s₁]
simpa only [actualResidual,adjointPair,add_apply,now,s₁,add_assoc] using
pair_fullResidual hα (A (now s₁)) (A (now t)) (b (now t)) (t.val-s)
(sub_pos.mpr hs.2) (unweighted j s) φ ψ hψ
lemma pair_integral_residualKernel (hT : 0 ≤ T) (j : Time T →ᵇ C₀(V,ℂ)) (t : Time T)
(hi : IntervalIntegrable (fun s => residualKernel hα A b hT t s (unweighted j s)) volume 0 t.val)
(φ ψ : SchwartzMap V ℂ) (hψ : ∀ x, ψ x = ((A (now t) x).val : ℂ)*φ x) :
pairCLM φ φ.integrable (∫ s in (0:ℝ)..t.val, residualKernel hα A b hT t s (unweighted j s)) =
-pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
(duhamel hα A (sourceMultiply A j) t.val) +
adjointPair b t φ ψ (duhamel hα A j t.val) := by
let L := pairCLM φ φ.integrable
let M := pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
let N := adjointPair b t φ ψ
have hi₁ := intervalIntegrable_sourceFrozen hα A (sourceMultiply A j) t.val t.val
⟨t.property.1.le,t.property.2⟩
have hi₂ := intervalIntegrable_sourceFrozen hα A j t.val t.val ⟨t.property.1.le,t.property.2⟩
have hm : IntervalIntegrable (fun s => M (sourceExtend (sourceFrozen hα A (sourceMultiply A j)) t.val s)) volume 0 t.val :=
⟨M.integrable_comp hi₁.1,M.integrable_comp hi₁.2⟩
have hn : IntervalIntegrable (fun s => N (sourceExtend (sourceFrozen hα A j) t.val s)) volume 0 t.val :=
⟨N.integrable_comp hi₂.1,N.integrable_comp hi₂.2⟩
rw [← L.intervalIntegral_comp_comm hi]
calc
_ = ∫ s in (0:ℝ)..t.val,
-M (sourceExtend (sourceFrozen hα A (sourceMultiply A j)) t.val s) +
N (sourceExtend (sourceFrozen hα A j) t.val s) := by
apply intervalIntegral.integral_congr_Ioo_of_le t.property.1.le
intro s hs
exact pair_residualKernel hα A b hT j t φ ψ hψ s hs
_ = _ := by
rw [intervalIntegral.integral_add (f := fun s => -M (sourceExtend (sourceFrozen hα A (sourceMultiply A j)) t.val s))
(g := fun s => N (sourceExtend (sourceFrozen hα A j) t.val s)) hm.neg hn,intervalIntegral.integral_neg,
M.intervalIntegral_comp_comm hi₁,N.intervalIntegral_comp_comm hi₂]
rfl
def mildTime (hT : 0 ≤ T) (d : C₀(V,ℂ)) (j : Time T →ᵇ C₀(V,ℂ)) (t : ℝ) : C₀(V,ℂ) :=
c0Time hα (A (initial hT)) t d + duhamel hα A j t
lemma mildTime_zero (hT : 0 ≤ T) (d : C₀(V,ℂ)) (j : Time T →ᵇ C₀(V,ℂ)) :
mildTime hα A hT d j 0 = d := by rw [mildTime,c0Time_zero,duhamel_zero,add_zero]
lemma continuousOn_mildTime (hT : 0 ≤ T) (d : C₀(V,ℂ)) (j : Time T →ᵇ C₀(V,ℂ)) :
ContinuousOn (mildTime hα A hT d j) (Icc 0 T) :=
(continuous_c0Time hα (A (initial hT)) d).continuousOn.add (continuousOn_duhamel_Icc hα A hT j)
lemma hasDerivAt_pair_mildTime (hT : 0 ≤ T) (d : C₀(V,ℂ)) (j l : Time T →ᵇ C₀(V,ℂ))
(hi : ∀ t : Time T, IntervalIntegrable
(fun s => residualKernel hα A b hT t s (unweighted j s)) volume 0 t.val)
(hj : ∀ t : Time T, unweighted j t.val + ∫ s in 0..t.val,
residualKernel hα A b hT t s (unweighted j s) = l t-actualResidual hα A b t (initial hT) d)
(t : Time T) (ht : t.val < T) (φ ψ : SchwartzMap V ℂ)
(hψ : ∀ x, ψ x = ((A (now t) x).val : ℂ)*φ x) :
HasDerivAt (fun r => pairCLM φ φ.integrable (mildTime hα A hT d j r))
(pairCLM φ φ.integrable (l t)-adjointPair b t φ ψ (mildTime hα A hT d j t.val)) t.val := by
let L := pairCLM φ φ.integrable
let M := pairCLM (Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ)
(Δ (Δ φ : SchwartzMap V ℂ) : SchwartzMap V ℂ).integrable
let N := adjointPair b t φ ψ
have h₁ := hasDerivAt_pair_c0Time hα (A (initial hT)) t.val t.property.1 d φ
have h₂ := hasDerivAt_pair_duhamel hα A hT j φ t.val ⟨t.property.1,ht⟩
have he₁ := pair_fullResidual hα (A (initial hT)) (A (now t)) (b (now t)) t.val t.property.1 d φ ψ hψ
have he₂ := pair_integral_residualKernel hα A b hT j t (hi t) φ ψ hψ
have he := congrArg L (hj t)
simp only [map_add,map_sub] at he
change L (unweighted j t.val) + L (∫ s in 0..t.val,
residualKernel hα A b hT t s (unweighted j s)) = L (l t)-L (actualResidual hα A b t (initial hT) d) at he
rw [he₂] at he
have he₁' : L (actualResidual hα A b t (initial hT) d) =
-M (c0Time hα (A (initial hT)) t.val
(C0Multiplier.mul (coefficient (A (initial hT)).toContinuousMap) d)) +
N (c0Time hα (A (initial hT)) t.val d) := by
simpa only [L,M,N,actualResidual,initial,sub_zero,adjointPair,add_apply,add_assoc] using he₁
rw [he₁'] at he
have hd := h₁.add h₂
have heq : (-M (c0Time hα (A (initial hT)) t.val
(C0Multiplier.mul (coefficient (A (initial hT)).toContinuousMap) d))) +
(L (unweighted j t.val)-M (duhamel hα A (sourceMultiply A j) t.val)) =
L (l t)-N (mildTime hα A hT d j t.val) := by
rw [mildTime,map_add]
linear_combination he
rw [heq] at hd
apply hd.congr_of_eventuallyEq
exact Eventually.of_forall (fun r => L.map_add _ _)
end ParametrixVolterra
namespace StrongWeightedVolterra
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
variable {T : ℝ}
def dampWeight (u : UnitTime) : ℝ := u.val^(-3/4 : ℝ)*(1-u.val)^(-7/8 : ℝ)
lemma dampWeight_nonneg (u : UnitTime) : 0 ≤ dampWeight u :=
mul_nonneg (Real.rpow_nonneg u.property.1.le _)
(Real.rpow_nonneg (sub_pos.mpr u.property.2).le _)
lemma integrable_dampWeight : Integrable dampWeight := by
have hb := (Complex.betaIntegral_convergent
(u := (1/4 : ℂ)) (v := (1/8 : ℂ)) (by norm_num) (by norm_num)).norm.1
have hi := hb.mono_set Ioo_subset_Ioc_self
have he : EqOn (fun x : ℝ => ‖(x : ℂ)^((1/4 : ℂ)-1) *
(1-(x : ℂ))^((1/8 : ℂ)-1)‖)
(fun x : ℝ => x^(-3/4 : ℝ)*(1-x)^(-7/8 : ℝ)) (Ioo 0 1) := by
intro x hx
dsimp only
rw [norm_mul]
have hq : (1/4 : ℂ)-1 = ((-3/4 : ℝ) : ℂ) := by norm_num
have hr : (1/8 : ℂ)-1 = ((-7/8 : ℝ) : ℂ) := by norm_num
rw [hq,hr, show (1 : ℂ)-(x : ℂ) = ((1-x : ℝ) : ℂ) by push_cast; rfl,
Complex.norm_cpow_real, Complex.norm_cpow_real,
Complex.norm_real, Complex.norm_real, Real.norm_eq_abs, Real.norm_eq_abs,
abs_of_pos hx.1, abs_of_pos (sub_pos.mpr hx.2)]
have hw := hi.congr_fun he measurableSet_Ioo
exact (integrableOn_iff_comap_subtypeVal measurableSet_Ioo).mp hw
lemma eighth_exp_neg_le_one (x : ℝ) (hx : 0 ≤ x) :
x^(1/8 : ℝ)*Real.exp (-x) ≤ 1 := by
by_cases h : x ≤ 1
· calc
_ ≤ 1*1 := mul_le_mul (Real.rpow_le_one hx h (by norm_num))
(Real.exp_le_one_iff.mpr (by linarith)) (Real.exp_pos _).le (by norm_num)
_ = _ := one_mul _
· calc
_ ≤ x*Real.exp (-x) := mul_le_mul_of_nonneg_right
(Real.rpow_le_self_of_one_le (le_of_not_ge h) (by norm_num)) (Real.exp_pos _).le
_ ≤ Real.exp (-1) := Real.mul_exp_neg_le_exp_neg_one x
_ ≤ 1 := Real.exp_le_one_iff.mpr (by norm_num)
lemma eighth_exp_scale_le (κ t v : ℝ) (hκ : 0 < κ) (ht : 0 < t) (hv : 0 < v) :
t^(1/8 : ℝ)*Real.exp (-κ*t*v) ≤ κ^(-1/8 : ℝ)*v^(-1/8 : ℝ) := by
have hb := eighth_exp_neg_le_one (κ*t*v) (by positivity)
have hcκ : κ^(-1/8 : ℝ)*κ^(1/8 : ℝ)=1 := by rw [← Real.rpow_add hκ]; norm_num
have hcv : v^(-1/8 : ℝ)*v^(1/8 : ℝ)=1 := by rw [← Real.rpow_add hv]; norm_num
calc
_ = (κ^(-1/8 : ℝ)*v^(-1/8 : ℝ))*((κ*t*v)^(1/8 : ℝ)*Real.exp (-(κ*t*v))) := by
rw [Real.mul_rpow (mul_pos hκ ht).le hv.le,Real.mul_rpow hκ.le ht.le]
calc
_ = (κ^(-1/8 : ℝ)*κ^(1/8 : ℝ))*(v^(-1/8 : ℝ)*v^(1/8 : ℝ))*
(t^(1/8 : ℝ)*Real.exp (-κ*t*v)) := by rw [hcκ,hcv]; ring
_ = _ := by
rw [show -(κ*t*v) = -κ*t*v by ring]
ring
_ ≤ (κ^(-1/8 : ℝ)*v^(-1/8 : ℝ))*1 :=
mul_le_mul_of_nonneg_left hb (by positivity)
_ = _ := mul_one _
lemma damp_scalar_bound (κ : ℝ) (hκ : 0 < κ) (t : Time T) (ht : t.val ≤ 1) (u : UnitTime) :
t.val^(1/4 : ℝ)*weight u*Real.exp (-κ*(t.val*(1-u.val))) ≤
κ^(-1/8 : ℝ)*dampWeight u := by
have hu : 0 < 1-u.val := sub_pos.mpr u.property.2
have ht8 : t.val^(1/8 : ℝ) ≤ 1 := Real.rpow_le_one t.property.1.le ht (by norm_num)
have he := eighth_exp_scale_le κ t.val (1-u.val) hκ t.property.1 hu
have hpow : t.val^(1/4 : ℝ) = t.val^(1/8 : ℝ)*t.val^(1/8 : ℝ) := by
rw [← Real.rpow_add t.property.1]; norm_num
have hmul : weight u*(1-u.val)^(-1/8 : ℝ)=dampWeight u := by
rw [weight,dampWeight,mul_assoc,← Real.rpow_add hu]; norm_num
calc
_ = (t.val^(1/8 : ℝ)*weight u)*(t.val^(1/8 : ℝ)*Real.exp (-κ*t.val*(1-u.val))) := by
rw [hpow,show -κ*(t.val*(1-u.val)) = -κ*t.val*(1-u.val) by ring]
ring
_ ≤ (1*weight u)*(κ^(-1/8 : ℝ)*(1-u.val)^(-1/8 : ℝ)) :=
mul_le_mul (mul_le_mul_of_nonneg_right ht8 (weight_nonneg u)) he (mul_nonneg (Real.rpow_nonneg t.property.1.le _) (Real.exp_pos _).le)
(mul_nonneg (by norm_num) (weight_nonneg u))
_ = _ := by rw [one_mul,← hmul]; ring
def dampKernel (N : Kernel T E) (κ : ℝ) : Kernel T E where
toFun p := Real.exp (-κ*(p.1.val*(1-p.2.val))) • N p
continuous_apply := by
change Continuous (fun p : (Time T × UnitTime) × E =>
Real.exp (-κ*(p.1.1.val*(1-p.1.2.val))) • N p.1 p.2)
exact (by fun_prop : Continuous (fun p : (Time T × UnitTime) × E =>
Real.exp (-κ*(p.1.1.val*(1-p.1.2.val))))).smul N.continuous_apply
lemma norm_dampKernel_le (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (κ : ℝ) (hκ : 0 ≤ κ) (p : Time T × UnitTime) :
‖dampKernel N κ p‖ ≤ C := by
change ‖Real.exp (-κ*(p.1.val*(1-p.2.val))) • N p‖ ≤ _
rw [norm_smul,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
have he : Real.exp (-κ*(p.1.val*(1-p.2.val))) ≤ 1 :=
Real.exp_le_one_iff.mpr (by
rw [neg_mul]
exact neg_nonpos.mpr (mul_nonneg hκ (mul_nonneg p.1.property.1.le (sub_pos.mpr p.2.property.2).le)))
exact (mul_le_mul_of_nonneg_left (hN p) (Real.exp_pos _).le).trans
(mul_le_of_le_one_left hC he)
lemma norm_damp_data_le (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (κ : ℝ) (hκ : 0 < κ) (ht : T ≤ 1)
(j : Time T →ᵇ E) (t : Time T) (u : UnitTime) :
‖t.val^(1/4 : ℝ) • data (dampKernel N κ) j t u‖ ≤
κ^(-1/8 : ℝ)*dampWeight u*(C*‖j‖) := by
change ‖t.val^(1/4 : ℝ) • (weight u •
((Real.exp (-κ*(t.val*(1-u.val))) • N (t,u)) (j (lag t u))))‖ ≤ _
rw [smul_apply,smul_smul,smul_smul,norm_smul,Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (mul_nonneg (Real.rpow_nonneg t.property.1.le _)
(weight_nonneg u)) (Real.exp_pos _).le)]
calc
_ ≤ (t.val^(1/4 : ℝ)*weight u*Real.exp (-κ*(t.val*(1-u.val))))*(C*‖j‖) :=
mul_le_mul_of_nonneg_left ((N (t,u)).le_opNorm _ |>.trans
(mul_le_mul (hN _) (j.norm_coe_le_norm _) (norm_nonneg _) hC))
(mul_nonneg (mul_nonneg (Real.rpow_nonneg t.property.1.le _) (weight_nonneg u)) (Real.exp_pos _).le)
_ ≤ _ := mul_le_mul_of_nonneg_right (damp_scalar_bound κ hκ t (t.property.2.trans ht) u)
(mul_nonneg hC (norm_nonneg _))
lemma norm_damp_value_le (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (κ : ℝ) (hκ : 0 < κ) (ht : T ≤ 1)
(j : Time T →ᵇ E) (t : Time T) :
‖value (dampKernel N κ) j t‖ ≤ (κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C)*‖j‖ := by
rw [value,← integral_smul]
calc
_ ≤ ∫ u : UnitTime, κ^(-1/8 : ℝ)*dampWeight u*(C*‖j‖) :=
norm_integral_le_of_norm_le ((integrable_dampWeight.const_mul _).mul_const _)
(Eventually.of_forall (norm_damp_data_le N C hC hN κ hκ ht j t))
_ = _ := by rw [integral_mul_const,integral_const_mul]; ring
lemma norm_timeExp_le (c : ℝ) (j : Time T →ᵇ E) (t : Time T) :
‖Real.exp (c*t.val) • j t‖ ≤ Real.exp (|c| * T)*‖j‖ := by
rw [norm_smul,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
exact mul_le_mul (Real.exp_le_exp.mpr ((mul_le_mul_of_nonneg_right (le_abs_self c) t.property.1.le).trans
(mul_le_mul_of_nonneg_left t.property.2 (abs_nonneg c)))) (j.norm_coe_le_norm t)
(norm_nonneg _) (Real.exp_pos _).le
def timeExp (c : ℝ) (j : Time T →ᵇ E) : Time T →ᵇ E :=
.ofNormedAddCommGroup (fun t => Real.exp (c*t.val) • j t)
((Real.continuous_exp.comp (continuous_const.mul continuous_subtype_val)).smul j.continuous)
_ (norm_timeExp_le c j)
lemma timeExp_apply (c : ℝ) (j : Time T →ᵇ E) (t : Time T) :
timeExp c j t = Real.exp (c*t.val) • j t := rfl
lemma timeExp_norm_le (c : ℝ) (j : Time T →ᵇ E) :
‖timeExp c j‖ ≤ Real.exp (|c| * T)*‖j‖ :=
(BoundedContinuousFunction.norm_le (mul_nonneg (Real.exp_pos _).le (norm_nonneg _))).mpr
(norm_timeExp_le c j)
lemma timeExp_add (c : ℝ) (j k : Time T →ᵇ E) :
timeExp c (j+k) = timeExp c j+timeExp c k := by
ext t
simp only [timeExp_apply,BoundedContinuousFunction.add_apply,smul_add]
lemma timeExp_comp (c d : ℝ) (j : Time T →ᵇ E) :
timeExp c (timeExp d j) = timeExp (c+d) j := by
ext t
simp only [timeExp_apply,smul_smul,← Real.exp_add,add_mul]
lemma timeExp_zero (j : Time T →ᵇ E) : timeExp 0 j = j := by
ext t
simp only [timeExp_apply,zero_mul,Real.exp_zero,one_smul]
lemma damp_data_conjugation (N : Kernel T E) (κ : ℝ) (j : Time T →ᵇ E) (t : Time T) (u : UnitTime) :
data (dampKernel N κ) j t u = Real.exp (-κ*t.val) • data N (timeExp κ j) t u := by
change weight u • ((Real.exp (-κ*(t.val*(1-u.val))) • N (t,u)) (j (lag t u))) = _
rw [smul_apply,data,timeExp_apply,ContinuousLinearMap.map_smul_of_tower,smul_smul,smul_smul,smul_smul]
congr 1
change weight u*Real.exp (-κ*(t.val*(1-u.val))) =
Real.exp (-κ*t.val)*weight u*Real.exp (κ*(t.val*u.val))
calc
_ = weight u*Real.exp (-κ*t.val+κ*(t.val*u.val)) := by congr 2; ring
_ = _ := by rw [Real.exp_add]; ring
lemma damp_value_conjugation (N : Kernel T E) (κ : ℝ) (j : Time T →ᵇ E) (t : Time T) :
value (dampKernel N κ) j t = Real.exp (-κ*t.val) • value N (timeExp κ j) t := by
unfold value
simp_rw [damp_data_conjugation]
rw [integral_smul,smul_comm]
lemma damp_operator_conjugation (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (κ : ℝ) (hκ : 0 ≤ κ) (hT : 0 ≤ T) (j : Time T →ᵇ E) :
operator (dampKernel N κ) C hC (norm_dampKernel_le N C hC hN κ hκ) hT j =
timeExp (-κ) (operator N C hC hN hT (timeExp κ j)) := by
ext t
exact damp_value_conjugation N κ j t
lemma norm_damp_operator_le (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (κ : ℝ) (hκ : 0 < κ) (hT : 0 ≤ T) (ht : T ≤ 1)
(j : Time T →ᵇ E) :
‖operator (dampKernel N κ) C hC (norm_dampKernel_le N C hC hN κ hκ.le) hT j‖ ≤
(κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C)*‖j‖ := by
apply (BoundedContinuousFunction.norm_le (mul_nonneg
(mul_nonneg (mul_nonneg (Real.rpow_nonneg hκ.le _) (integral_nonneg dampWeight_nonneg)) hC)
(norm_nonneg _))).mpr
exact norm_damp_value_le N C hC hN κ hκ ht j
lemma norm_damp_operatorCLM_le (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (κ : ℝ) (hκ : 0 < κ) (hT : 0 ≤ T) (ht : T ≤ 1) :
‖operatorCLM (dampKernel N κ) C hC (norm_dampKernel_le N C hC hN κ hκ.le) hT‖ ≤
κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C := by
apply ContinuousLinearMap.opNorm_le_bound _
(mul_nonneg (mul_nonneg (Real.rpow_nonneg hκ.le _) (integral_nonneg dampWeight_nonneg)) hC)
exact norm_damp_operator_le N C hC hN κ hκ hT ht
lemma exists_damping_small (C : ℝ) :
∃ κ : ℝ, 0 < κ ∧ κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C < 1 := by
have ht : Tendsto (fun κ : ℝ => κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C) atTop (𝓝 0) := by
simpa only [zero_mul,neg_div] using ((tendsto_rpow_neg_atTop (by norm_num : (0:ℝ) < 1/8)).mul_const
(∫ u : UnitTime, dampWeight u)).mul_const C
exact ((eventually_gt_atTop (0:ℝ)).and (ht.eventually (gt_mem_nhds (by norm_num : (0:ℝ) < 1)))).exists
theorem exists_unique_solution_full [CompleteSpace E] (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (hT : 0 ≤ T) (ht : T ≤ 1) (g : Time T →ᵇ E) :
∃! j : Time T →ᵇ E, j+operator N C hC hN hT j=g := by
obtain ⟨κ,hκ,hsmall⟩ := exists_damping_small C
let M := dampKernel N κ
have hM := norm_dampKernel_le N C hC hN κ hκ.le
let A := operatorCLM M C hC hM hT
have hA : ‖A‖ < 1 := (norm_damp_operatorCLM_le N C hC hN κ hκ hT ht).trans_lt hsmall
let g₀ := timeExp (-κ) g
let f : (Time T →ᵇ E) → (Time T →ᵇ E) := fun j => g₀-A j
have hf : ContractingWith ‖A‖₊ f := by
refine ⟨hA,LipschitzWith.of_dist_le_mul (fun j k => ?_)⟩
rw [dist_eq_norm,dist_eq_norm]
change ‖(g₀-A j)-(g₀-A k)‖ ≤ ‖A‖*‖j-k‖
rw [sub_sub_sub_cancel_left,← A.map_sub,norm_sub_rev j k]
exact A.le_opNorm (k-j)
have hsolve : hf.fixedPoint+operator M C hC hM hT hf.fixedPoint = g₀ :=
eq_sub_iff_add_eq.mp hf.fixedPoint_isFixedPt.symm
let j := timeExp κ hf.fixedPoint
have hj : j+operator N C hC hN hT j=g := by
have he := congrArg (timeExp κ) hsolve
rw [damp_operator_conjugation N C hC hN κ hκ.le hT,timeExp_add,timeExp_comp,
add_neg_cancel,timeExp_zero] at he
simpa only [g₀,timeExp_comp,add_neg_cancel,timeExp_zero] using he
refine ⟨j,hj,fun k hk => ?_⟩
have hk₀ : timeExp (-κ) k+operator M C hC hM hT (timeExp (-κ) k)=g₀ := by
rw [damp_operator_conjugation N C hC hN κ hκ.le hT,timeExp_comp,add_neg_cancel,timeExp_zero]
rw [← timeExp_add,hk]
have hfix : f (timeExp (-κ) k)=timeExp (-κ) k := (eq_sub_iff_add_eq.mpr hk₀).symm
have he := congrArg (timeExp κ) (hf.fixedPoint_unique hfix)
simpa only [timeExp_comp,add_neg_cancel,timeExp_zero] using he
lemma norm_solution_full_le (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (κ : ℝ) (hκ : 0 < κ) (hT : 0 ≤ T) (ht : T ≤ 1)
(hsmall : κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C < 1)
(g j : Time T →ᵇ E) (hj : j+operator N C hC hN hT j=g) :
‖j‖ ≤ (Real.exp (κ*T))^2/(1-κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C)*‖g‖ := by
let Q := κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C
let M := dampKernel N κ
have hM := norm_dampKernel_le N C hC hN κ hκ.le
let j₀ := timeExp (-κ) j
let g₀ := timeExp (-κ) g
have he : j₀+operator M C hC hM hT j₀=g₀ := by
rw [damp_operator_conjugation N C hC hN κ hκ.le hT]
dsimp only [j₀,g₀]
rw [timeExp_comp,add_neg_cancel,timeExp_zero,← timeExp_add,hj]
have hb : ‖operator M C hC hM hT j₀‖ ≤ Q*‖j₀‖ :=
norm_damp_operator_le N C hC hN κ hκ hT ht j₀
have hn := norm_sub_le g₀ (operator M C hC hM hT j₀)
rw [← eq_sub_iff_add_eq.mpr he] at hn
have hpos : 0 < 1-Q := sub_pos.mpr hsmall
have hj₀ : ‖j₀‖ ≤ ‖g₀‖/(1-Q) := (le_div_iff₀ hpos).mpr (by nlinarith)
have hj' : timeExp κ j₀=j := by
change timeExp κ (timeExp (-κ) j)=j
rw [timeExp_comp,add_neg_cancel,timeExp_zero]
have hjb := timeExp_norm_le κ j₀
rw [hj',abs_of_pos hκ] at hjb
have hgb : ‖g₀‖ ≤ Real.exp (κ*T)*‖g‖ := by
simpa only [g₀,abs_neg,abs_of_pos hκ] using timeExp_norm_le (-κ) g
calc
‖j‖ ≤ Real.exp (κ*T)*(‖g₀‖/(1-Q)) := hjb.trans
(mul_le_mul_of_nonneg_left hj₀ (Real.exp_pos _).le)
_ ≤ Real.exp (κ*T)*((Real.exp (κ*T)*‖g‖)/(1-Q)) :=
mul_le_mul_of_nonneg_left (div_le_div_of_nonneg_right hgb hpos.le) (Real.exp_pos _).le
_ = _ := by dsimp only [Q]; ring
theorem exists_full_inverse_bound [CompleteSpace E] (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (hT : 0 ≤ T) (ht : T ≤ 1) :
∃ D : ℝ, 0 < D ∧ ∀ g : Time T →ᵇ E,
∃ j : Time T →ᵇ E, j+operator N C hC hN hT j=g ∧ ‖j‖ ≤ D*‖g‖ := by
obtain ⟨κ,hκ,hsmall⟩ := exists_damping_small C
refine ⟨(Real.exp (κ*T))^2/(1-κ^(-1/8 : ℝ)*(∫ u : UnitTime, dampWeight u)*C),
div_pos (sq_pos_of_pos (Real.exp_pos _)) (sub_pos.mpr hsmall),fun g => ?_⟩
obtain ⟨j,hj,_⟩ := exists_unique_solution_full N C hC hN hT ht g
exact ⟨j,hj,norm_solution_full_le N C hC hN κ hκ hT ht hsmall g j hj⟩
theorem exists_unweighted_solution_full [CompleteSpace E] (N : Kernel T E) (C : ℝ) (hC : 0 ≤ C)
(hN : ∀ p, ‖N p‖ ≤ C) (hT : 0 ≤ T) (ht : T ≤ 1) :
∃ D : ℝ, 0 < D ∧ ∀ g : Time T →ᵇ E,
∃ j : Time T →ᵇ E,
(∀ t : Time T, IntervalIntegrable (fun r => kernel N t r (unweighted j r)) volume 0 t.val) ∧
(∀ t : Time T, unweighted j t.val + ∫ r in 0..t.val, kernel N t r (unweighted j r) = unweighted g t.val) ∧
‖j‖ ≤ D*‖g‖ ∧
(∀ t : Time T, ‖unweighted j t.val‖ ≤ t.val^(-3/4 : ℝ)*(D*‖g‖)) := by
obtain ⟨D,hD,hd⟩ := exists_full_inverse_bound N C hC hN hT ht
refine ⟨D,hD,fun g => ?_⟩
obtain ⟨j,hj,hjb⟩ := hd g
refine ⟨j,intervalIntegrable_kernel_unweighted N C hC hN j,
unweighted_solves N C hC hN hT g j hj,hjb,fun t => ?_⟩
rw [unweighted_at_time,norm_smul,Real.norm_eq_abs,
abs_of_nonneg (Real.rpow_nonneg t.property.1.le _)]
exact mul_le_mul_of_nonneg_left ((j.norm_coe_le_norm t).trans hjb)
(Real.rpow_nonneg t.property.1.le _)
end StrongWeightedVolterra
namespace ParametrixVolterra
open scoped ZeroAtInfty BoundedContinuousFunction SchwartzMap Laplacian
open FrozenParametrix C0Convolution StrongWeightedVolterra KernelPairing
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {T α β : ℝ}
theorem exists_parametrix_correction_full (hα : 0 < α)
(A : C(Slab T, V →ᵇ Icc α β)) (b : C(Slab T, V →ᵇ ℂ))
(hT₀ : 0 ≤ T) (hT : T ≤ 1) (L B : ℝ) (hL : 0 ≤ L) (hB : 0 ≤ B)
(hb : ∀ s, ‖b s‖ ≤ B)
(hLip : ∀ s r : Slab T, ∀ x z : V,
|(A s x).val-(A r z).val| ≤ L*(‖x-z‖+|s.val-r.val|)) :
∃ C D : ℝ, 0 ≤ C ∧ 0 < D ∧
∀ (d : C₀(V,ℂ)) (l : Time T →ᵇ C₀(V,ℂ)), ∃ j : Time T →ᵇ C₀(V,ℂ),
(∀ t : Time T, IntervalIntegrable
(fun r => residualKernel hα A b hT₀ t r (unweighted j r)) volume 0 t.val) ∧
(∀ t : Time T, unweighted j t.val + ∫ r in 0..t.val,
residualKernel hα A b hT₀ t r (unweighted j r) =
l t-actualResidual hα A b t (initial hT₀) d) ∧
‖j‖ ≤ D*(‖l‖+C*‖d‖) := by
obtain ⟨C,hC,hR⟩ := exists_actualResidual_bound hα A b hT L B hL hB hb hLip
obtain ⟨D,hD,hN⟩ := exists_normalized_bound hα A b hT L B hL hB hb hLip
have hR₀ : ∀ t : Time T, ‖actualResidual hα A b t (initial hT₀)‖ ≤ C*t.val^(-3/4 : ℝ) := by
intro t
simpa only [initial,sub_zero] using hR t (initial hT₀) t.property.1
let N : Kernel T C₀(V,ℂ) := Kernel.ofStrong (normalized hα A b)
(continuous_normalized_apply hα A b) D hD hN
obtain ⟨E,hE,he⟩ := exists_unweighted_solution_full N D hD hN hT₀ hT
refine ⟨C,E,hC,hE,fun d l => ?_⟩
let g := weightedSource hα A b hT₀ hT C hC hR₀ d l
obtain ⟨j,hi,hj,hbound,_⟩ := he g
have hk : ∀ t r, kernel N t r = residualKernel hα A b hT₀ t r :=
kernel_eq_residualKernel hα A b hT₀ D hD hN
simp_rw [hk] at hi hj
have hg : ∀ t : Time T, unweighted g t.val = l t-actualResidual hα A b t (initial hT₀) d :=
unweighted_weightedSource hα A b hT₀ hT C hC hR₀ d l
simp_rw [hg] at hj
refine ⟨j,hi,hj,hbound.trans ?_⟩
have hgnorm : ‖g‖ ≤ ‖l‖+C*‖d‖ := by
apply (BoundedContinuousFunction.norm_le (by positivity)).mpr
exact norm_sourceRHS_le hα A b hT₀ hT C hC hR₀ d l
exact mul_le_mul_of_nonneg_left hgnorm hE.le
def coefficientTest (a : V →ᵇ Icc α β) (ha : ContDiff ℝ ∞ (fun x => (a x).val))
(φ : SchwartzMap V ℂ) (hφ : HasCompactSupport (φ : V → ℂ)) : SchwartzMap V ℂ :=
HasCompactSupport.toSchwartzMap (f := fun x => ((a x).val : ℂ)*φ x) hφ.mul_left
((Complex.ofRealCLM.contDiff.comp ha).mul (φ.smooth ⊤))
omit [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
lemma coefficientTest_apply (a : V →ᵇ Icc α β) (ha : ContDiff ℝ ∞ (fun x => (a x).val))
(φ : SchwartzMap V ℂ) (hφ : HasCompactSupport (φ : V → ℂ)) (x : V) :
coefficientTest a ha φ hφ x = ((a x).val : ℂ)*φ x := rfl
theorem exists_weak_evolution (hα : 0 < α)
(A : C(Slab T,V →ᵇ Icc α β)) (b : C(Slab T,V →ᵇ ℂ))
(hT₀ : 0 ≤ T) (hT : T ≤ 1) (L B : ℝ) (hL : 0 ≤ L) (hB : 0 ≤ B)
(hb : ∀ s, ‖b s‖ ≤ B)
(hLip : ∀ s r : Slab T, ∀ x z : V,
|(A s x).val-(A r z).val| ≤ L*(‖x-z‖+|s.val-r.val|))
(hA : ∀ s, ContDiff ℝ ∞ (fun x => (A s x).val)) :
∃ K : ℝ, 0 ≤ K ∧ ∀ (d : C₀(V,ℂ)) (l : Time T →ᵇ C₀(V,ℂ)),
∃ u : ℝ → C₀(V,ℂ), u 0=d ∧ ContinuousOn u (Icc 0 T) ∧
(∀ t ∈ Icc 0 T, ‖u t‖ ≤ K*(‖l‖+‖d‖)) ∧
(∀ (t : Time T), t.val < T → ∀ (φ : SchwartzMap V ℂ)
(hφ : HasCompactSupport (φ : V → ℂ)),
HasDerivAt (fun r => pairCLM φ φ.integrable (u r))
(pairCLM φ φ.integrable (l t)-
adjointPair b t φ (coefficientTest (A (now t)) (hA (now t)) φ hφ) (u t.val)) t.val) := by
obtain ⟨C,D,hC,hD,hs⟩ := exists_parametrix_correction_full hα A b hT₀ hT L B hL hB hb hLip
let M := frozenBound (V := V) (β := β) hα
let Q := ∫ v : UnitTime, MildVolterra.massWeight v
have hM : 0 ≤ M := frozenBound_nonneg hα
have hQ : 0 ≤ Q := integral_nonneg MildVolterra.massWeight_nonneg
refine ⟨M+Q*M*D*(1+C),by positivity,fun d l => ?_⟩
obtain ⟨j,hi,hj,hjb⟩ := hs d l
refine ⟨mildTime hα A hT₀ d j,mildTime_zero hα A hT₀ d j,
continuousOn_mildTime hα A hT₀ d j,fun t ht => ?_,fun t ht φ hφ => ?_⟩
· have ht1 : t^(1/4 : ℝ) ≤ 1 := Real.rpow_le_one ht.1 (ht.2.trans hT) (by positivity)
have h0 := norm_c0Time_le hα (A (initial hT₀)) t d
have h1 := norm_duhamel_le hα A hT₀ j t ht
have hjb' : ‖j‖ ≤ D*((1+C)*(‖l‖+‖d‖)) := hjb.trans
(mul_le_mul_of_nonneg_left (by nlinarith [norm_nonneg l,norm_nonneg d]) hD.le)
calc
‖mildTime hα A hT₀ d j t‖ ≤ M*‖d‖+t^(1/4 : ℝ)*(Q*M*‖j‖) :=
(norm_add_le _ _).trans (add_le_add h0 h1)
_ ≤ M*‖d‖+Q*M*‖j‖ := add_le_add le_rfl
(mul_le_of_le_one_left (mul_nonneg (mul_nonneg hQ hM) (norm_nonneg j)) ht1)
_ ≤ M*(‖l‖+‖d‖)+Q*M*(D*((1+C)*(‖l‖+‖d‖))) := add_le_add
(mul_le_mul_of_nonneg_left (le_add_of_nonneg_left (norm_nonneg l)) hM)
(mul_le_mul_of_nonneg_left hjb' (mul_nonneg hQ hM))
_ = _ := by ring
· exact hasDerivAt_pair_mildTime hα A b hT₀ d j l hi hj t ht φ
(coefficientTest (A (now t)) (hA (now t)) φ hφ) (coefficientTest_apply _ _ _ _)
end ParametrixVolterra
open Set Filter MeasureTheory
open scoped SchwartzMap Topology
namespace SchwartzTimeScale
variable {V E : Type*} [NormedAddCommGroup V] [NormedSpace ℝ V]
[NormedAddCommGroup E] [NormedSpace ℝ E]
def euler (K : SchwartzMap V E) (N : ℕ) : SchwartzMap V E :=
(-(N : ℝ)/4) • K - (1/4 : ℝ) •
(SchwartzMap.bilinLeftCLM (ContinuousLinearMap.apply ℝ E).flip
(by fun_prop : Function.HasTemperateGrowth (fun y : V => y))
(SchwartzMap.fderivCLM ℝ V E K))
lemma euler_apply (K : SchwartzMap V E) (N : ℕ) (y : V) :
euler K N y = (-(N : ℝ)/4) • K y-(1/4 : ℝ) • (fderiv ℝ K y y) := rfl
def atTime (K : SchwartzMap V E) (N : ℕ) (q : ℝ) (y : V) : E :=
q^(-(N : ℝ)/4) • K (q^(-(1 : ℝ)/4) • y)
lemma hasDerivAt_atTime (K : SchwartzMap V E) (N : ℕ) (q : ℝ) (hq : 0 < q) (y : V) :
HasDerivAt (fun s => atTime K N s y)
(atTime (euler K N) (N+4) q y) q := by
have h1 := Real.hasDerivAt_rpow_const (p := -(N : ℝ)/4) (Or.inl hq.ne')
have h2 := Real.hasDerivAt_rpow_const (p := -(1 : ℝ)/4) (Or.inl hq.ne')
have hK := (K.hasFDerivAt (q^(-(1 : ℝ)/4) • y)).comp_hasDerivAt q (h2.smul_const y)
have hd := h1.smul hK
convert hd using 1
· rfl
· dsimp only [atTime,Function.comp_apply,Pi.smul_apply]
rw [euler_apply,smul_sub]
simp only [ContinuousLinearMap.map_smul,smul_smul]
have he1 : q^(-((N+4 : ℕ) : ℝ)/4) = q^(-(N : ℝ)/4-1) := by
congr 1
push_cast
ring
have he2 : q^(-(N : ℝ)/4) * (-(1 : ℝ)/4*q^(-(1 : ℝ)/4-1)) =
-(q^(-(N : ℝ)/4-1)*(1/4))*q^(-(1 : ℝ)/4) := by
calc
_ = (-(1 : ℝ)/4)*q^(-(N : ℝ)/4+(-(1 : ℝ)/4-1)) := by rw [Real.rpow_add hq]; ring
_ = (-(1 : ℝ)/4)*q^((-(N : ℝ)/4-1)+(-(1 : ℝ)/4)) := by congr 2; ring
_ = _ := by rw [Real.rpow_add hq]; ring
rw [he1,he2]
module
lemma atTime_eq_scaled (K : SchwartzMap V E) (N : ℕ) (q : ℝ) (hq : 0 < q) (y : V) :
atTime K N q y = ((q^(1/4 : ℝ))⁻¹)^N • K ((q^(1/4 : ℝ))⁻¹ • y) := by
unfold atTime
rw [show -(1 : ℝ)/4 = -(1/4 : ℝ) by ring,Real.rpow_neg hq.le]
congr 1
rw [← Real.rpow_natCast,← Real.rpow_neg hq.le,← Real.rpow_mul hq.le]
congr 1
ring
end SchwartzTimeScale
namespace SourceFrozenCancellation
open SchwartzTimeScale
open scoped BoundedContinuousFunction
variable {V E : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
[NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
omit [CompleteSpace E] in
lemma parameter_envelope (K : SchwartzMap V E) (N : ℕ) (α β : ℝ) (hα : 0 < α) :
∃ B : V → ℝ, Integrable B ∧ Integrable (fun z => (1+‖z‖)*B z) ∧
(∀ z, 0 ≤ B z) ∧ ∀ a ∈ Icc α β, ∀ z, ‖atTime K N a z‖ ≤ B z := by
obtain ⟨B,hB,hw,hp,hb⟩ := SchwartzConvolution.scaled_weighted_majorant K
(α^(1/4 : ℝ)) (β^(1/4 : ℝ)) (by positivity) N 1
refine ⟨B,hB,by simpa only [pow_one] using hw,hp,?_⟩
intro a ha z
rw [atTime_eq_scaled K N a (hα.trans_le ha.1)]
exact hb _ ⟨Real.rpow_le_rpow hα.le ha.1 (by norm_num),
Real.rpow_le_rpow (hα.trans_le ha.1).le ha.2 (by norm_num)⟩ z
omit [CompleteSpace E] in
lemma parameter_lipschitz_envelope (K : SchwartzMap V E) (N : ℕ) (α β : ℝ) (hα : 0 < α) :
∃ C : V → ℝ, Integrable C ∧ Integrable (fun z => (1+‖z‖)*C z) ∧
(∀ z, 0 ≤ C z) ∧ ∀ a ∈ Icc α β, ∀ b ∈ Icc α β, ∀ z,
‖atTime K N a z-atTime K N b z‖ ≤ C z*‖a-b‖ := by
obtain ⟨C,hC,hw,hp,hb⟩ := parameter_envelope (euler K N) (N+4) α β hα
refine ⟨C,hC,hw,hp,fun a ha b hb' z => ?_⟩
exact Convex.norm_image_sub_le_of_norm_hasDerivWithin_le
(fun q hq => (hasDerivAt_atTime K N q (hα.trans_le hq.1) z).hasDerivWithinAt)
(fun q hq => hb q hq z) (convex_Icc α β) hb' ha
omit [CompleteSpace E] in
lemma integral_atTime_zero (K : SchwartzMap V E) (N : ℕ) (a : ℝ) (ha : 0 < a)
(hK : ∫ z, K z = 0) : ∫ z, atTime K N a z = 0 := by
simp_rw [atTime_eq_scaled K N a ha]
rw [integral_smul,Measure.integral_comp_inv_smul_of_nonneg volume _ (by positivity)]
simp only [hK,smul_zero]
omit [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] [CompleteSpace E] in
lemma continuous_variable (K : SchwartzMap V E) (N : ℕ) (a : V → ℝ) (ha : Continuous a)
(hp : ∀ z, 0 < a z) : Continuous (fun z => atTime K N (a z) z) := by
unfold atTime
exact (ha.rpow_const (fun z => Or.inl (hp z).ne')).smul
(K.continuous.comp ((ha.rpow_const (fun z => Or.inl (hp z).ne')).smul continuous_id))
omit [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] in
lemma integrable_envelope_power (B : V → ℝ) (hB : Integrable B)
(hW : Integrable (fun z => (1+‖z‖)*B z)) (hp : ∀ z, 0 ≤ B z)
(γ : ℝ) (hγ : 0 ≤ γ) (hγ1 : γ ≤ 1) : Integrable (fun z => ‖z‖^γ*B z) := by
apply hW.mono'
· exact (continuous_norm.rpow_const (fun _ => Or.inr hγ)).aestronglyMeasurable.mul
hB.aestronglyMeasurable
· filter_upwards with z
rw [Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (Real.rpow_nonneg (norm_nonneg _) _) (hp z))]
apply mul_le_mul_of_nonneg_right _ (hp z)
by_cases hz : ‖z‖ ≤ 1
· exact (Real.rpow_le_one (norm_nonneg _) hz hγ).trans (by linarith [norm_nonneg z])
· have hh := Real.rpow_le_rpow_of_exponent_le (le_of_not_ge hz) hγ1
rw [Real.rpow_one] at hh
exact hh.trans (by linarith)
omit [CompleteSpace E] in
lemma norm_normalized_source_integral (K : SchwartzMap V E) (N : ℕ)
(α β : ℝ) (hα : 0 < α) (hK : ∫ z, K z = 0)
(B C : V → ℝ) (hB : Integrable B) (hBw : Integrable (fun z => (1+‖z‖)*B z))
(hBp : ∀ z, 0 ≤ B z) (hC : Integrable C) (hCw : Integrable (fun z => (1+‖z‖)*C z))
(hCp : ∀ z, 0 ≤ C z)
(hb : ∀ a ∈ Icc α β, ∀ z, ‖atTime K N a z‖ ≤ B z)
(hc : ∀ a ∈ Icc α β, ∀ b ∈ Icc α β, ∀ z,
‖atTime K N a z-atTime K N b z‖ ≤ C z*‖a-b‖)
(A : V → ℝ) (hA : Continuous A) (hAr : ∀ y, A y ∈ Icc α β)
(L : ℝ) (_hL : 0 ≤ L) (hAL : ∀ x y, ‖A x-A y‖ ≤ L*‖x-y‖)
(f : V →ᵇ ℂ) (γ H : ℝ) (hγ : 0 ≤ γ) (hγ1 : γ ≤ 1) (hH : 0 ≤ H)
(hhold : ∀ x y, ‖f x-f y‖ ≤ H*‖x-y‖^γ) (r : ℝ) (hr : 0 < r) (x : V) :
‖∫ z, f (x-r • z) • atTime K N (A (x-r • z)) z‖ ≤
H*r^γ*(∫ z, ‖z‖^γ*B z)+‖f‖*L*r*(∫ z, ‖z‖*C z) := by
let a : V → ℝ := fun z => A (x-r • z)
have ha : Continuous a := hA.comp (continuous_const.sub (continuous_const.smul continuous_id))
have hp (z : V) : 0 < a z := hα.trans_le (hAr _).1
have hi : Integrable (fun z => f (x-r • z) • atTime K N (a z) z) := by
apply (hB.const_mul ‖f‖).mono'
· exact ((f.continuous.comp (continuous_const.sub (continuous_const.smul continuous_id))).smul
(continuous_variable K N a ha hp)).aestronglyMeasurable
· filter_upwards with z
rw [norm_smul]
exact mul_le_mul (f.norm_coe_le_norm _) (hb _ (hAr _) z) (norm_nonneg _) (norm_nonneg _)
have hi₀ : Integrable (fun z => f x • atTime K N (A x) z) := by
apply (hB.const_mul ‖f x‖).mono'
· exact ((continuous_variable K N (fun _ => A x) continuous_const
(fun _ => hα.trans_le (hAr x).1)).const_smul (f x)).aestronglyMeasurable
· filter_upwards with z
rw [norm_smul]
exact mul_le_mul_of_nonneg_left (hb _ (hAr x) z) (norm_nonneg _)
have hzero : ∫ z, f x • atTime K N (A x) z = 0 := by
rw [integral_smul,integral_atTime_zero K N (A x) (hα.trans_le (hAr x).1) hK,smul_zero]
have hiB := integrable_envelope_power B hB hBw hBp γ hγ hγ1
have hiC : Integrable (fun z => ‖z‖*C z) := by
simpa using integrable_envelope_power C hC hCw hCp 1 (by norm_num) le_rfl
have hd (z : V) : ‖(x-r • z)-x‖ = r*‖z‖ := by
rw [sub_sub_cancel_left,norm_neg,norm_smul,Real.norm_eq_abs,abs_of_pos hr]
calc
_ = ‖∫ z, (f (x-r • z) • atTime K N (a z) z-f x • atTime K N (A x) z)‖ := by
rw [integral_sub hi hi₀,hzero,sub_zero]
_ ≤ ∫ z, ‖f (x-r • z) • atTime K N (a z) z-f x • atTime K N (A x) z‖ :=
norm_integral_le_integral_norm _
_ ≤ ∫ z, (H*r^γ)*(‖z‖^γ*B z)+(‖f‖*L*r)*(‖z‖*C z) := by
apply integral_mono (hi.sub hi₀).norm ((hiB.const_mul _).add (hiC.const_mul _))
intro z
have hdec : f (x-r • z) • atTime K N (a z) z-f x • atTime K N (A x) z =
(f (x-r • z)-f x) • atTime K N (a z) z+
f x • (atTime K N (a z) z-atTime K N (A x) z) := by module
simp only [Pi.sub_apply, Pi.add_apply]
rw [hdec]
apply (norm_add_le _ _).trans
rw [norm_smul,norm_smul]
have hF : ‖f (x-r • z)-f x‖ ≤ H*r^γ*‖z‖^γ := by
simpa only [hd,Real.mul_rpow hr.le (norm_nonneg _),mul_assoc] using hhold (x-r • z) x
have hcoef : ‖atTime K N (a z) z-atTime K N (A x) z‖ ≤ C z*(L*r*‖z‖) := by
exact (hc _ (hAr _) _ (hAr x) z).trans
(mul_le_mul_of_nonneg_left (by simpa only [hd,mul_assoc] using hAL (x-r • z) x) (hCp z))
calc
_ ≤ (H*r^γ*‖z‖^γ)*B z+‖f‖*(C z*(L*r*‖z‖)) :=
add_le_add (mul_le_mul hF (hb _ (hAr _) z) (norm_nonneg _) (by positivity))
(mul_le_mul (f.norm_coe_le_norm x) hcoef (norm_nonneg _) (norm_nonneg _))
_ = _ := by ring
_ = _ := by rw [integral_add (hiB.const_mul _) (hiC.const_mul _),integral_const_mul,integral_const_mul]
end SourceFrozenCancellation
open Set Filter MeasureTheory
open scoped SchwartzMap ContDiff FourierTransform BoundedContinuousFunction Convolution Topology
namespace SchwartzDerivatives
section Iterated
variable {V E : Type*} [NormedAddCommGroup V] [NormedSpace ℝ V]
[NormedAddCommGroup E] [NormedSpace ℝ E]
def iterated (g : SchwartzMap V E) : (n : ℕ) →
SchwartzMap V (ContinuousMultilinearMap ℝ (fun _ : Fin n => V) E)
| 0 => g.postcompCLM (continuousMultilinearCurryFin0 ℝ V E).symm.toContinuousLinearEquiv.toContinuousLinearMap
| n+1 => (SchwartzMap.fderivCLM ℝ V _ (iterated g n)).postcompCLM
(continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (n+1) => V) E).symm.toContinuousLinearEquiv.toContinuousLinearMap
lemma iterated_coe (g : SchwartzMap V E) (n : ℕ) :
(iterated g n : V → ContinuousMultilinearMap ℝ (fun _ : Fin n => V) E) =
iteratedFDeriv ℝ n g := by
induction n with
| zero => rfl
| succ n ih =>
rw [iteratedFDeriv_succ_eq_comp_left]
change ((continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (n+1) => V) E).symm ∘
fderiv ℝ (iterated g n)) = _
rw [ih]
lemma iterated_apply (g : SchwartzMap V E) (n : ℕ) (x : V) :
iterated g n x = iteratedFDeriv ℝ n g x := congrFun (iterated_coe g n) x
end Iterated
variable {V E : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
[NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
omit [CompleteSpace E] in
lemma integral_fderiv (g : SchwartzMap V E) :
∫ x : V, fderiv ℝ g x = 0 := by
have h := congrArg (fun f : SchwartzMap V (V →L[ℝ] E) => f 0)
(SchwartzMap.fourier_fderivCLM_eq (𝕜 := ℝ) g)
simpa [SchwartzMap.fourier_coe, Real.fourier_eq,
SchwartzMap.smulRightCLM_apply_apply, SchwartzMap.fderivCLM_apply] using h
lemma integral_iterated (g : SchwartzMap V E) (n : ℕ) :
∫ x : V, iteratedFDeriv ℝ (n+1) g x = 0 := by
let L := (continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (n+1) => V) E).symm.toContinuousLinearEquiv.toContinuousLinearMap
let : ContinuousENorm (V →L[ℝ] ContinuousMultilinearMap ℝ (fun _ : Fin n => V) E) :=
@SeminormedAddGroup.toContinuousENorm (V →L[ℝ] ContinuousMultilinearMap ℝ (fun _ : Fin n => V) E) inferInstance
have hi : Integrable (fun x : V => fderiv ℝ (iterated g n) x) :=
(SchwartzMap.fderivCLM ℝ V _ (iterated g n)).integrable
rw [iteratedFDeriv_succ_eq_comp_left, ← iterated_coe g n]
change (∫ x, L (fderiv ℝ (iterated g n) x)) = 0
have hh := ContinuousLinearMap.integral_comp_comm (𝕜 := ℝ)
(E := V →L[ℝ] ContinuousMultilinearMap ℝ (fun _ : Fin n => V) E)
(Fₗ := ContinuousMultilinearMap ℝ (fun _ : Fin (n+1) => V) E) L hi
exact hh.trans (by rw [integral_fderiv, map_zero])
end SchwartzDerivatives
namespace ScaledSchwartzConvolution
variable {V E : Type} [NormedAddCommGroup V] [NormedSpace ℝ V]
[FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)]
[NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
variable {a b : ℝ} (ha : 0 < a) (c : V → ℝ) (hc : Continuous c) (hcb : ∀ y, c y ∈ Icc a b)
include ha hc hcb
lemma iteratedFDeriv_value_smul (f : V →ᵇ ℂ) (g : SchwartzMap V E) (K n : ℕ) :
iteratedFDeriv ℝ n (value c (ContinuousLinearMap.lsmul ℝ ℂ) f g K) =
value c (ContinuousLinearMap.lsmul ℝ ℂ) f (SchwartzDerivatives.iterated g n) (K+n) := by
induction n with
| zero =>
funext x
let L := (continuousMultilinearCurryFin0 ℝ V E).symm.toContinuousLinearEquiv.toContinuousLinearMap
have hi : Integrable (fun y => f y • ((c y)⁻¹^K • g ((c y)⁻¹ • (x-y)))) :=
integrable_integrand ha c hc hcb (ContinuousLinearMap.lsmul ℝ ℂ) f g K x
change L (∫ y, f y • (c y)⁻¹^K • g ((c y)⁻¹ • (x-y))) =
∫ y, f y • ((c y)⁻¹^K • L (g ((c y)⁻¹ • (x-y))))
rw [← ContinuousLinearMap.integral_comp_comm (𝕜 := ℝ) L hi]
apply integral_congr_ae
filter_upwards with y
ext m
rfl
| succ n ih =>
rw [iteratedFDeriv_succ_eq_comp_left, ih, fderiv_value ha c hc hcb]
funext x
let g' := SchwartzMap.fderivCLM ℝ V _ (SchwartzDerivatives.iterated g n)
let L := (continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (n+1) => V) E).symm.toContinuousLinearEquiv.toContinuousLinearMap
have hi := integrable_integrand ha c hc hcb
(E := V →L[ℝ] ContinuousMultilinearMap ℝ (fun _ : Fin n => V) E)
(F := V →L[ℝ] ContinuousMultilinearMap ℝ (fun _ : Fin n => V) E)
((ContinuousLinearMap.lsmul ℝ ℂ).precompR V) f g' (K+n+1) x
change L (∫ y, ((ContinuousLinearMap.lsmul ℝ ℂ).precompR V) (f y)
((c y)⁻¹^(K+n+1) • g' ((c y)⁻¹ • (x-y)))) =
∫ y, f y • ((c y)⁻¹^(K+(n+1)) • L (g' ((c y)⁻¹ • (x-y))))
simp only [← Nat.add_assoc]
rw [← ContinuousLinearMap.integral_comp_comm (𝕜 := ℝ) L hi]
apply integral_congr_ae
filter_upwards with y
ext m
rfl
lemma iteratedFDeriv_value_smul_apply (f : V →ᵇ ℂ) (g : SchwartzMap V E) (K n : ℕ) (x : V) :
iteratedFDeriv ℝ n (value c (ContinuousLinearMap.lsmul ℝ ℂ) f g K) x =
∫ y, f y • ((c y)⁻¹^(K+n) • iteratedFDeriv ℝ n g ((c y)⁻¹ • (x-y))) := by
rw [iteratedFDeriv_value_smul ha c hc hcb]
simp only [value,ContinuousLinearMap.lsmul_apply,SchwartzDerivatives.iterated_apply]
end ScaledSchwartzConvolution
open Set Filter MeasureTheory
open scoped Topology SchwartzMap
namespace SourceFrozenScaling
variable {V E : Type} [NormedAddCommGroup V] [NormedSpace ℝ V]
[FiniteDimensional ℝ V] [MeasureSpace V] [BorelSpace V]
[Measure.IsAddHaarMeasure (volume : Measure V)]
[NormedAddCommGroup E] [NormedSpace ℂ E]
lemma normalized_integral (f : V → ℂ) (g : V → E) (c : V → ℝ) (r : ℝ) (hr : 0 < r)
(K : ℕ) (x : V) :
(∫ y, f y • ((r*c y)⁻¹^K • g ((r*c y)⁻¹ • (x-y)))) =
(r^Module.finrank ℝ V*(r⁻¹)^K) • ∫ z, f (x-r • z) •
((c (x-r • z))⁻¹^K • g ((c (x-r • z))⁻¹ • z)) := by
rw [← integral_sub_left_eq_self (fun y : V =>
f y • ((r*c y)⁻¹^K • g ((r*c y)⁻¹ • (x-y)))) volume x]
simp only [sub_sub_self]
let F : V → E := fun z => f (x-r • z) •
((c (x-r • z))⁻¹^K • g ((c (x-r • z))⁻¹ • z))
have he (y : V) : f (x-y) • ((r*c (x-y))⁻¹^K • g ((r*c (x-y))⁻¹ • y)) =
(r⁻¹)^K • F (r⁻¹ • y) := by
dsimp [F]
rw [smul_inv_smul₀ hr.ne',mul_inv,mul_pow]
rw [mul_comm r⁻¹ ((c (x-y))⁻¹),mul_smul]
rw [mul_smul,smul_comm (f (x-y)) ((r⁻¹)^K)]
simp_rw [he]
rw [integral_smul,Measure.integral_comp_inv_smul_of_nonneg volume F hr.le,smul_smul]
congr 1
ring
lemma dimension_cancel (r : ℝ) (hr : r ≠ 0) (d n : ℕ) :
r^d*(r⁻¹)^(d+n) = (r⁻¹)^n := by
rw [pow_add,← mul_assoc,← mul_pow,mul_inv_cancel₀ hr,one_pow,one_mul]
lemma normalized_integral_order (f : V → ℂ) (g : V → E) (c : V → ℝ)
(r : ℝ) (hr : 0 < r) (n : ℕ) (x : V) :
(∫ y, f y • ((r*c y)⁻¹^(Module.finrank ℝ V+n) • g ((r*c y)⁻¹ • (x-y)))) =
(r⁻¹)^n • ∫ z, f (x-r • z) •
((c (x-r • z))⁻¹^(Module.finrank ℝ V+n) • g ((c (x-r • z))⁻¹ • z)) := by
rw [normalized_integral f g c r hr,dimension_cancel r hr.ne']
end SourceFrozenScaling
namespace SourceFrozenRows
open ScaledSchwartzConvolution SchwartzTimeScale
open scoped BoundedContinuousFunction ContDiff
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
def value (K : SchwartzMap V ℂ) (A : V → ℝ) (r : ℝ) (f : V →ᵇ ℂ) : V → ℂ :=
ScaledSchwartzConvolution.value (fun y => r*(A y)^(1/4 : ℝ))
(ContinuousLinearMap.lsmul ℝ ℂ) f K (Module.finrank ℝ V)
def row (K : SchwartzMap V ℂ) (A : V → ℝ) (r : ℝ) (f : V →ᵇ ℂ)
(j : ℕ) : V → V [×j]→L[ℝ] ℂ :=
ScaledSchwartzConvolution.value (fun y => r*(A y)^(1/4 : ℝ))
(ContinuousLinearMap.lsmul ℝ ℂ) f (SchwartzDerivatives.iterated K j) (Module.finrank ℝ V+j)
omit [NormedAddCommGroup V] [InnerProductSpace ℝ V] [FiniteDimensional ℝ V]
[MeasurableSpace V] [BorelSpace V] in
lemma radius_bounds (A : V → ℝ) (α β : ℝ) (hα : 0 < α)
(hA : ∀ y, A y ∈ Icc α β) (r : ℝ) (hr : 0 < r) (y : V) :
r*(A y)^(1/4 : ℝ) ∈ Icc (r*α^(1/4 : ℝ)) (r*β^(1/4 : ℝ)) := by
constructor
· exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow hα.le (hA y).1 (by norm_num)) hr.le
· exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow
(hα.trans_le (hA y).1).le (hA y).2 (by norm_num)) hr.le
lemma contDiff_value (K : SchwartzMap V ℂ) (A : V → ℝ) (hA : Continuous A)
(α β : ℝ) (hα : 0 < α) (hAr : ∀ y, A y ∈ Icc α β)
(r : ℝ) (hr : 0 < r) (f : V →ᵇ ℂ) : ContDiff ℝ ∞ (value K A r f) := by
apply ScaledSchwartzConvolution.contDiff_value (a := r*α^(1/4 : ℝ))
(b := r*β^(1/4 : ℝ)) (by positivity) _
(continuous_const.mul (hA.rpow_const (fun _ => Or.inr (by norm_num))))
(radius_bounds A α β hα hAr r hr)
lemma row_eq (K : SchwartzMap V ℂ) (A : V → ℝ) (hA : Continuous A)
(α β : ℝ) (hα : 0 < α) (hAr : ∀ y, A y ∈ Icc α β)
(r : ℝ) (hr : 0 < r) (f : V →ᵇ ℂ) (j : ℕ) :
row K A r f j = iteratedFDeriv ℝ j (value K A r f) := by
symm
apply ScaledSchwartzConvolution.iteratedFDeriv_value_smul (a := r*α^(1/4 : ℝ))
(b := r*β^(1/4 : ℝ)) (by positivity) _
(continuous_const.mul (hA.rpow_const (fun _ => Or.inr (by norm_num))))
(radius_bounds A α β hα hAr r hr)
lemma row_normalized (K : SchwartzMap V ℂ) (A : V → ℝ)
(hAp : ∀ y, 0 < A y) (r : ℝ) (hr : 0 < r) (f : V →ᵇ ℂ) (j : ℕ) (x : V) :
row K A r f j x = (r⁻¹)^j • ∫ z, f (x-r • z) •
atTime (SchwartzDerivatives.iterated K j) (Module.finrank ℝ V+j) (A (x-r • z)) z := by
unfold row ScaledSchwartzConvolution.value
simp only [ContinuousLinearMap.lsmul_apply]
rw [SourceFrozenScaling.normalized_integral_order _ _ _ r hr]
congr 1
apply integral_congr_ae
filter_upwards with z
rw [atTime_eq_scaled _ _ _ (hAp _)]
lemma exists_row_holder_bound (K : SchwartzMap V ℂ) (j : ℕ) (hj : 0 < j)
(α β : ℝ) (hα : 0 < α) (γ : ℝ) (hγ : 0 ≤ γ) (hγ1 : γ ≤ 1) :
∃ C D : ℝ, 0 ≤ C ∧ 0 ≤ D ∧
∀ (A : V → ℝ) (_hA : Continuous A) (_hAr : ∀ y, A y ∈ Icc α β)
(L : ℝ) (_hL : 0 ≤ L) (_hAL : ∀ x y, ‖A x-A y‖ ≤ L*‖x-y‖)
(f : V →ᵇ ℂ) (H : ℝ) (_hH : 0 ≤ H)
(_hhold : ∀ x y, ‖f x-f y‖ ≤ H*‖x-y‖^γ)
(r : ℝ) (_hr : 0 < r) (x : V),
‖row K A r f j x‖ ≤ (r⁻¹)^j*(H*r^γ*C+‖f‖*L*r*D) := by
let K' := SchwartzDerivatives.iterated K j
obtain ⟨B,hB,hBw,hBp,hb⟩ := SourceFrozenCancellation.parameter_envelope K' (Module.finrank ℝ V+j) α β hα
obtain ⟨D,hD,hDw,hDp,hd⟩ := SourceFrozenCancellation.parameter_lipschitz_envelope K' (Module.finrank ℝ V+j) α β hα
refine ⟨∫ z, ‖z‖^γ*B z, ∫ z, ‖z‖*D z,
integral_nonneg (fun z => mul_nonneg (Real.rpow_nonneg (norm_nonneg _) _) (hBp z)),
integral_nonneg (fun z => mul_nonneg (norm_nonneg _) (hDp z)), ?_⟩
intro A hA hAr L hL hAL f H hH hhold r hr x
rw [row_normalized K A (fun y => hα.trans_le (hAr y).1) r hr,
norm_smul,Real.norm_eq_abs,abs_of_nonneg (by positivity)]
apply mul_le_mul_of_nonneg_left _ (by positivity)
have hz : ∫ z, K' z = 0 := by
obtain ⟨n,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hj)
simp only [K',SchwartzDerivatives.iterated_apply]
exact SchwartzDerivatives.integral_iterated K n
exact SourceFrozenCancellation.norm_normalized_source_integral K' _ α β hα hz
B D hB hBw hBp hD hDw hDp hb hd A hA hAr L hL hAL f γ H hγ hγ1 hH hhold r hr x
end SourceFrozenRows
namespace SourceFrozenOrder
open ScaledSchwartzConvolution SchwartzTimeScale
open scoped BoundedContinuousFunction ContDiff
variable {V E : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
[NormedAddCommGroup E] [NormedSpace ℂ E]
def value (K : SchwartzMap V E) (A : V → ℝ) (r : ℝ) (f : V →ᵇ ℂ) (j : ℕ) : V → E :=
ScaledSchwartzConvolution.value (fun y => r*(A y)^(1/4 : ℝ))
(ContinuousLinearMap.lsmul ℝ ℂ) f K (Module.finrank ℝ V+j)
lemma normalized (K : SchwartzMap V E) (A : V → ℝ)
(hAp : ∀ y, 0 < A y) (r : ℝ) (hr : 0 < r) (f : V →ᵇ ℂ) (j : ℕ) (x : V) :
value K A r f j x = (r⁻¹)^j • ∫ z, f (x-r • z) •
atTime K (Module.finrank ℝ V+j) (A (x-r • z)) z := by
unfold value ScaledSchwartzConvolution.value
simp only [ContinuousLinearMap.lsmul_apply]
rw [SourceFrozenScaling.normalized_integral_order _ _ _ r hr]
congr 1
apply integral_congr_ae
filter_upwards with z
rw [atTime_eq_scaled _ _ _ (hAp _)]
lemma exists_norm_bound (K : SchwartzMap V E) (j : ℕ) (α β : ℝ) (hα : 0 < α) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (A : V → ℝ) (_hA : Continuous A)
(_hAr : ∀ y, A y ∈ Icc α β) (r : ℝ) (_hr : 0 < r) (f : V →ᵇ ℂ) (x : V),
‖value K A r f j x‖ ≤ (r⁻¹)^j * (‖f‖*C) := by
obtain ⟨B,hB,_hw,hBp,hb⟩ := SourceFrozenCancellation.parameter_envelope K (Module.finrank ℝ V+j) α β hα
refine ⟨∫ z, B z,integral_nonneg hBp,?_⟩
intro A hA hAr r hr f x
rw [normalized K A (fun y => hα.trans_le (hAr y).1) r hr,norm_smul,Real.norm_of_nonneg (by positivity : 0 ≤ (r⁻¹)^j)]
apply mul_le_mul_of_nonneg_left _ (by positivity)
have hi : Integrable (fun z => f (x-r • z) •
atTime K (Module.finrank ℝ V+j) (A (x-r • z)) z) := by
apply (hB.const_mul ‖f‖).mono'
· exact ((f.continuous.comp (continuous_const.sub (continuous_const.smul continuous_id))).smul
(SourceFrozenCancellation.continuous_variable K _ (fun z => A (x-r • z))
(hA.comp (continuous_const.sub (continuous_const.smul continuous_id)))
(fun z => hα.trans_le (hAr _).1))).aestronglyMeasurable
· filter_upwards with z
rw [norm_smul]
exact mul_le_mul (f.norm_coe_le_norm _) (hb _ (hAr _) z) (norm_nonneg _) (norm_nonneg _)
change ‖∫ z, f (x-r • z) • atTime K _ (A (x-r • z)) z‖ ≤ _
calc
_ ≤ ∫ z, ‖f (x-r • z) • atTime K _ (A (x-r • z)) z‖ := norm_integral_le_integral_norm _
_ ≤ ∫ z, ‖f‖*B z := by
apply integral_mono hi.norm (hB.const_mul ‖f‖)
intro z
dsimp only
rw [norm_smul]
exact mul_le_mul (f.norm_coe_le_norm _) (hb _ (hAr _) z) (norm_nonneg _) (norm_nonneg _)
_ = _ := integral_const_mul ..
lemma hasFDerivAt_value (K : SchwartzMap V E) (A : V → ℝ) (hA : Continuous A)
(α β : ℝ) (hα : 0 < α) (hAr : ∀ y, A y ∈ Icc α β)
(r : ℝ) (hr : 0 < r) (f : V →ᵇ ℂ) (j : ℕ) (x : V) :
HasFDerivAt (value K A r f j)
(value (SchwartzMap.fderivCLM ℝ V E K) A r f (j+1) x) x := by
have h := ScaledSchwartzConvolution.hasFDerivAt_value
(a := r*α^(1/4 : ℝ)) (b := r*β^(1/4 : ℝ)) (by positivity)
(fun y => r*(A y)^(1/4 : ℝ))
(continuous_const.mul (hA.rpow_const (fun _ => Or.inr (by norm_num))))
(SourceFrozenRows.radius_bounds A α β hα hAr r hr)
(ContinuousLinearMap.lsmul ℝ ℂ) f K (Module.finrank ℝ V+j) x
have he : (ContinuousLinearMap.lsmul ℝ ℂ : ℂ →L[ℝ] E →L[ℝ] E).precompR V =
(ContinuousLinearMap.lsmul ℝ ℂ : ℂ →L[ℝ] (V →L[ℝ] E) →L[ℝ] (V →L[ℝ] E)) := by
ext c g v
rfl
simpa only [value, Nat.add_assoc, he] using h
lemma exists_bounds (K : SchwartzMap V E) (j : ℕ) (α β : ℝ) (hα : 0 < α) :
∃ C D : ℝ, 0 ≤ C ∧ 0 ≤ D ∧
∀ (A : V → ℝ) (_hA : Continuous A) (_hAr : ∀ z, A z ∈ Icc α β)
(r : ℝ) (_hr : 0 < r) (f : V →ᵇ ℂ),
(∀ x, ‖value K A r f j x‖ ≤ (r⁻¹)^j*(‖f‖*C)) ∧
(∀ x y, ‖value K A r f j x-value K A r f j y‖ ≤ ((r⁻¹)^(j+1)*(‖f‖*D))*‖x-y‖) := by
obtain ⟨C,hC,hb⟩ := exists_norm_bound K j α β hα
obtain ⟨D,hD,hd⟩ := exists_norm_bound (SchwartzMap.fderivCLM ℝ V E K) (j+1) α β hα
refine ⟨C,D,hC,hD,?_⟩
intro A hA hAr r hr f
refine ⟨hb A hA hAr r hr f,fun x y => ?_⟩
exact (convex_univ : Convex ℝ (univ : Set V)).norm_image_sub_le_of_norm_hasFDerivWithin_le
(fun z _ => (hasFDerivAt_value K A hA α β hα hAr r hr f j z).hasFDerivWithinAt)
(fun z _ => hd A hA hAr r hr f z) (mem_univ y) (mem_univ x)
end SourceFrozenOrder
namespace FrozenParametrix
open scoped SchwartzMap Laplacian ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
def bilapOne : SchwartzMap V ℂ := Δ (Δ (heatKernel (V := V) 1 zero_lt_one) : SchwartzMap V ℂ)
def heatOne : SchwartzMap V ℂ := heatKernel 1 zero_lt_one
lemma quarter_root (t : ℝ) (ht : 0 < t) : Real.sqrt (Real.sqrt t) = t^(1/4 : ℝ) := by
rw [Real.sqrt_eq_rpow,Real.sqrt_eq_rpow,← Real.rpow_mul ht.le]
norm_num
lemma bilapKernel_ordered (t : ℝ) (ht : 0 < t) (r : ℝ) (hr : 0 < r) (z : V) :
bilapKernel (r^4*t) z = ((r*t^(1/4 : ℝ))⁻¹)^(Module.finrank ℝ V+4) •
bilapOne ((r*t^(1/4 : ℝ))⁻¹ • z) := by
rw [bilapKernel_scaling t ht r hr,bilapKernel_eq_scaled t ht,quarter_root t ht]
dsimp only [bilapOne]
rw [mul_inv,mul_pow,smul_smul,smul_smul]
congr 2
rw [mul_comm]
lemma kernel_ordered (t : ℝ) (ht : 0 < t) (r : ℝ) (hr : 0 < r) (z : V) :
kernel (r^4*t) z = ((r*t^(1/4 : ℝ))⁻¹)^(Module.finrank ℝ V) •
heatOne ((r*t^(1/4 : ℝ))⁻¹ • z) := by
have hs := heatKernel_scaling t ht r hr z
rw [heatKernel_eq_kernel,heatKernel_eq_kernel] at hs
rw [hs,kernel_eq_scaled t ht,quarter_root t ht]
dsimp only [heatOne]
rw [mul_inv,mul_pow,smul_smul,smul_smul]
simp only [inv_pow]
congr 2
rw [mul_comm]
lemma integrable_ordered (K : SchwartzMap V ℂ) (j : ℕ) {α β : ℝ} (hα : 0 < α)
(a : C(V,Icc α β)) (r : ℝ) (hr : 0 < r) (f : V →ᵇ ℂ) (x : V) :
Integrable (fun y => f y • (((r*(a y).val^(1/4 : ℝ))⁻¹)^(Module.finrank ℝ V+j) •
K ((r*(a y).val^(1/4 : ℝ))⁻¹ • (x-y)))) := by
exact ScaledSchwartzConvolution.integrable_integrand
(a := r*α^(1/4 : ℝ)) (b := r*β^(1/4 : ℝ)) (by positivity)
(fun y => r*(a y).val^(1/4 : ℝ))
(continuous_const.mul ((continuous_subtype_val.comp a.continuous).rpow_const
(fun _ => Or.inr (by norm_num))))
(SourceFrozenRows.radius_bounds (fun y => (a y).val) α β hα (fun y => (a y).property) r hr)
(ContinuousLinearMap.lsmul ℝ ℂ) f K (Module.finrank ℝ V+j) x
lemma principal_eq_ordered {α β : ℝ} (hα : 0 < α) (a₀ a₁ : C(V,Icc α β))
(r : ℝ) (hr : 0 < r) (f : C₀(V,ℂ)) (x : V) :
principalResidual hα a₀ a₁ r f x = coefficient a₁ x *
SourceFrozenOrder.value bilapOne (fun y => (a₀ y).val) r f.toBCF 4 x -
SourceFrozenOrder.value bilapOne (fun y => (a₀ y).val) r (coefficient a₀*f.toBCF) 4 x := by
rw [principalResidual_apply_unscaled hα a₀ a₁ r hr]
simp_rw [bilapKernel_ordered _ (hα.trans_le (a₀ _).property.1) r hr]
have hi := integrable_ordered bilapOne 4 hα a₀ r hr f.toBCF x
have hi' := integrable_ordered bilapOne 4 hα a₀ r hr (coefficient a₀*f.toBCF) x
unfold SourceFrozenOrder.value ScaledSchwartzConvolution.value
simp only [ContinuousLinearMap.lsmul_apply,smul_eq_mul] at hi hi' ⊢
rw [← integral_const_mul,← integral_sub (hi.const_mul (coefficient a₁ x)) hi']
apply integral_congr_ae
filter_upwards with y
simp only [coefficient_apply,BoundedContinuousFunction.coe_mul,Pi.mul_apply,
Complex.ofReal_sub]
change (_-_)*_*f y = _*(f y*_)-(_*f y)*_
ring
lemma frozen_eq_ordered {α β : ℝ} (hα : 0 < α) (a₀ : C(V,Icc α β))
(r : ℝ) (hr : 0 < r) (f : C₀(V,ℂ)) (x : V) :
frozenOp hα a₀ r f x = SourceFrozenOrder.value heatOne (fun y => (a₀ y).val) r f.toBCF 0 x := by
rw [frozenOp,frozen_apply_unscaled _ _ _ _ _ _ _ hr]
unfold SourceFrozenOrder.value ScaledSchwartzConvolution.value
simp only [Nat.add_zero,ContinuousLinearMap.lsmul_apply,smul_eq_mul]
apply integral_congr_ae
filter_upwards with y
rw [kernel_ordered _ (hα.trans_le (a₀ _).property.1) r hr]
exact mul_comm _ _
end FrozenParametrix
open Set MeasureTheory
namespace ProductLipschitz
lemma bound {X : Type*} [NormedAddCommGroup X] (a u : X → ℂ)
(B L M N : ℝ) (hB : 0 ≤ B) (hL : 0 ≤ L)
(ha : ∀ x, ‖a x‖ ≤ B) (hu : ∀ x, ‖u x‖ ≤ M)
(hal : ∀ x y, ‖a x-a y‖ ≤ L*‖x-y‖)
(hul : ∀ x y, ‖u x-u y‖ ≤ N*‖x-y‖) (x y : X) :
‖a x*u x-a y*u y‖ ≤ (B*N+L*M)*‖x-y‖ := by
have he : a x*u x-a y*u y = a x*(u x-u y)+(a x-a y)*u y := by ring
rw [he]
calc
_ ≤ ‖a x*(u x-u y)‖+‖(a x-a y)*u y‖ := norm_add_le ..
_ = ‖a x‖*‖u x-u y‖+‖a x-a y‖*‖u y‖ := by rw [norm_mul,norm_mul]
_ ≤ B*(N*‖x-y‖)+(L*‖x-y‖)*M := add_le_add
(mul_le_mul (ha x) (hul x y) (norm_nonneg _) hB)
(mul_le_mul (hal x y) (hu y) (norm_nonneg _) (mul_nonneg hL (norm_nonneg _)))
_ = _ := by ring
lemma inv_pow_le {r : ℝ} (hr : 0 < r) (hr1 : r ≤ 1) {j k : ℕ} (hjk : j ≤ k) :
(r⁻¹)^j ≤ (r⁻¹)^k := by
have hh : 1 ≤ r⁻¹ := (one_le_inv₀ hr).mpr hr1
exact pow_le_pow_right₀ hh hjk
end ProductLipschitz
namespace FrozenParametrix
open scoped SchwartzMap Laplacian ZeroAtInfty BoundedContinuousFunction
open BiharmonicKernel
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
omit [InnerProductSpace ℝ V] [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
lemma norm_coefficient_le_pos {α β : ℝ} (hα : 0 < α) (a : C(V,Icc α β)) :
‖coefficient a‖ ≤ max β 0 := by
apply (BoundedContinuousFunction.norm_le (le_max_right _ _)).mpr
intro x
rw [coefficient_apply,Complex.norm_real,Real.norm_of_nonneg (hα.le.trans (a x).property.1)]
exact (a x).property.2.trans (le_max_left _ _)
lemma exists_principal_lipschitz_bound (α β : ℝ) (hα : 0 < α) (L : ℝ) (hL : 0 ≤ L) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (a₀ a₁ : C(V,Icc α β))
(_hLip : ∀ x y, |(a₁ x).val-(a₁ y).val| ≤ L*‖x-y‖)
(r : ℝ) (_hr : 0 < r) (_hr1 : r ≤ 1) (f : C₀(V,ℂ)) (x y : V),
‖principalResidual hα a₀ a₁ r f x-principalResidual hα a₀ a₁ r f y‖ ≤
((r⁻¹)^5*‖f‖*C)*‖x-y‖ := by
obtain ⟨C,D,hC,hD,hb⟩ := SourceFrozenOrder.exists_bounds (bilapOne : SchwartzMap V ℂ) 4 α β hα
let B := max β 0
have hB : 0 ≤ B := le_max_right _ _
refine ⟨L*C+2*B*D,by positivity,?_⟩
intro a₀ a₁ hLip r hr hr1 f x y
let A := fun z => (a₀ z).val
have hA : Continuous A := continuous_subtype_val.comp a₀.continuous
have hAr : ∀ z, A z ∈ Icc α β := fun z => (a₀ z).property
obtain ⟨hu,hul⟩ := hb A hA hAr r hr f.toBCF
obtain ⟨_hv,hvl⟩ := hb A hA hAr r hr (coefficient a₀*f.toBCF)
have ha : ∀ z, ‖coefficient a₁ z‖ ≤ B := fun z =>
((coefficient a₁).norm_coe_le_norm z).trans (norm_coefficient_le_pos hα a₁)
have hal : ∀ z w, ‖coefficient a₁ z-coefficient a₁ w‖ ≤ L*‖z-w‖ := by
intro z w
simpa only [coefficient_apply,← Complex.ofReal_sub,Complex.norm_real,Real.norm_eq_abs] using hLip z w
have hmul : ‖coefficient a₀*f.toBCF‖ ≤ B*‖f‖ := by
simpa only [ZeroAtInftyContinuousMap.norm_toBCF_eq_norm] using
(norm_mul_le (coefficient a₀) f.toBCF).trans
(mul_le_mul_of_nonneg_right (norm_coefficient_le_pos hα a₀) (norm_nonneg f.toBCF))
have hp := ProductLipschitz.bound (coefficient a₁)
(SourceFrozenOrder.value bilapOne A r f.toBCF 4)
B L ((r⁻¹)^4*(‖f.toBCF‖*C)) ((r⁻¹)^5*(‖f.toBCF‖*D)) hB hL ha hu hal hul x y
simp_rw [principal_eq_ordered hα a₀ a₁ r hr]
calc
_ = ‖(coefficient a₁ x*SourceFrozenOrder.value bilapOne A r f.toBCF 4 x-
coefficient a₁ y*SourceFrozenOrder.value bilapOne A r f.toBCF 4 y)-
(SourceFrozenOrder.value bilapOne A r (coefficient a₀*f.toBCF) 4 x-
SourceFrozenOrder.value bilapOne A r (coefficient a₀*f.toBCF) 4 y)‖ := by congr 1; ring
_ ≤ ‖coefficient a₁ x*SourceFrozenOrder.value bilapOne A r f.toBCF 4 x-
coefficient a₁ y*SourceFrozenOrder.value bilapOne A r f.toBCF 4 y‖+
‖SourceFrozenOrder.value bilapOne A r (coefficient a₀*f.toBCF) 4 x-
SourceFrozenOrder.value bilapOne A r (coefficient a₀*f.toBCF) 4 y‖ := norm_sub_le ..
_ ≤ (B*((r⁻¹)^5*(‖f.toBCF‖*D))+L*((r⁻¹)^4*(‖f.toBCF‖*C)))*‖x-y‖+
((r⁻¹)^5*(‖coefficient a₀*f.toBCF‖*D))*‖x-y‖ := add_le_add hp (hvl x y)
_ ≤ (B*((r⁻¹)^5*(‖f‖*D))+L*((r⁻¹)^5*(‖f‖*C)))*‖x-y‖+
((r⁻¹)^5*((B*‖f‖)*D))*‖x-y‖ := by
simp only [ZeroAtInftyContinuousMap.norm_toBCF_eq_norm]
gcongr <;> first | exact hmul | exact (one_le_inv₀ hr).mpr hr1 | norm_num
_ = _ := by ring
lemma exists_frozen_lipschitz_bound (α β : ℝ) (hα : 0 < α) (B L : ℝ)
(hB : 0 ≤ B) (hL : 0 ≤ L) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (a : C(V,Icc α β)) (b : V →ᵇ ℂ)
(_hb : ‖b‖ ≤ B) (_hLip : ∀ x y, ‖b x-b y‖ ≤ L*‖x-y‖)
(r : ℝ) (_hr : 0 < r) (_hr1 : r ≤ 1) (f : C₀(V,ℂ)) (x y : V),
‖b x*frozenOp hα a r f x-b y*frozenOp hα a r f y‖ ≤
((r⁻¹)^5*‖f‖*C)*‖x-y‖ := by
obtain ⟨C,D,hC,hD,hbound⟩ := SourceFrozenOrder.exists_bounds (heatOne : SchwartzMap V ℂ) 0 α β hα
refine ⟨B*D+L*C,by positivity,?_⟩
intro a b hb hLip r hr hr1 f x y
obtain ⟨hu,hul⟩ := hbound (fun z => (a z).val) (continuous_subtype_val.comp a.continuous)
(fun z => (a z).property) r hr f.toBCF
have hh := ProductLipschitz.bound b
(SourceFrozenOrder.value heatOne (fun z => (a z).val) r f.toBCF 0)
B L ((r⁻¹)^0*(‖f.toBCF‖*C)) ((r⁻¹)^1*(‖f.toBCF‖*D)) hB hL
(fun z => (b.norm_coe_le_norm z).trans hb) hu hLip hul x y
simp_rw [frozen_eq_ordered hα a r hr]
apply hh.trans
calc
_ ≤ (B*((r⁻¹)^5*(‖f‖*D))+L*((r⁻¹)^5*(‖f‖*C)))*‖x-y‖ := by
simp only [ZeroAtInftyContinuousMap.norm_toBCF_eq_norm]
gcongr <;> first | exact (one_le_inv₀ hr).mpr hr1 | norm_num
_ = _ := by ring
lemma exists_fullResidual_lipschitz_bound (α β : ℝ) (hα : 0 < α) (B L : ℝ)
(hB : 0 ≤ B) (hL : 0 ≤ L) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (a₀ a₁ : C(V,Icc α β)) (b : V →ᵇ ℂ)
(_hb : ‖b‖ ≤ B) (_hLipa : ∀ x y, |(a₁ x).val-(a₁ y).val| ≤ L*‖x-y‖)
(_hLipb : ∀ x y, ‖b x-b y‖ ≤ L*‖x-y‖)
(r : ℝ) (_hr : 0 < r) (_hr1 : r ≤ 1) (f : C₀(V,ℂ)) (x y : V),
‖fullResidualCLM hα a₀ a₁ b r f x-fullResidualCLM hα a₀ a₁ b r f y‖ ≤
((r⁻¹)^5*‖f‖*C)*‖x-y‖ := by
obtain ⟨C,hC,hp⟩ := exists_principal_lipschitz_bound (V := V) α β hα L hL
obtain ⟨D,hD,hf⟩ := exists_frozen_lipschitz_bound (V := V) α β hα B L hB hL
refine ⟨C+D,add_nonneg hC hD,?_⟩
intro a₀ a₁ b hb ha hl r hr hr1 f x y
have he : fullResidualCLM hα a₀ a₁ b r f x-fullResidualCLM hα a₀ a₁ b r f y =
(principalResidual hα a₀ a₁ r f x-principalResidual hα a₀ a₁ r f y)+
(b x*frozenOp hα a₀ r f x-b y*frozenOp hα a₀ r f y) := by
simp only [fullResidualCLM_apply, ZeroAtInftyContinuousMap.add_apply, C0Multiplier.mul_apply]
ring
rw [he]
calc
_ ≤ ‖principalResidual hα a₀ a₁ r f x-principalResidual hα a₀ a₁ r f y‖+
‖b x*frozenOp hα a₀ r f x-b y*frozenOp hα a₀ r f y‖ := norm_add_le ..
_ ≤ ((r⁻¹)^5*‖f‖*C)*‖x-y‖+((r⁻¹)^5*‖f‖*D)*‖x-y‖ :=
add_le_add (hp a₀ a₁ ha r hr hr1 f x y) (hf a₀ b hb hl r hr hr1 f x y)
_ = _ := by ring
end FrozenParametrix
open scoped Topology
namespace HolderInterpolation
lemma scalar {z A B δ γ : ℝ} (hz : 0 ≤ z) (hA : 0 ≤ A) (hB : 0 ≤ B)
(hδ : 0 ≤ δ) (hγ : 0 < γ) (hγ1 : γ < 1) (ha : z ≤ A) (hb : z ≤ B*δ) :
z ≤ A^(1-γ)*B^γ*δ^γ := by
by_cases hz0 : z = 0
· rw [hz0]; positivity
have hz' : 0 < z := lt_of_le_of_ne hz (Ne.symm hz0)
calc
_ = z^(1-γ)*z^γ := by rw [← Real.rpow_add hz']; simp
_ ≤ A^(1-γ)*(B*δ)^γ := mul_le_mul
(Real.rpow_le_rpow hz ha (by linarith)) (Real.rpow_le_rpow hz hb hγ.le)
(Real.rpow_nonneg hz _) (Real.rpow_nonneg hA _)
_ = _ := by rw [Real.mul_rpow hB hδ]; ring
lemma scaled {z C δ q γ p₀ p₁ : ℝ} (hz : 0 ≤ z) (hC : 0 ≤ C)
(hδ : 0 ≤ δ) (hq : 0 < q) (hγ : 0 < γ) (hγ1 : γ < 1)
(ha : z ≤ C*q^p₀) (hb : z ≤ (C*q^p₁)*δ) :
z ≤ C*q^(p₀*(1-γ)+p₁*γ)*δ^γ := by
by_cases hC0 : C = 0
· simpa only [hC0,zero_mul] using ha
have hC' : 0 < C := lt_of_le_of_ne hC (Ne.symm hC0)
have he := scalar hz (mul_nonneg hC (Real.rpow_nonneg hq.le _))
(mul_nonneg hC (Real.rpow_nonneg hq.le _)) hδ hγ hγ1 ha hb
rw [Real.mul_rpow hC (Real.rpow_nonneg hq.le _),
Real.mul_rpow hC (Real.rpow_nonneg hq.le _),
← Real.rpow_mul hq.le,← Real.rpow_mul hq.le] at he
have heq : C^(1-γ)*q^(p₀*(1-γ))*(C^γ*q^(p₁*γ))*δ^γ =
C*q^(p₀*(1-γ)+p₁*γ)*δ^γ := by
calc
_ = (C^(1-γ)*C^γ)*(q^(p₀*(1-γ))*q^(p₁*γ))*δ^γ := by ring
_ = _ := by rw [← Real.rpow_add hC',← Real.rpow_add hq]; simp
exact heq ▸ he
lemma residual {z C δ q γ : ℝ} (hz : 0 ≤ z) (hC : 0 ≤ C)
(hδ : 0 ≤ δ) (hq : 0 < q) (hγ : 0 < γ) (hγ1 : γ < 1)
(ha : z ≤ C*q^(-(3/4 : ℝ))) (hb : z ≤ (C*q^(-(5/4 : ℝ)))*δ) :
z ≤ C*q^(-(3+2*γ)/4)*δ^γ := by
simpa only [show (-(3/4 : ℝ))*(1-γ)+ (-(5/4 : ℝ))*γ = -(3+2*γ)/4 by ring] using
(scaled hz hC hδ hq hγ hγ1 ha hb)
end HolderInterpolation
namespace ParabolicRadius
lemma inv_pow_five {q : ℝ} (hq : 0 ≤ q) : (radius q)⁻¹^5 = q^(-5/4 : ℝ) := by
unfold radius
rw [← Real.rpow_natCast,← Real.rpow_neg hq,← Real.rpow_mul hq]
congr 1
norm_num
end ParabolicRadius
namespace ParametrixVolterra
open scoped ZeroAtInfty BoundedContinuousFunction
open FrozenParametrix C0Convolution StrongWeightedVolterra
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {T α β : ℝ} (hα : 0 < α) (A : C(Slab T, V →ᵇ Icc α β)) (b : C(Slab T, V →ᵇ ℂ))
lemma exists_actualResidual_holder_bound (hT : T ≤ 1) (L B : ℝ) (hL : 0 ≤ L) (hB : 0 ≤ B)
(hb : ∀ s, ‖b s‖ ≤ B)
(hLip : ∀ s r : Slab T, ∀ x z : V,
|(A s x).val-(A r z).val| ≤ L*(‖x-z‖+|s.val-r.val|))
(hLipb : ∀ s : Slab T, ∀ x z : V, ‖b s x-b s z‖ ≤ L*‖x-z‖)
(γ : ℝ) (hγ : 0 < γ) (hγ1 : γ < 1) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (t : Time T) (s : Slab T) (_hst : s.val<t.val)
(f : C₀(V,ℂ)) (x y : V),
‖actualResidual hα A b t s f x-actualResidual hα A b t s f y‖ ≤
C*‖f‖*(t.val-s.val)^(-(3+2*γ)/4)*‖x-y‖^γ := by
obtain ⟨C,hC,hb₀⟩ := exists_actualResidual_bound hα A b hT L B hL hB hb hLip
obtain ⟨D,hD,hb₁⟩ := exists_fullResidual_lipschitz_bound (V := V) α β hα B L hB hL
refine ⟨2*C+D,by positivity,?_⟩
intro t s hst f x y
let q := t.val-s.val
have hq : 0 < q := sub_pos.mpr hst
have hq1 : q ≤ 1 := by dsimp [q]; linarith [t.property.2,s.property.1]
have hnorm (z : V) : ‖actualResidual hα A b t s f z‖ ≤ C*q^(-3/4 : ℝ)*‖f‖ :=
((actualResidual hα A b t s f).toBCF.norm_coe_le_norm z).trans
(((actualResidual hα A b t s).le_opNorm f).trans
(mul_le_mul_of_nonneg_right (hb₀ t s hst) (norm_nonneg f)))
have hs : ‖actualResidual hα A b t s f x-actualResidual hα A b t s f y‖ ≤
((2*C+D)*‖f‖)*q^(-3/4 : ℝ) := by
calc
_ ≤ ‖actualResidual hα A b t s f x‖+‖actualResidual hα A b t s f y‖ := norm_sub_le ..
_ ≤ C*q^(-3/4 : ℝ)*‖f‖+C*q^(-3/4 : ℝ)*‖f‖ := add_le_add (hnorm x) (hnorm y)
_ ≤ _ := by nlinarith [mul_nonneg hD (mul_nonneg (norm_nonneg f) (Real.rpow_nonneg hq.le (-3/4 : ℝ)))]
have hl : ‖actualResidual hα A b t s f x-actualResidual hα A b t s f y‖ ≤
(((2*C+D)*‖f‖)*q^(-5/4 : ℝ))*‖x-y‖ := by
have h := hb₁ (A s).toContinuousMap (A (now t)).toContinuousMap (b (now t)) (hb _)
(fun z w => by
change |(A (now t) z).val-(A (now t) w).val| ≤ L*‖z-w‖
simpa only [sub_self,abs_zero,add_zero] using hLip (now t) (now t) z w)
(hLipb _) (ParabolicRadius.radius q) (ParabolicRadius.pos hq)
(ParabolicRadius.le_one hq.le hq1) f x y
rw [ParabolicRadius.inv_pow_five hq.le] at h
apply h.trans
calc
_ = D*‖f‖*q^(-5/4 : ℝ)*‖x-y‖ := by ring
_ ≤ _ := by gcongr; nlinarith
simpa only [neg_div] using HolderInterpolation.residual (norm_nonneg _)
(show 0 ≤ (2*C+D)*‖f‖ by positivity) (norm_nonneg (x-y)) hq hγ hγ1
(by simpa only [neg_div] using hs) (by simpa only [neg_div] using hl)
end ParametrixVolterra
open Set MeasureTheory
namespace BetaWeights
def density (σ ρ t s : ℝ) : ℝ := s^(-σ)*(t-s)^(-ρ)
lemma density_nonneg (σ ρ t s : ℝ) (hs : 0 ≤ s) (hst : s ≤ t) : 0 ≤ density σ ρ t s := by
exact mul_nonneg (Real.rpow_nonneg hs _) (Real.rpow_nonneg (sub_nonneg.mpr hst) _)
lemma intervalIntegrable_one (σ ρ : ℝ) (hσ : σ < 1) (hρ : ρ < 1) :
IntervalIntegrable (density σ ρ 1) volume 0 1 := by
have hb := (Complex.betaIntegral_convergent
(u := ((1-σ : ℝ) : ℂ)) (v := ((1-ρ : ℝ) : ℂ)) (by simpa using sub_pos.mpr hσ)
(by simpa using sub_pos.mpr hρ)).norm
apply hb.congr_ae
rw [uIoc_of_le (by norm_num : (0:ℝ) ≤ 1),← restrict_Ioo_eq_restrict_Ioc]
filter_upwards [ae_restrict_mem measurableSet_Ioo] with x hx
dsimp only [density]
rw [norm_mul]
have hq : ((1-σ : ℝ) : ℂ)-1 = ((-σ : ℝ) : ℂ) := by push_cast; ring
have hr : ((1-ρ : ℝ) : ℂ)-1 = ((-ρ : ℝ) : ℂ) := by push_cast; ring
rw [hq,hr,show (1 : ℂ)-(x : ℂ) = ((1-x : ℝ) : ℂ) by push_cast; rfl,
Complex.norm_cpow_real,Complex.norm_cpow_real,Complex.norm_real,Complex.norm_real,
Real.norm_eq_abs,Real.norm_eq_abs,abs_of_pos hx.1,abs_of_pos (sub_pos.mpr hx.2)]
lemma density_scaled (σ ρ t s : ℝ) (ht : 0 < t) (hs : s ∈ Ioo 0 1) :
density σ ρ t (t*s) = (t^(-σ)*t^(-ρ))*density σ ρ 1 s := by
unfold density
rw [show t-t*s = t*(1-s) by ring,Real.mul_rpow ht.le hs.1.le,
Real.mul_rpow ht.le (sub_nonneg.mpr hs.2.le)]
ring
lemma intervalIntegrable (σ ρ : ℝ) (hσ : σ < 1) (hρ : ρ < 1) (t : ℝ) (ht : 0 < t) :
IntervalIntegrable (density σ ρ t) volume 0 t := by
rw [← IntervalIntegrable.comp_mul_left_iff ht.ne']
simp only [zero_div,div_self ht.ne']
apply ((intervalIntegrable_one σ ρ hσ hρ).const_mul (t^(-σ)*t^(-ρ))).congr_ae
rw [uIoc_of_le (by norm_num : (0:ℝ) ≤ 1)]
have hmem : ∀ᵐ s ∂volume.restrict (Ioc (0:ℝ) 1), s ∈ Ioo 0 1 := by
rw [← restrict_Ioo_eq_restrict_Ioc]
exact ae_restrict_mem measurableSet_Ioo
filter_upwards [hmem] with s hs
exact (density_scaled σ ρ t s ht hs).symm
lemma integral_scale (σ ρ t : ℝ) (ht : 0 < t) :
(∫ s in 0..t, density σ ρ t s) = t^(1-σ-ρ)*(∫ s in 0..1, density σ ρ 1 s) := by
have hc := intervalIntegral.smul_integral_comp_mul_left (a := 0) (b := 1) (density σ ρ t) t
simp only [mul_zero,mul_one,smul_eq_mul] at hc
rw [← hc]
have he : (∫ s in 0..1, density σ ρ t (t*s)) =
(t^(-σ)*t^(-ρ))*(∫ s in 0..1, density σ ρ 1 s) := by
rw [← intervalIntegral.integral_const_mul]
apply intervalIntegral.integral_congr_ae
rw [uIoc_of_le (by norm_num : (0:ℝ) ≤ 1),← ae_restrict_iff' measurableSet_Ioc,← restrict_Ioo_eq_restrict_Ioc]
filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
exact density_scaled σ ρ t s ht hs
rw [he,← mul_assoc]
congr 1
calc
_ = t^(1 : ℝ)*(t^(-σ)*t^(-ρ)) := by rw [Real.rpow_one]
_ = _ := by rw [← Real.rpow_add ht,← Real.rpow_add ht]; congr 1; ring
end BetaWeights
namespace HolderIntegral
open scoped ZeroAtInfty BoundedContinuousFunction
variable {V : Type*} [TopologicalSpace V]
def eval (x : V) : C₀(V,ℂ) →L[ℝ] ℂ :=
LinearMap.mkContinuous
{ toFun := fun f => f x
map_add' := fun _ _ => rfl
map_smul' := fun _ _ => rfl } 1 (fun f => by
change ‖f.toBCF x‖ ≤ 1*‖f‖
simpa only [one_mul,ZeroAtInftyContinuousMap.norm_toBCF_eq_norm] using f.toBCF.norm_coe_le_norm x)
lemma intervalIntegral_apply (f : ℝ → C₀(V,ℂ)) {a b : ℝ}
(hf : IntervalIntegrable f volume a b) (x : V) :
(∫ s in a..b, f s) x = ∫ s in a..b, f s x :=
((eval x).intervalIntegral_comp_comm hf).symm
lemma beta_holder {x y : V} (f : ℝ → C₀(V,ℂ)) (t : ℝ) (ht : 0 < t)
(hf : IntervalIntegrable f volume 0 t) (σ ρ : ℝ) (hσ : σ < 1) (hρ : ρ < 1)
(C δ : ℝ) (h : ∀ s ∈ Ioo 0 t,
‖f s x-f s y‖ ≤ C*BetaWeights.density σ ρ t s*δ) :
‖(∫ s in 0..t, f s) x-(∫ s in 0..t, f s) y‖ ≤
C*t^(1-σ-ρ)*(∫ s in 0..1, BetaWeights.density σ ρ 1 s)*δ := by
rw [intervalIntegral_apply f hf x,intervalIntegral_apply f hf y,
← intervalIntegral.integral_sub (show IntervalIntegrable (fun s => f s x) volume 0 t from ⟨(eval x).integrable_comp hf.1,(eval x).integrable_comp hf.2⟩)
(show IntervalIntegrable (fun s => f s y) volume 0 t from ⟨(eval y).integrable_comp hf.1,(eval y).integrable_comp hf.2⟩)]
calc
_ ≤ ∫ s in 0..t, C*BetaWeights.density σ ρ t s*δ := by
apply intervalIntegral.norm_integral_le_of_norm_le ht.le
· rw [← ae_restrict_iff' measurableSet_Ioc,← restrict_Ioo_eq_restrict_Ioc]
filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
exact h s hs
· exact ((BetaWeights.intervalIntegrable σ ρ hσ hρ t ht).const_mul C).mul_const δ
_ = _ := by
rw [intervalIntegral.integral_mul_const,intervalIntegral.integral_const_mul,
BetaWeights.integral_scale σ ρ t ht]
ring
end HolderIntegral
namespace ParametrixVolterra
open scoped ZeroAtInfty BoundedContinuousFunction
open FrozenParametrix C0Convolution StrongWeightedVolterra
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable {T α β : ℝ} (hα : 0 < α) (A : C(Slab T, V →ᵇ Icc α β)) (b : C(Slab T, V →ᵇ ℂ))
lemma holder_residual_integral (hT₀ : 0 ≤ T) (C : ℝ) (hC : 0 ≤ C)
(hR : ∀ (t : Time T) (s : Slab T), s.val<t.val → ∀ (f : C₀(V,ℂ)) (x y : V),
‖actualResidual hα A b t s f x-actualResidual hα A b t s f y‖ ≤
C*‖f‖*(t.val-s.val)^(-7/8 : ℝ)*‖x-y‖^(1/4 : ℝ))
(j : Time T →ᵇ C₀(V,ℂ)) (t : Time T)
(hi : IntervalIntegrable (fun r => residualKernel hα A b hT₀ t r (unweighted j r)) volume 0 t.val)
(x y : V) :
‖(∫ r in 0..t.val, residualKernel hα A b hT₀ t r (unweighted j r)) x-
(∫ r in 0..t.val, residualKernel hα A b hT₀ t r (unweighted j r)) y‖ ≤
(C*‖j‖)*t.val^(-5/8 : ℝ)*(∫ s in 0..1, BetaWeights.density (3/4) (7/8) 1 s)*‖x-y‖^(1/4 : ℝ) := by
have hh := HolderIntegral.beta_holder (x := x) (y := y)
(fun r => residualKernel hα A b hT₀ t r (unweighted j r)) t.val t.property.1 hi
(3/4) (7/8) (by norm_num) (by norm_num) (C*‖j‖) (‖x-y‖^(1/4 : ℝ))
apply (show 1-(3/4 : ℝ)-7/8 = -5/8 by norm_num) ▸ hh
intro r hr
let s : Slab T := ⟨r,hr.1.le,hr.2.le.trans t.property.2⟩
have he : projIcc 0 T hT₀ r = s := projIcc_of_mem hT₀ s.property
have hu : ‖unweighted j r‖ ≤ r^(-3/4 : ℝ)*‖j‖ := by
let u : Time T := ⟨r,hr.1,hr.2.le.trans t.property.2⟩
change ‖unweighted j u.val‖ ≤ _
rw [unweighted_at_time,norm_smul,Real.norm_eq_abs,abs_of_nonneg (Real.rpow_nonneg hr.1.le _)]
exact mul_le_mul_of_nonneg_left (j.norm_coe_le_norm u) (Real.rpow_nonneg hr.1.le _)
simp only [residualKernel,ite_eq_left hr,he]
calc
_ ≤ C*‖unweighted j r‖*(t.val-r)^(-7/8 : ℝ)*‖x-y‖^(1/4 : ℝ) := hR t s hr.2 _ x y
_ ≤ C*(r^(-3/4 : ℝ)*‖j‖)*(t.val-r)^(-7/8 : ℝ)*‖x-y‖^(1/4 : ℝ) := by
gcongr
exact Real.rpow_nonneg (sub_nonneg.mpr hr.2.le) _
_ = _ := by unfold BetaWeights.density; ring_nf
lemma correction_holder (hT₀ : 0 ≤ T) (hT : T ≤ 1) (C : ℝ) (hC : 0 ≤ C)
(hR : ∀ (t : Time T) (s : Slab T), s.val<t.val → ∀ (f : C₀(V,ℂ)) (x y : V),
‖actualResidual hα A b t s f x-actualResidual hα A b t s f y‖ ≤
C*‖f‖*(t.val-s.val)^(-7/8 : ℝ)*‖x-y‖^(1/4 : ℝ))
(d : C₀(V,ℂ)) (l j : Time T →ᵇ C₀(V,ℂ)) (H : ℝ) (hH : 0 ≤ H)
(hl : ∀ t x y, ‖l t x-l t y‖ ≤ H*‖x-y‖^(1/4 : ℝ))
(hi : ∀ t : Time T, IntervalIntegrable
(fun r => residualKernel hα A b hT₀ t r (unweighted j r)) volume 0 t.val)
(hj : ∀ t : Time T, unweighted j t.val + ∫ r in 0..t.val,
residualKernel hα A b hT₀ t r (unweighted j r) = l t-actualResidual hα A b t (initial hT₀) d) :
∃ D : ℝ, 0 ≤ D ∧ ∀ t : Time T, ∀ x y,
‖unweighted j t.val x-unweighted j t.val y‖ ≤ D*t.val^(-7/8 : ℝ)*‖x-y‖^(1/4 : ℝ) := by
let Q := ∫ s in 0..1, BetaWeights.density (3/4) (7/8) 1 s
have hQ : 0 ≤ Q := intervalIntegral.integral_nonneg (by norm_num : (0:ℝ) ≤ 1)
(fun s hs => BetaWeights.density_nonneg _ _ _ _ hs.1 hs.2)
refine ⟨H+C*‖d‖+C*‖j‖*Q,by positivity,fun t x y => ?_⟩
let v := ∫ r in 0..t.val, residualKernel hα A b hT₀ t r (unweighted j r)
have he : unweighted j t.val = l t-actualResidual hα A b t (initial hT₀) d-v :=
eq_sub_of_add_eq (hj t)
have hd := hR t (initial hT₀) t.property.1 d x y
simp only [initial,sub_zero] at hd
have hv := holder_residual_integral hα A b hT₀ C hC hR j t (hi t) x y
have ht1 : t.val ≤ 1 := t.property.2.trans hT
have hp : 1 ≤ t.val^(-7/8 : ℝ) :=
Real.one_le_rpow_of_pos_of_le_one_of_nonpos t.property.1 ht1 (by norm_num)
have hq : t.val^(-5/8 : ℝ) ≤ t.val^(-7/8 : ℝ) :=
Real.rpow_le_rpow_of_exponent_ge t.property.1 ht1 (by norm_num)
rw [he]
change ‖(l t x-actualResidual hα A b t (initial hT₀) d x-v x)-
(l t y-actualResidual hα A b t (initial hT₀) d y-v y)‖ ≤ _
calc
_ = ‖(l t x-l t y)-(actualResidual hα A b t (initial hT₀) d x-
actualResidual hα A b t (initial hT₀) d y)-(v x-v y)‖ := by congr 1; ring
_ ≤ ‖l t x-l t y‖+‖actualResidual hα A b t (initial hT₀) d x-
actualResidual hα A b t (initial hT₀) d y‖+‖v x-v y‖ :=
(norm_sub_le _ _).trans (add_le_add (norm_sub_le _ _) le_rfl)
_ ≤ H*‖x-y‖^(1/4 : ℝ)+C*‖d‖*t.val^(-7/8 : ℝ)*‖x-y‖^(1/4 : ℝ)+
(C*‖j‖)*t.val^(-5/8 : ℝ)*Q*‖x-y‖^(1/4 : ℝ) := add_le_add (add_le_add (hl t x y) hd) hv
_ ≤ H*t.val^(-7/8 : ℝ)*‖x-y‖^(1/4 : ℝ)+C*‖d‖*t.val^(-7/8 : ℝ)*‖x-y‖^(1/4 : ℝ)+
(C*‖j‖)*t.val^(-7/8 : ℝ)*Q*‖x-y‖^(1/4 : ℝ) := by gcongr; exact le_mul_of_one_le_right hH hp
_ = _ := by ring
end ParametrixVolterra
namespace SourceFrozenRows
section ExistsRowZeroBound
open ScaledSchwartzConvolution SchwartzTimeScale
open scoped BoundedContinuousFunction ContDiff
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma exists_row_zero_bound (K : SchwartzMap V ℂ) (α β : ℝ) (hα : 0 < α) :
∃ C : ℝ, 0 ≤ C ∧ ∀ (A : V → ℝ) (_hA : Continuous A)
(_hAr : ∀ y, A y ∈ Icc α β) (r : ℝ) (_hr : 0 < r) (f : V →ᵇ ℂ) (x : V),
‖row K A r f 0 x‖ ≤ ‖f‖*C := by
let K' := SchwartzDerivatives.iterated K 0
obtain ⟨B,hB,_hw,hBp,hb⟩ := SourceFrozenCancellation.parameter_envelope K' (Module.finrank ℝ V+0) α β hα
refine ⟨∫ z, B z,integral_nonneg hBp,?_⟩
intro A hA hAr r hr f x
rw [row_normalized K A (fun y => hα.trans_le (hAr y).1) r hr,pow_zero,one_smul]
have hi : Integrable (fun z => f (x-r • z) •
atTime K' (Module.finrank ℝ V+0) (A (x-r • z)) z) := by
apply (hB.const_mul ‖f‖).mono'
· exact ((f.continuous.comp (continuous_const.sub (continuous_const.smul continuous_id))).smul
(SourceFrozenCancellation.continuous_variable K' _ (fun z => A (x-r • z))
(hA.comp (continuous_const.sub (continuous_const.smul continuous_id)))
(fun z => hα.trans_le (hAr _).1))).aestronglyMeasurable
· filter_upwards with z
rw [norm_smul]
exact mul_le_mul (f.norm_coe_le_norm _) (hb _ (hAr _) z) (norm_nonneg _) (norm_nonneg _)
change ‖∫ z, f (x-r • z) • atTime K' _ (A (x-r • z)) z‖ ≤ _
calc
_ ≤ ∫ z, ‖f (x-r • z) • atTime K' _ (A (x-r • z)) z‖ := norm_integral_le_integral_norm _
_ ≤ ∫ z, ‖f‖*B z := by
apply integral_mono hi.norm (hB.const_mul ‖f‖)
intro z
dsimp only
rw [norm_smul]
exact mul_le_mul (f.norm_coe_le_norm _) (hb _ (hAr _) z) (norm_nonneg _) (norm_nonneg _)
_ = _ := integral_const_mul ..
lemma continuous_row (K : SchwartzMap V ℂ) (A : V → ℝ) (hA : Continuous A)
(α β : ℝ) (hα : 0 < α) (hAr : ∀ y, A y ∈ Icc α β)
(r : ℝ) (hr : 0 < r) (f : V →ᵇ ℂ) (j : ℕ) : Continuous (row K A r f j) := by
rw [row_eq K A hA α β hα hAr r hr]
have hd : ContDiff ℝ (j+1) (value K A r f) :=
by simpa only [Nat.cast_add,Nat.cast_one] using
(contDiff_infty.mp (contDiff_value K A hA α β hα hAr r hr f) (j+1))
exact hd.continuous_iteratedFDeriv (by exact_mod_cast Nat.le_succ j)
lemma hasFDerivAt_row (K : SchwartzMap V ℂ) (A : V → ℝ) (hA : Continuous A)
(α β : ℝ) (hα : 0 < α) (hAr : ∀ y, A y ∈ Icc α β)
(r : ℝ) (hr : 0 < r) (f : V →ᵇ ℂ) (j : ℕ) (x : V) :
HasFDerivAt (row K A r f j)
((continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ)
(row K A r f (j+1) x)) x := by
rw [row_eq K A hA α β hα hAr r hr f j,
row_eq K A hA α β hα hAr r hr f (j+1)]
have hd : ContDiff ℝ (j+1) (value K A r f) :=
by simpa only [Nat.cast_add,Nat.cast_one] using
(contDiff_infty.mp (contDiff_value K A hA α β hα hAr r hr f) (j+1))
have hd' := (hd.differentiable_iteratedFDeriv (m := j) (by exact_mod_cast Nat.lt_succ_self j) x).hasFDerivAt
simpa only [fderiv_iteratedFDeriv, Function.comp_apply] using hd'
lemma stronglyMeasurable_time_row (K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(hA : Continuous (Function.uncurry A)) (f : ℝ → (V →ᵇ ℂ)) (hf : Continuous f)
(j : ℕ) (t : ℝ) (x : V) :
StronglyMeasurable (fun s : ℝ => row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x) := by
let c : ℝ × V → ℝ := fun p => (((t-p.1)^(1/4 : ℝ))*(A p.1 p.2)^(1/4 : ℝ))⁻¹
have hc : Measurable c := by
dsimp [c]
exact (((measurable_const.sub measurable_fst).pow_const _).mul
(hA.measurable.pow_const _)).inv
have he : Continuous (fun p : ℝ × V => f p.1 p.2) := by fun_prop
have hg := (SchwartzDerivatives.iterated K j).continuous
have hm : StronglyMeasurable (fun p : ℝ × V => f p.1 p.2 •
(c p ^ (Module.finrank ℝ V+j) • SchwartzDerivatives.iterated K j (c p • (x-p.2)))) :=
he.stronglyMeasurable.smul ((hc.pow_const _).stronglyMeasurable.smul
(hg.comp_stronglyMeasurable (hc.stronglyMeasurable.smul
(continuous_const.sub continuous_snd).stronglyMeasurable)))
exact hm.integral_prod_right'
omit [NormedAddCommGroup V] [InnerProductSpace ℝ V] [FiniteDimensional ℝ V]
[MeasurableSpace V] [BorelSpace V] in
lemma radius_weight (q : ℝ) (hq : 0 < q) (j : ℕ) (p : ℝ) :
((q^(1/4 : ℝ))⁻¹)^j*(q^(1/4 : ℝ))^p = q^((p-j)/4) := by
rw [inv_pow,← Real.rpow_natCast,← Real.rpow_mul hq.le,← Real.rpow_neg hq.le,
← Real.rpow_mul hq.le,← Real.rpow_add hq]
congr 1
ring
end ExistsRowZeroBound
section IntegrableOnLagRpow
open SchwartzTimeScale
open scoped BoundedContinuousFunction ContDiff
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma integrableOn_lag_rpow (t p : ℝ) (ht : 0 ≤ t) (hp : -1 < p) :
IntegrableOn (fun s : ℝ => (t-s)^p) (Ioo 0 t) := by
have hi := (intervalIntegral.intervalIntegrable_rpow' (a := 0) (b := t) hp).comp_sub_left t
simp only [sub_zero,sub_self] at hi
exact (intervalIntegrable_iff_integrableOn_Ioo_of_le ht).mp hi.symm
lemma exists_integrable_row_bound (K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(hA : Continuous (Function.uncurry A)) (α β : ℝ) (hα : 0 < α)
(hAr : ∀ s y, A s y ∈ Icc α β) (L : ℝ) (hL : 0 ≤ L)
(hAL : ∀ s x y, ‖A s x-A s y‖ ≤ L*‖x-y‖)
(f : ℝ → (V →ᵇ ℂ)) (hf : Continuous f)
(γ H t : ℝ) (ht : 0 ≤ t) (hγ : 0 < γ) (hγ1 : γ ≤ 1) (hH : 0 ≤ H)
(hhold : ∀ s ∈ Ioo 0 t, ∀ x y : V, ‖f s x-f s y‖ ≤ H*‖x-y‖^γ)
(j : ℕ) (hj4 : j ≤ 4) :
∃ b : ℝ → ℝ, IntegrableOn b (Ioo 0 t) ∧
∀ s ∈ Ioo 0 t, ∀ x : V,
‖row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x‖ ≤ b s := by
obtain ⟨M,hM⟩ := (isCompact_Icc (a := (0 : ℝ)) (b := t)).exists_bound_of_continuousOn hf.continuousOn
have hAs (s : ℝ) : Continuous (A s) := hA.comp (continuous_const.prodMk continuous_id)
by_cases hj : j = 0
· subst j
obtain ⟨C,hC,hb⟩ := exists_row_zero_bound K α β hα
refine ⟨fun _ => M*C,integrableOn_const (hs := measure_Ioo_lt_top.ne),?_⟩
intro s hs x
exact (hb (A s) (hAs s) (hAr s) _ (Real.rpow_pos_of_pos (sub_pos.mpr hs.2) _) (f s) x).trans
(mul_le_mul_of_nonneg_right (hM s ⟨hs.1.le,hs.2.le⟩) hC)
· obtain ⟨C,D,hC,hD,hb⟩ := exists_row_holder_bound K j (Nat.pos_of_ne_zero hj) α β hα γ hγ.le hγ1
have hp : -1 < (γ-j)/4 := by
have : (j : ℝ) ≤ 4 := by exact_mod_cast hj4
linarith
have hp' : -1 < ((1 : ℝ)-j)/4 := by
have : (j : ℝ) ≤ 4 := by exact_mod_cast hj4
linarith
refine ⟨fun s => H*C*(t-s)^((γ-j)/4)+M*L*D*(t-s)^(((1 : ℝ)-j)/4),
((integrableOn_lag_rpow t _ ht hp).const_mul _).add
((integrableOn_lag_rpow t _ ht hp').const_mul _),?_⟩
intro s hs x
have hq : 0 < t-s := sub_pos.mpr hs.2
have hr : 0 < (t-s)^(1/4 : ℝ) := Real.rpow_pos_of_pos hq _
have he := hb (A s) (hAs s) (hAr s) L hL (hAL s) (f s) H hH
(hhold s hs) _ hr x
have heq : (((t-s)^(1/4 : ℝ))⁻¹)^j *
(H*((t-s)^(1/4 : ℝ))^γ*C+‖f s‖*L*((t-s)^(1/4 : ℝ))*D) =
H*C*(t-s)^((γ-j)/4)+‖f s‖*L*D*(t-s)^(((1 : ℝ)-j)/4) := by
rw [mul_add]
have h1 := radius_weight (t-s) hq j γ
have h2 := radius_weight (t-s) hq j 1
rw [Real.rpow_one] at h2
calc
_ = H*C*((((t-s)^(1/4 : ℝ))⁻¹)^j*((t-s)^(1/4 : ℝ))^γ) +
‖f s‖*L*D*((((t-s)^(1/4 : ℝ))⁻¹)^j*(t-s)^(1/4 : ℝ)) := by ring
_ = _ := by rw [h1,h2]
rw [heq] at he
apply he.trans
exact add_le_add le_rfl (mul_le_mul_of_nonneg_right
(mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right
(hM s ⟨hs.1.le,hs.2.le⟩) hL) hD) (Real.rpow_nonneg hq.le _))
def integralRow (K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(f : ℝ → (V →ᵇ ℂ)) (t : ℝ) (j : ℕ) (x : V) : V [×j]→L[ℝ] ℂ :=
∫ s in Ioo 0 t, row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x
variable (K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(hA : Continuous (Function.uncurry A)) (α β : ℝ) (hα : 0 < α)
(hAr : ∀ s y, A s y ∈ Icc α β) (L : ℝ) (hL : 0 ≤ L)
(hAL : ∀ s x y, ‖A s x-A s y‖ ≤ L*‖x-y‖)
(f : ℝ → (V →ᵇ ℂ)) (hf : Continuous f)
(γ H t : ℝ) (ht : 0 ≤ t) (hγ : 0 < γ) (hγ1 : γ ≤ 1) (hH : 0 ≤ H)
(hhold : ∀ s ∈ Ioo 0 t, ∀ x y : V, ‖f s x-f s y‖ ≤ H*‖x-y‖^γ)
include hA hα hAr hf hAL hL hH ht hγ hγ1 hhold
lemma integrableOn_row (j : ℕ) (hj4 : j ≤ 4) (x : V) :
IntegrableOn (fun s => row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x) (Ioo 0 t) := by
obtain ⟨b,hi,hb⟩ := exists_integrable_row_bound K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold j hj4
exact hi.mono' (stronglyMeasurable_time_row K A hA f hf j t x).aestronglyMeasurable
(by filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs; exact hb s hs x)
lemma continuous_integralRow (j : ℕ) (hj4 : j ≤ 4) :
Continuous (integralRow K A f t j) := by
obtain ⟨b,hbi,hb⟩ := exists_integrable_row_bound K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold j hj4
apply continuous_of_dominated (bound := b)
· intro x
exact (stronglyMeasurable_time_row K A hA f hf j t x).aestronglyMeasurable
· intro x
filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
exact hb s hs x
· exact hbi
· filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
exact continuous_row K (A s) (hA.comp (continuous_const.prodMk continuous_id)) α β hα (hAr s)
_ (Real.rpow_pos_of_pos (sub_pos.mpr hs.2) _) (f s) j
lemma hasFDerivAt_integralRow (j : ℕ) (hj4 : j+1 ≤ 4) (x : V) :
HasFDerivAt (integralRow K A f t j)
((continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ)
(integralRow K A f t (j+1) x)) x := by
let C := (continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ).toContinuousLinearEquiv.toContinuousLinearMap
let : ContinuousENorm (V →L[ℝ] V [×j]→L[ℝ] ℂ) :=
@SeminormedAddGroup.toContinuousENorm (V →L[ℝ] V [×j]→L[ℝ] ℂ) inferInstance
have hi := integrableOn_row K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold (j+1) hj4 x
have hcomm := ContinuousLinearMap.integral_comp_comm (𝕜 := ℝ)
(E := V [×(j+1)]→L[ℝ] ℂ) (Fₗ := V →L[ℝ] V [×j]→L[ℝ] ℂ) C hi
change HasFDerivAt (fun x => ∫ s in Ioo 0 t, row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x)
(C (∫ s in Ioo 0 t, row K (A s) ((t-s)^(1/4 : ℝ)) (f s) (j+1) x)) x
rw [← hcomm]
obtain ⟨b,hbi,hb⟩ := exists_integrable_row_bound K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold (j+1) hj4
apply hasFDerivAt_integral_of_dominated_of_fderiv_le (s := univ)
(F' := fun x s => C (row K (A s) ((t-s)^(1/4 : ℝ)) (f s) (j+1) x)) (bound := b) (univ_mem : univ ∈ 𝓝 x)
· exact Eventually.of_forall fun z => (stronglyMeasurable_time_row K A hA f hf j t z).aestronglyMeasurable
· exact integrableOn_row K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold j (by omega) x
· exact (C.continuous.comp_stronglyMeasurable
(stronglyMeasurable_time_row K A hA f hf (j+1) t x)).aestronglyMeasurable
· filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs z _
change ‖(continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ)
(row K (A s) ((t-s)^(1/4 : ℝ)) (f s) (j+1) z)‖ ≤ b s
rw [LinearIsometryEquiv.norm_map]
exact hb s hs z
· exact hbi
· filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs z _
exact hasFDerivAt_row K (A s) (hA.comp (continuous_const.prodMk continuous_id)) α β hα (hAr s)
_ (Real.rpow_pos_of_pos (sub_pos.mpr hs.2) _) (f s) j z
lemma contDiff_integralRow (j n : ℕ) (hjn : j+n ≤ 4) :
ContDiff ℝ n (integralRow K A f t j) := by
induction n generalizing j with
| zero =>
rw [Nat.cast_zero, contDiff_zero]
exact continuous_integralRow K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold j (by omega)
| succ n ih =>
rw [Nat.cast_add, Nat.cast_one, contDiff_succ_iff_hasFDerivAt]
let C : (V [×(j+1)]→L[ℝ] ℂ) →L[ℝ] (V →L[ℝ] V [×j]→L[ℝ] ℂ) := (continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ).toContinuousLinearEquiv.toContinuousLinearMap
refine ⟨fun x => C (integralRow K A f t (j+1) x), ?_, ?_⟩
· exact contDiff_const.clm_apply (ih (j+1) (by omega))
· intro x
exact hasFDerivAt_integralRow K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold j (by omega) x
end IntegrableOnLagRpow
section Duhamel
open scoped BoundedContinuousFunction ContDiff
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
def duhamel (K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(f : ℝ → (V →ᵇ ℂ)) (t : ℝ) (x : V) : ℂ :=
∫ s in Ioo 0 t, value K (A s) ((t-s)^(1/4 : ℝ)) (f s) x
variable (K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(hA : Continuous (Function.uncurry A)) (α β : ℝ) (hα : 0 < α)
(hAr : ∀ s y, A s y ∈ Icc α β) (L : ℝ) (hL : 0 ≤ L)
(hAL : ∀ s x y, ‖A s x-A s y‖ ≤ L*‖x-y‖)
(f : ℝ → (V →ᵇ ℂ)) (hf : Continuous f)
(γ H t : ℝ) (ht : 0 ≤ t) (hγ : 0 < γ) (hγ1 : γ ≤ 1) (hH : 0 ≤ H)
(hhold : ∀ s ∈ Ioo 0 t, ∀ x y : V, ‖f s x-f s y‖ ≤ H*‖x-y‖^γ)
include hA hα hAr hf hAL hL hH ht hγ hγ1 hhold
lemma duhamel_eq_integralRow_zero (x : V) : duhamel K A f t x =
(continuousMultilinearCurryFin0 ℝ V ℂ) (integralRow K A f t 0 x) := by
let C := (continuousMultilinearCurryFin0 ℝ V ℂ).toContinuousLinearEquiv.toContinuousLinearMap
have hc := ContinuousLinearMap.integral_comp_comm (𝕜 := ℝ)
(E := V [×0]→L[ℝ] ℂ) (Fₗ := ℂ) C
(integrableOn_row K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold 0 (by omega) x)
change (∫ s in Ioo 0 t, value K (A s) ((t-s)^(1/4 : ℝ)) (f s) x) =
C (∫ s in Ioo 0 t, row K (A s) ((t-s)^(1/4 : ℝ)) (f s) 0 x)
rw [← hc]
apply integral_congr_ae
filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
rw [row_eq K (A s) (hA.comp (continuous_const.prodMk continuous_id)) α β hα (hAr s)
_ (Real.rpow_pos_of_pos (sub_pos.mpr hs.2) _),iteratedFDeriv_zero_eq_comp]
exact (LinearIsometryEquiv.apply_symm_apply _ _).symm
lemma contDiff_duhamel : ContDiff ℝ 4 (duhamel K A f t) := by
have he : duhamel K A f t = fun x => (continuousMultilinearCurryFin0 ℝ V ℂ)
(integralRow K A f t 0 x) :=
funext (duhamel_eq_integralRow_zero K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold)
rw [he]
let C : (V [×0]→L[ℝ] ℂ) →L[ℝ] ℂ :=
(continuousMultilinearCurryFin0 ℝ V ℂ).toContinuousLinearEquiv.toContinuousLinearMap
change ContDiff ℝ 4 (fun x => C (integralRow K A f t 0 x))
exact contDiff_const.clm_apply
(contDiff_integralRow K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold 0 4 (by omega))
lemma iteratedFDeriv_duhamel (j : ℕ) (hj : j ≤ 4) :
iteratedFDeriv ℝ j (duhamel K A f t) = integralRow K A f t j := by
induction j with
| zero =>
funext x
rw [iteratedFDeriv_zero_eq_comp]
change (continuousMultilinearCurryFin0 ℝ V ℂ).symm (duhamel K A f t x) = _
rw [duhamel_eq_integralRow_zero K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold,
LinearIsometryEquiv.symm_apply_apply]
| succ j ih =>
rw [iteratedFDeriv_succ_eq_comp_left,ih (by omega)]
funext x
dsimp only [Function.comp_apply]
rw [(hasFDerivAt_integralRow K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold j hj x).fderiv]
exact LinearIsometryEquiv.symm_apply_apply _ _
lemma exists_norm_iteratedFDeriv_duhamel_bound (j : ℕ) (hj : j ≤ 4) :
∃ C : ℝ, ∀ x, ‖iteratedFDeriv ℝ j (duhamel K A f t) x‖ ≤ C := by
obtain ⟨b,hi,hb⟩ := exists_integrable_row_bound K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold j hj
refine ⟨∫ s in Ioo 0 t, b s,fun x => ?_⟩
rw [iteratedFDeriv_duhamel K A hA α β hα hAr L hL hAL f hf γ H t ht hγ hγ1 hH hhold j hj]
apply norm_integral_le_of_norm_le hi
filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
exact hb s hs x
end Duhamel
open ScaledSchwartzConvolution SchwartzTimeScale
open scoped BoundedContinuousFunction ContDiff
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
lemma stronglyMeasurable_time_row_of_stronglyMeasurable
(K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(hA : Continuous (Function.uncurry A)) (f : ℝ → (V →ᵇ ℂ))
(hf : StronglyMeasurable f) (j : ℕ) (t : ℝ) (x : V) :
StronglyMeasurable (fun s : ℝ => row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x) := by
let c : ℝ × V → ℝ := fun p => (((t-p.1)^(1/4 : ℝ))*(A p.1 p.2)^(1/4 : ℝ))⁻¹
have hc : Measurable c := by
dsimp [c]
exact (((measurable_const.sub measurable_fst).pow_const _).mul
(hA.measurable.pow_const _)).inv
have he' : Continuous (fun p : (V →ᵇ ℂ) × V => p.1 p.2) := by fun_prop
have he : StronglyMeasurable (fun p : ℝ × V => f p.1 p.2) :=
he'.comp_stronglyMeasurable
((hf.comp_measurable measurable_fst).prodMk continuous_snd.stronglyMeasurable)
have hg := (SchwartzDerivatives.iterated K j).continuous
have hm : StronglyMeasurable (fun p : ℝ × V => f p.1 p.2 •
(c p ^ (Module.finrank ℝ V+j) • SchwartzDerivatives.iterated K j (c p • (x-p.2)))) :=
he.smul ((hc.pow_const _).stronglyMeasurable.smul
(hg.comp_stronglyMeasurable (hc.stronglyMeasurable.smul
(continuous_const.sub continuous_snd).stronglyMeasurable)))
exact hm.integral_prod_right'
lemma exists_integrable_row_bound_weighted (K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(hA : Continuous (Function.uncurry A)) (α β : ℝ) (hα : 0 < α)
(hAr : ∀ s y, A s y ∈ Icc α β) (L : ℝ) (hL : 0 ≤ L)
(hAL : ∀ s x y, ‖A s x-A s y‖ ≤ L*‖x-y‖)
(f : ℝ → (V →ᵇ ℂ)) (σ τ M H γ t : ℝ)
(hσ : σ < 1) (hτ : τ < 1) (_hM : 0 ≤ M) (hH : 0 ≤ H)
(ht : 0 < t) (hγ : 0 < γ) (hγ1 : γ ≤ 1)
(hfn : ∀ s ∈ Ioo 0 t, ‖f s‖ ≤ M*s^(-σ))
(hhold : ∀ s ∈ Ioo 0 t, ∀ x y : V, ‖f s x-f s y‖ ≤ (H*s^(-τ))*‖x-y‖^γ)
(j : ℕ) (hj4 : j ≤ 4) :
∃ b : ℝ → ℝ, IntegrableOn b (Ioo 0 t) ∧
∀ s ∈ Ioo 0 t, ∀ x : V,
‖row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x‖ ≤ b s := by
have hAs (s : ℝ) : Continuous (A s) := hA.comp (continuous_const.prodMk continuous_id)
by_cases hj : j = 0
· subst j
obtain ⟨C,hC,hb⟩ := exists_row_zero_bound K α β hα
have hi := (intervalIntegrable_iff_integrableOn_Ioo_of_le ht.le).mp
(BetaWeights.intervalIntegrable σ 0 hσ (by norm_num) t ht)
refine ⟨fun s => (M*C)*BetaWeights.density σ 0 t s,hi.const_mul _,?_⟩
intro s hs x
have hh := (hb (A s) (hAs s) (hAr s) ((t-s)^(1/4 : ℝ)) (Real.rpow_pos_of_pos (sub_pos.mpr hs.2) _) (f s) x).trans
(mul_le_mul_of_nonneg_right (hfn s hs) hC)
simpa only [BetaWeights.density,neg_zero,Real.rpow_zero,mul_one,mul_assoc,mul_comm,mul_left_comm] using hh
· obtain ⟨C,D,hC,hD,hb⟩ := exists_row_holder_bound K j (Nat.pos_of_ne_zero hj) α β hα γ hγ.le hγ1
have hp : ((j : ℝ)-γ)/4 < 1 := by
have : (j : ℝ) ≤ 4 := by exact_mod_cast hj4
linarith
have hp' : ((j : ℝ)-1)/4 < 1 := by
have : (j : ℝ) ≤ 4 := by exact_mod_cast hj4
linarith
have hi := (intervalIntegrable_iff_integrableOn_Ioo_of_le ht.le).mp
(BetaWeights.intervalIntegrable τ ((j-γ)/4) hτ hp t ht)
have hi' := (intervalIntegrable_iff_integrableOn_Ioo_of_le ht.le).mp
(BetaWeights.intervalIntegrable σ ((j-1)/4) hσ hp' t ht)
refine ⟨fun s => (H*C)*BetaWeights.density τ ((j-γ)/4) t s+
(M*L*D)*BetaWeights.density σ ((j-1)/4) t s,
(hi.const_mul _).add (hi'.const_mul _),?_⟩
intro s hs x
have hq : 0 < t-s := sub_pos.mpr hs.2
have hr : 0 < (t-s)^(1/4 : ℝ) := Real.rpow_pos_of_pos hq _
have hsτ : 0 ≤ H*s^(-τ) := mul_nonneg hH (Real.rpow_nonneg hs.1.le _)
have he := hb (A s) (hAs s) (hAr s) L hL (hAL s) (f s) (H*s^(-τ)) hsτ
(hhold s hs) _ hr x
have heq : (((t-s)^(1/4 : ℝ))⁻¹)^j *
((H*s^(-τ))*((t-s)^(1/4 : ℝ))^γ*C+‖f s‖*L*((t-s)^(1/4 : ℝ))*D) =
(H*s^(-τ))*C*(t-s)^((γ-j)/4)+‖f s‖*L*D*(t-s)^(((1 : ℝ)-j)/4) := by
rw [mul_add]
have h1 := radius_weight (t-s) hq j γ
have h2 := radius_weight (t-s) hq j 1
rw [Real.rpow_one] at h2
calc
_ = (H*s^(-τ))*C*((((t-s)^(1/4 : ℝ))⁻¹)^j*((t-s)^(1/4 : ℝ))^γ) +
‖f s‖*L*D*((((t-s)^(1/4 : ℝ))⁻¹)^j*(t-s)^(1/4 : ℝ)) := by ring
_ = _ := by rw [h1,h2]
rw [heq] at he
apply he.trans
have hn := mul_le_mul_of_nonneg_right
(mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right (hfn s hs) hL) hD)
(Real.rpow_nonneg hq.le (((1 : ℝ)-j)/4))
calc
_ ≤ (H*s^(-τ))*C*(t-s)^((γ-j)/4)+(M*s^(-σ))*L*D*(t-s)^(((1 : ℝ)-j)/4) :=
add_le_add le_rfl hn
_ = _ := by
unfold BetaWeights.density
rw [show -((↑j-γ)/4) = (γ-j)/4 by ring,show -(((j:ℝ)-1)/4) = ((1:ℝ)-j)/4 by ring]
ring
end SourceFrozenRows
namespace WeightedSourceFrozenRows
open SourceFrozenRows
open scoped BoundedContinuousFunction ContDiff
variable {V : Type} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
[FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]
variable (K : SchwartzMap V ℂ) (A : ℝ → V → ℝ)
(hA : Continuous (Function.uncurry A)) (α β : ℝ) (hα : 0 < α)
(hAr : ∀ s y, A s y ∈ Icc α β) (L : ℝ) (hL : 0 ≤ L)
(hAL : ∀ s x y, ‖A s x-A s y‖ ≤ L*‖x-y‖)
(f : ℝ → (V →ᵇ ℂ)) (hf : StronglyMeasurable f) (σ τ M H γ t : ℝ)
(hσ : σ < 1) (hτ : τ < 1) (hM : 0 ≤ M) (hH : 0 ≤ H)
(ht : 0 < t) (hγ : 0 < γ) (hγ1 : γ ≤ 1)
(hfn : ∀ s ∈ Ioo 0 t, ‖f s‖ ≤ M*s^(-σ))
(hhold : ∀ s ∈ Ioo 0 t, ∀ x y : V, ‖f s x-f s y‖ ≤ (H*s^(-τ))*‖x-y‖^γ)
include hA hα hAr hf hAL hL hH ht hγ hγ1 hhold hσ hτ hM hfn
lemma integrableOn_row (j : ℕ) (hj4 : j ≤ 4) (x : V) :
IntegrableOn (fun s => row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x) (Ioo 0 t) := by
obtain ⟨b,hi,hb⟩ := SourceFrozenRows.exists_integrable_row_bound_weighted K A hA α β hα hAr L hL hAL f σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold j hj4
exact hi.mono' (stronglyMeasurable_time_row_of_stronglyMeasurable K A hA f hf j t x).aestronglyMeasurable
(by filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs; exact hb s hs x)
lemma continuous_integralRow (j : ℕ) (hj4 : j ≤ 4) :
Continuous (integralRow K A f t j) := by
obtain ⟨b,hbi,hb⟩ := SourceFrozenRows.exists_integrable_row_bound_weighted K A hA α β hα hAr L hL hAL f σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold j hj4
apply continuous_of_dominated (bound := b)
· intro x
exact (stronglyMeasurable_time_row_of_stronglyMeasurable K A hA f hf j t x).aestronglyMeasurable
· intro x
filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
exact hb s hs x
· exact hbi
· filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
exact continuous_row K (A s) (hA.comp (continuous_const.prodMk continuous_id)) α β hα (hAr s)
_ (Real.rpow_pos_of_pos (sub_pos.mpr hs.2) _) (f s) j
lemma hasFDerivAt_integralRow (j : ℕ) (hj4 : j+1 ≤ 4) (x : V) :
HasFDerivAt (integralRow K A f t j)
((continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ)
(integralRow K A f t (j+1) x)) x := by
let C := (continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ).toContinuousLinearEquiv.toContinuousLinearMap
let : ContinuousENorm (V →L[ℝ] V [×j]→L[ℝ] ℂ) :=
@SeminormedAddGroup.toContinuousENorm (V →L[ℝ] V [×j]→L[ℝ] ℂ) inferInstance
have hi := integrableOn_row K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold (j+1) hj4 x
have hcomm := ContinuousLinearMap.integral_comp_comm (𝕜 := ℝ)
(E := V [×(j+1)]→L[ℝ] ℂ) (Fₗ := V →L[ℝ] V [×j]→L[ℝ] ℂ) C hi
change HasFDerivAt (fun x => ∫ s in Ioo 0 t, row K (A s) ((t-s)^(1/4 : ℝ)) (f s) j x)
(C (∫ s in Ioo 0 t, row K (A s) ((t-s)^(1/4 : ℝ)) (f s) (j+1) x)) x
rw [← hcomm]
obtain ⟨b,hbi,hb⟩ := SourceFrozenRows.exists_integrable_row_bound_weighted K A hA α β hα hAr L hL hAL f σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold (j+1) hj4
apply hasFDerivAt_integral_of_dominated_of_fderiv_le (s := univ)
(F' := fun x s => C (row K (A s) ((t-s)^(1/4 : ℝ)) (f s) (j+1) x)) (bound := b) (univ_mem : univ ∈ 𝓝 x)
· exact Eventually.of_forall fun z => (stronglyMeasurable_time_row_of_stronglyMeasurable K A hA f hf j t z).aestronglyMeasurable
· exact integrableOn_row K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold j (by omega) x
· exact (C.continuous.comp_stronglyMeasurable
(stronglyMeasurable_time_row_of_stronglyMeasurable K A hA f hf (j+1) t x)).aestronglyMeasurable
· filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs z _
change ‖(continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ)
(row K (A s) ((t-s)^(1/4 : ℝ)) (f s) (j+1) z)‖ ≤ b s
rw [LinearIsometryEquiv.norm_map]
exact hb s hs z
· exact hbi
· filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs z _
exact hasFDerivAt_row K (A s) (hA.comp (continuous_const.prodMk continuous_id)) α β hα (hAr s)
_ (Real.rpow_pos_of_pos (sub_pos.mpr hs.2) _) (f s) j z
lemma contDiff_integralRow (j n : ℕ) (hjn : j+n ≤ 4) :
ContDiff ℝ n (integralRow K A f t j) := by
induction n generalizing j with
| zero =>
rw [Nat.cast_zero, contDiff_zero]
exact continuous_integralRow K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold j (by omega)
| succ n ih =>
rw [Nat.cast_add, Nat.cast_one, contDiff_succ_iff_hasFDerivAt]
let C : (V [×(j+1)]→L[ℝ] ℂ) →L[ℝ] (V →L[ℝ] V [×j]→L[ℝ] ℂ) := (continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (j+1) => V) ℂ).toContinuousLinearEquiv.toContinuousLinearMap
refine ⟨fun x => C (integralRow K A f t (j+1) x), ?_, ?_⟩
· exact contDiff_const.clm_apply (ih (j+1) (by omega))
· intro x
exact hasFDerivAt_integralRow K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold j (by omega) x
lemma duhamel_eq_integralRow_zero (x : V) : duhamel K A f t x =
(continuousMultilinearCurryFin0 ℝ V ℂ) (integralRow K A f t 0 x) := by
let C := (continuousMultilinearCurryFin0 ℝ V ℂ).toContinuousLinearEquiv.toContinuousLinearMap
have hc := ContinuousLinearMap.integral_comp_comm (𝕜 := ℝ)
(E := V [×0]→L[ℝ] ℂ) (Fₗ := ℂ) C
(integrableOn_row K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold 0 (by omega) x)
change (∫ s in Ioo 0 t, value K (A s) ((t-s)^(1/4 : ℝ)) (f s) x) =
C (∫ s in Ioo 0 t, row K (A s) ((t-s)^(1/4 : ℝ)) (f s) 0 x)
rw [← hc]
apply integral_congr_ae
filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
rw [row_eq K (A s) (hA.comp (continuous_const.prodMk continuous_id)) α β hα (hAr s)
_ (Real.rpow_pos_of_pos (sub_pos.mpr hs.2) _),iteratedFDeriv_zero_eq_comp]
exact (LinearIsometryEquiv.apply_symm_apply _ _).symm
lemma contDiff_duhamel : ContDiff ℝ 4 (duhamel K A f t) := by
have he : duhamel K A f t = fun x => (continuousMultilinearCurryFin0 ℝ V ℂ)
(integralRow K A f t 0 x) :=
funext (duhamel_eq_integralRow_zero K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold)
rw [he]
let C : (V [×0]→L[ℝ] ℂ) →L[ℝ] ℂ :=
(continuousMultilinearCurryFin0 ℝ V ℂ).toContinuousLinearEquiv.toContinuousLinearMap
change ContDiff ℝ 4 (fun x => C (integralRow K A f t 0 x))
exact contDiff_const.clm_apply
(contDiff_integralRow K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold 0 4 (by omega))
lemma iteratedFDeriv_duhamel (j : ℕ) (hj : j ≤ 4) :
iteratedFDeriv ℝ j (duhamel K A f t) = integralRow K A f t j := by
induction j with
| zero =>
funext x
rw [iteratedFDeriv_zero_eq_comp]
change (continuousMultilinearCurryFin0 ℝ V ℂ).symm (duhamel K A f t x) = _
rw [duhamel_eq_integralRow_zero K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold,
LinearIsometryEquiv.symm_apply_apply]
| succ j ih =>
rw [iteratedFDeriv_succ_eq_comp_left,ih (by omega)]
funext x
dsimp only [Function.comp_apply]
rw [(hasFDerivAt_integralRow K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold j hj x).fderiv]
exact LinearIsometryEquiv.symm_apply_apply _ _
lemma exists_norm_iteratedFDeriv_duhamel_bound (j : ℕ) (hj : j ≤ 4) :
∃ C : ℝ, ∀ x, ‖iteratedFDeriv ℝ j (duhamel K A f t) x‖ ≤ C := by
obtain ⟨b,hi,hb⟩ := SourceFrozenRows.exists_integrable_row_bound_weighted K A hA α β hα hAr L hL hAL f σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold j hj
refine ⟨∫ s in Ioo 0 t, b s,fun x => ?_⟩
rw [iteratedFDeriv_duhamel K A hA α β hα hAr L hL hAL f hf σ τ M H γ t hσ hτ hM hH ht hγ hγ1 hfn hhold j hj]
apply norm_integral_le_of_norm_le hi
filter_upwards [ae_restrict_mem measurableSet_Ioo] with s hs
exact hb s hs x
end WeightedSourceFrozenRows
end
end OAI
import Mathlib
namespace OAI
noncomputable section
open scoped Topology SchwartzMap FourierTransform ContDiff
open Set Filter MeasureTheory
namespace BiharmonicKernel
lemma gaussian_moment_bound (n : ℕ) :
∃ C : ℝ, ∀ x : ℝ, |x|^n * Real.exp (-(x^2/2)) ≤ C := by
refine ⟨max 1 ((2:ℝ)^n * (n.factorial : ℝ)), fun x => ?_⟩
by_cases hx : |x| ≤ 1
· apply le_trans _ (le_max_left _ _)
have he : Real.exp (-(x^2/2)) ≤ 1 := Real.exp_le_one_iff.mpr (neg_nonpos.mpr (by positivity))
exact (mul_le_of_le_one_left (Real.exp_nonneg _)
(pow_le_one₀ (abs_nonneg x) hx)).trans he
· have hx1 : 1 ≤ |x| := (lt_of_not_ge hx).le
have hxx : |x| ≤ x^2 := by nlinarith [sq_abs x]
have hf : (x^2/2)^n ≤ Real.exp (x^2/2)*(n.factorial : ℝ) :=
(div_le_iff₀ (show (0:ℝ)<(n.factorial : ℝ) by positivity)).mp
(Real.pow_div_factorial_le_exp _ (by positivity) n)
have hfm : (x^2/2)^n * Real.exp (-(x^2/2)) ≤ (n.factorial : ℝ) := by
calc
_ ≤ (Real.exp (x^2/2)*(n.factorial : ℝ))*Real.exp (-(x^2/2)) :=
mul_le_mul_of_nonneg_right hf (Real.exp_nonneg _)
_ = (n.factorial : ℝ) := by rw [mul_right_comm, ← Real.exp_add, add_neg_cancel, Real.exp_zero, one_mul]
calc
_ ≤ (x^2)^n * Real.exp (-(x^2/2)) := by gcongr
_ = (2:ℝ)^n *((x^2/2)^n * Real.exp (-(x^2/2))) := by
rw [← mul_assoc, ← mul_pow]
congr 2
ring
_ ≤ (2:ℝ)^n * (n.factorial : ℝ) := mul_le_mul_of_nonneg_left hfm (by positivity)
_ ≤ _ := le_max_right _ _
lemma polynomial_gaussian_bound (p : Polynomial ℝ) (k : ℕ) :
∃ C : ℝ, ∀ x : ℝ, |x|^k * |p.eval x| * Real.exp (-(x^2/2)) ≤ C := by
induction p using Polynomial.induction_on' with
| add p q hp hq =>
obtain ⟨Cp,hp⟩ := hp
obtain ⟨Cq,hq⟩ := hq
refine ⟨Cp+Cq, fun x => ?_⟩
calc
_ ≤ |x|^k*(|p.eval x|+|q.eval x|)*Real.exp (-(x^2/2)) := by
rw [Polynomial.eval_add]
gcongr
exact abs_add_le _ _
_ = |x|^k*|p.eval x| *Real.exp (-(x^2/2))+
|x|^k*|q.eval x| *Real.exp (-(x^2/2)) := by ring
_ ≤ Cp+Cq := add_le_add (hp x) (hq x)
| monomial n a =>
obtain ⟨C,hC⟩ := gaussian_moment_bound (k+n)
refine ⟨|a| *C, fun x => ?_⟩
calc
_ = |a| *(|x|^(k+n)*Real.exp (-(x^2/2))) := by
simp only [Polynomial.eval_monomial, abs_mul, abs_pow, pow_add]
ring
_ ≤ |a| *C := mul_le_mul_of_nonneg_left (hC x) (abs_nonneg _)
def gaussian : SchwartzMap ℝ ℝ where
toFun x := Real.exp (-(x^2/2))
smooth' := by fun_prop
decay' k n := by
obtain ⟨C,hC⟩ := polynomial_gaussian_bound
((Polynomial.hermite n).map (algebraMap ℤ ℝ)) k
refine ⟨C,fun x => ?_⟩
rw [norm_iteratedFDeriv_eq_norm_iteratedDeriv, iteratedDeriv_eq_iterate,
Polynomial.deriv_gaussian_eq_hermite_mul_gaussian]
simpa only [norm_mul, norm_pow, norm_neg, norm_one, one_pow, one_mul,
Real.norm_eq_abs, abs_of_pos (Real.exp_pos _), Polynomial.eval_map,
Polynomial.aeval_def, mul_assoc] using hC x
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
omit [InnerProductSpace ℝ V] in
lemma norm_le_quadratic (q : ℝ) (hq : 0 < q) :
∃ (k : ℕ) (C : ℝ), ∀ x : V, ‖x‖ ≤ C * (1+‖q*‖x‖^2‖)^k := by
refine ⟨1,1+q⁻¹,fun x => ?_⟩
rw [pow_one, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
have he : (1+q⁻¹)*(1+q*‖x‖^2) = 1+‖x‖^2+q*‖x‖^2+q⁻¹ := by
field_simp
ring
rw [he]
nlinarith [sq_nonneg (‖x‖-1/2), inv_pos.mpr hq, mul_nonneg hq.le (sq_nonneg ‖x‖)]
def multiplier (b : ℝ) (hb : 0 < b) : SchwartzMap V ℂ :=
SchwartzMap.postcompCLM Complex.ofRealCLM
(SchwartzMap.compCLM ℝ
(g := fun x : V => Real.sqrt (2*b)*‖x‖^2) (by fun_prop)
(norm_le_quadratic _ (Real.sqrt_pos.mpr (by positivity))) gaussian)
@[simp] lemma multiplier_apply (b : ℝ) (hb : 0 < b) (x : V) :
multiplier b hb x = (Real.exp (-b*‖x‖^4) : ℂ) := by
change (Real.exp (-((Real.sqrt (2*b)*‖x‖^2)^2/2)) : ℂ) = _
congr 2
rw [mul_pow, Real.sq_sqrt (by positivity)]
ring
variable [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]