introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
11.2 kB
import Mathlib
namespace OAI
section
noncomputable section
open Set Filter Topology
namespace ElasticityCompact
variable {A P F : Type*} [TopologicalSpace A] [CompactSpace A]
[NormedAddCommGroup P] [NormedSpace ℝ P]
[NormedAddCommGroup F] [NormedSpace ℝ F]
/-- Interchanging a compact continuous-variable slot and a bounded linear slot. -/
def flipLinear (q : C(A,P →L[ℝ] F)) : P →L[ℝ] C(A,F) :=
LinearMap.mkContinuous
({ toFun := fun p => ⟨fun a => q a p,q.continuous.clm_apply continuous_const⟩
map_add' := fun v w => by ext a; exact map_add (q a) v w
map_smul' := fun c v => by ext a; exact map_smul (q a) c v } : P →ₗ[ℝ] C(A,F))
‖q‖ (fun p => by
change ‖(⟨fun a => q a p,q.continuous.clm_apply continuous_const⟩ : C(A,F))‖ ≤ ‖q‖ * ‖p‖
apply (ContinuousMap.norm_le _ (mul_nonneg (norm_nonneg q) (norm_nonneg p))).mpr
intro a
exact (q a).le_opNorm p |>.trans (mul_le_mul_of_nonneg_right
(q.norm_coe_le_norm a) (norm_nonneg p)))
lemma flipLinear_apply (q : C(A,P →L[ℝ] F)) (p : P) (a : A) : flipLinear q p a=q a p := rfl
def flipCLM : C(A,P →L[ℝ] F) →L[ℝ] (P →L[ℝ] C(A,F)) :=
LinearMap.mkContinuous
({ toFun := fun q : C(A,P →L[ℝ] F) => flipLinear q
map_add' := fun q r => by ext p a; rfl
map_smul' := fun c q => by ext p a; rfl } :
C(A,P →L[ℝ] F) →ₗ[ℝ] (P →L[ℝ] C(A,F))) 1 (fun q : C(A,P →L[ℝ] F) => by
change ‖flipLinear q‖ ≤ 1 * ‖q‖
rw [one_mul]
apply ContinuousLinearMap.opNorm_le_bound (flipLinear q) (norm_nonneg q)
intro p
exact
(ContinuousMap.norm_le (flipLinear q p) (mul_nonneg (norm_nonneg q) (norm_nonneg p))).mpr
(fun a => (q a).le_opNorm p |>.trans
(mul_le_mul_of_nonneg_right (q.norm_coe_le_norm a) (norm_nonneg p))))
lemma hasFDerivAt_compact (f : P → C(A,F)) (q : P → C(A,P →L[ℝ] F))
(hq : Continuous q)
(hd : ∀ p a, HasFDerivAt (fun p => f p a) (q p a) p) (p : P) :
HasFDerivAt f (flipLinear (q p)) p := by
rw [hasFDerivAt_iff_isLittleO,Asymptotics.isLittleO_iff]
intro ε hε
obtain ⟨r,hr,he⟩ := (Metric.continuousAt_iff (f := q) (a := p)).mp hq.continuousAt ε hε
filter_upwards [Metric.ball_mem_nhds p hr] with y hy
apply (ContinuousMap.norm_le _ (mul_nonneg hε.le (norm_nonneg _))).mpr
intro a
have hb (z : P) (hz : z∈Metric.ball p r) : ‖q z a-q p a‖ ≤ ε := by
have hh := le_of_lt (he hz)
simpa only [dist_eq_norm] using (ContinuousMap.dist_apply_le_dist (f := q z) (g := q p) a).trans hh
exact Convex.norm_image_sub_le_of_norm_hasFDerivWithin_le'
(fun z _ => (hd z a).hasFDerivWithinAt) hb (convex_ball p r)
(Metric.mem_ball_self hr) hy
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
def curryCompact (f : P × E → F) (hf : Continuous f) (j : A → E) (hj : Continuous j) :
P → C(A,F) :=
fun p => ⟨fun a => f (p,j a),hf.comp (continuous_const.prodMk hj)⟩
omit [CompactSpace A] [NormedSpace ℝ P] [NormedSpace ℝ F] [NormedSpace ℝ E] in
lemma curryCompact_apply (f : P × E → F) (hf : Continuous f) (j : A → E) (hj : Continuous j)
(p : P) (a : A) : curryCompact f hf j hj p a=f (p,j a) := rfl
omit [CompactSpace A] [NormedSpace ℝ P] [NormedSpace ℝ F] [NormedSpace ℝ E] in
lemma curryCompact_continuous (f : P × E → F) (hf : Continuous f) (j : A → E) (hj : Continuous j) :
Continuous (curryCompact f hf j hj) := by
apply ContinuousMap.continuous_of_continuous_uncurry
exact hf.comp (continuous_fst.prodMk (hj.comp continuous_snd))
lemma curryCompact_hasFDerivAt (f : P × E → F) (hf : ContDiff ℝ (⊤ : ℕ∞) f)
(j : A → E) (hj : Continuous j) (p : P) :
HasFDerivAt (curryCompact f hf.continuous j hj)
(flipLinear ⟨fun a => (fderiv ℝ f (p,j a)).comp (ContinuousLinearMap.inl ℝ P E),
((hf.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).continuous.comp (continuous_const.prodMk hj)).clm_comp continuous_const⟩) p := by
let q : P → C(A,P →L[ℝ] F) := fun p =>
⟨fun a => (fderiv ℝ f (p,j a)).comp (ContinuousLinearMap.inl ℝ P E),
((hf.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).continuous.comp (continuous_const.prodMk hj)).clm_comp continuous_const⟩
apply hasFDerivAt_compact _ q ?_ ?_ p
· apply ContinuousMap.continuous_of_continuous_uncurry
exact ((hf.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).continuous.comp
(continuous_fst.prodMk (hj.comp continuous_snd))).clm_comp continuous_const
· intro p a
exact (hf.differentiable (by simp) (p,j a)).hasFDerivAt.comp p
((hasFDerivAt_id p).prodMk (hasFDerivAt_const (j a) p))
/-- Smooth currying over a compact set. This supplies the Banach-space parameter
regularity needed for the actual coefficient multipliers and linear ODE. -/
theorem curryCompact_contDiff [FiniteDimensional ℝ P]
(f : P × E → F) (hf : ContDiff ℝ (⊤ : ℕ∞) f) (j : A → E) (hj : Continuous j) :
ContDiff ℝ (⊤ : ℕ∞) (curryCompact f hf.continuous j hj) := by
apply contDiff_infty.mpr
intro n
induction n generalizing f with
| zero =>
simp only [Nat.cast_zero,contDiff_zero]
exact curryCompact_continuous f hf.continuous j hj
| succ n ih =>
rw [Nat.cast_add,Nat.cast_one,contDiff_succ_iff_fderiv_apply]
refine ⟨fun p => (curryCompact_hasFDerivAt f hf j hj p).differentiableAt,by simp,fun v => ?_⟩
let f' : P × E → F := fun q => fderiv ℝ f q (v,0)
have hf' : ContDiff ℝ (⊤ : ℕ∞) f' := (hf.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).clm_apply contDiff_const
have he : (fun p => fderiv ℝ (curryCompact f hf.continuous j hj) p v)=
curryCompact f' hf'.continuous j hj := by
funext p
ext a
rw [(curryCompact_hasFDerivAt f hf j hj p).fderiv]
rfl
rw [he]
exact ih f' hf'
end ElasticityCompact
end
end
section
noncomputable section
open MeasureTheory Set Filter Function
open scoped ENNReal
namespace ElasticityCompact
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
[MeasurableSpace E] [BorelSpace E]
variable {S : Set E} [CompactSpace S]
def zeroExtend (f : C(S,ℂ)) : E → ℂ := Function.extend Subtype.val f 0
omit [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] [CompactSpace S] in
lemma zeroExtend_mem (f : C(S,ℂ)) (x : S) : zeroExtend f x=f x :=
Subtype.val_injective.extend_apply f 0 x
omit [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] [CompactSpace S] in
lemma zeroExtend_notMem (f : C(S,ℂ)) {x : E} (hx : x∉S) : zeroExtend f x=0 := by
apply Function.extend_apply'
rintro ⟨y,rfl⟩
exact hx y.property
omit [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] in
lemma zeroExtend_norm (f : C(S,ℂ)) (x : E) : ‖zeroExtend f x‖ ≤ ‖f‖ := by
by_cases hx : x∈S
· exact (zeroExtend_mem f ⟨x,hx⟩) ▸ f.norm_coe_le_norm ⟨x,hx⟩
· rw [zeroExtend_notMem f hx,norm_zero]; exact norm_nonneg _
omit [NormedSpace ℝ E] in
lemma zeroExtend_memLp (hS : MeasurableSet S) (μ : Measure E) (f : C(S,ℂ)) :
MemLp (zeroExtend f) ∞ μ := by
apply memLp_top_of_bound _ ‖f‖ (Eventually.of_forall (zeroExtend_norm f))
exact ((MeasurableEmbedding.subtype_coe hS).stronglyMeasurable_extend
f.continuous.stronglyMeasurable stronglyMeasurable_const).aestronglyMeasurable
omit [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] [CompactSpace S] in
lemma zeroExtend_add (f g : C(S,ℂ)) : zeroExtend (f+g)=zeroExtend f+zeroExtend g := by
funext x
by_cases hx : x∈S
· change zeroExtend (f+g) (⟨x,hx⟩ : S)=zeroExtend f (⟨x,hx⟩ : S)+zeroExtend g (⟨x,hx⟩ : S)
rw [zeroExtend_mem (f+g) ⟨x,hx⟩,zeroExtend_mem f ⟨x,hx⟩,zeroExtend_mem g ⟨x,hx⟩]
rfl
· simp only [Pi.add_apply,zeroExtend_notMem _ hx,add_zero]
omit [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] [CompactSpace S] in
lemma zeroExtend_smul (c : ℂ) (f : C(S,ℂ)) : zeroExtend (c • f)=c • zeroExtend f := by
funext x
by_cases hx : x∈S
· change zeroExtend (c • f) (⟨x,hx⟩ : S)=c • zeroExtend f (⟨x,hx⟩ : S)
rw [zeroExtend_mem (c • f) ⟨x,hx⟩,zeroExtend_mem f ⟨x,hx⟩]
rfl
· simp only [Pi.smul_apply,zeroExtend_notMem _ hx,smul_zero]
def toLinfCompact (hS : MeasurableSet S) (μ : Measure E) : C(S,ℂ) →L[ℂ] Lp ℂ ∞ μ :=
LinearMap.mkContinuous
({ toFun := fun f => (zeroExtend_memLp hS μ f).toLp (zeroExtend f)
map_add' := fun f g => by
apply Lp.ext
filter_upwards [MemLp.coeFn_toLp (zeroExtend_memLp hS μ (f+g)),
MemLp.coeFn_toLp (zeroExtend_memLp hS μ f),MemLp.coeFn_toLp (zeroExtend_memLp hS μ g),
Lp.coeFn_add ((zeroExtend_memLp hS μ f).toLp _) ((zeroExtend_memLp hS μ g).toLp _)] with x ha hb hc hd
rw [ha,hd]
simp only [Pi.add_apply,hb,hc,zeroExtend_add]
map_smul' := fun c f => by
apply Lp.ext
filter_upwards [MemLp.coeFn_toLp (zeroExtend_memLp hS μ (c • f)),
MemLp.coeFn_toLp (zeroExtend_memLp hS μ f),
Lp.coeFn_smul c ((zeroExtend_memLp hS μ f).toLp _)] with x ha hb hc
simp only [RingHom.id_apply]
rw [ha,hc]
simp only [Pi.smul_apply,hb,zeroExtend_smul] } : C(S,ℂ) →ₗ[ℂ] Lp ℂ ∞ μ) 1 (fun f => by
rw [one_mul]
change ‖(zeroExtend_memLp hS μ f).toLp (zeroExtend f)‖ ≤ ‖f‖
rw [Lp.norm_toLp]
have h := eLpNorm_le_of_ae_bound (p := ∞) (μ := μ)
(zeroExtend_memLp hS μ f).aestronglyMeasurable
(Eventually.of_forall (zeroExtend_norm f))
simp only [ENNReal.toReal_top,inv_zero,ENNReal.rpow_zero,one_mul] at h
exact (ENNReal.toReal_mono ENNReal.ofReal_ne_top h).trans_eq
(ENNReal.toReal_ofReal (norm_nonneg f)))
omit [NormedSpace ℝ E] in
lemma toLinfCompact_ae (hS : MeasurableSet S) (μ : Measure E) (f : C(S,ℂ)) :
toLinfCompact hS μ f =ᵐ[μ] zeroExtend f := MemLp.coeFn_toLp (zeroExtend_memLp hS μ f)
variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P]
/-- A joint smooth family with a fixed compact spatial support is genuinely
smooth with values in L-infinity, not merely pointwise smooth. -/
theorem exists_smooth_linf_family (hS : MeasurableSet S) (μ : Measure E)
(a : P × E → ℂ) (ha : ContDiff ℝ (⊤ : ℕ∞) a)
(hs : ∀ p x, x∉S → a (p,x)=0) :
∃ b : P → Lp ℂ ∞ μ, ContDiff ℝ (⊤ : ℕ∞) b ∧ ∀ p, b p =ᵐ[μ] fun x => a (p,x) := by
let f := curryCompact a ha.continuous (fun x : S => (x:E)) continuous_subtype_val
have hf := curryCompact_contDiff a ha (fun x : S => (x:E)) continuous_subtype_val
refine ⟨fun p => toLinfCompact hS μ (f p),?_,fun p => ?_⟩
· have hL : ContDiff ℝ (⊤ : ℕ∞) (toLinfCompact hS μ) :=
(toLinfCompact hS μ).restrictScalars ℝ |>.contDiff
exact hL.comp hf
· apply (toLinfCompact_ae hS μ (f p)).trans
apply Eventually.of_forall
intro x
by_cases hx : x∈S
· exact zeroExtend_mem (f p) ⟨x,hx⟩
· rw [zeroExtend_notMem _ hx]
change 0=a (p,x)
exact (hs p x hx).symm
end ElasticityCompact
end
end
end OAI