Download data/lean/OAI/MathematicalPhysics/Elasticity/Variational.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 50.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Elasticity/Variational.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/Elasticity/Variational.lean
-
curl -L -o Variational.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Elasticity/Variational.lean
50.6 kB
import OAI.MathematicalPhysics.Elasticity.Basic
namespace OAI
section
noncomputable section
open MeasureTheory Set
open scoped BigOperators
namespace Elasticity
open scoped BigOperators
lemma coordDeriv_add {f g : X → V} (hf : Differentiable ℝ f)
(hg : Differentiable ℝ g) (i : Fin 3) :
coordDeriv (f+g) i = coordDeriv f i + coordDeriv g i := by
funext x
exact congrArg (fun L : X →L[ℝ] V => L (coordVector i))
(fderiv_add (hf x) (hg x))
lemma coordDeriv_smul (c : ℝ) {f : X → V} (hf : Differentiable ℝ f)
(i : Fin 3) : coordDeriv (c • f) i = c • coordDeriv f i := by
funext x
exact congrArg (fun L : X →L[ℝ] V => L (coordVector i))
(fderiv_const_smul (hf x) c)
lemma coordDeriv_zero (i : Fin 3) : coordDeriv (0 : X → V) i = 0 := by
ext x j
simp [coordDeriv]
def smoothJetSubmodule (Ω : Set X) : Submodule ℝ (Ambient Ω) where
carrier := SmoothJets Ω
zero_mem' := by
refine ⟨0, MemLp.zero, fun i => ?_, contDiff_const, ?_, ?_⟩
· simpa only [coordDeriv_zero] using (MemLp.zero : MemLp (0 : X → V) 2 (volume.restrict Ω))
· simp
· funext i
change 0 = _
simp only [coordDeriv_zero, MemLp.toLp_zero]
add_mem' := by
rintro u v ⟨f, hf, hd, hs, hu, hud⟩ ⟨g, hg, he, ht, hv, hvd⟩
have hb (i) : MemLp (coordDeriv (f+g) i) 2 (volume.restrict Ω) := by
rw [coordDeriv_add (hs.differentiable (by simp)) (ht.differentiable (by simp))]
exact (hd i).add (he i)
refine ⟨f+g, hf.add hg, hb, hs.add ht, ?_, ?_⟩
· simpa [hu, hv] using (MemLp.toLp_add hf hg).symm
· funext i
simp only [Prod.snd_add, Pi.add_apply, hud, hvd]
simp only [coordDeriv_add (hs.differentiable (by simp)) (ht.differentiable (by simp))]
exact (MemLp.toLp_add (hd i) (he i)).symm
smul_mem' := by
rintro c u ⟨f, hf, hd, hs, hu, hud⟩
have hb (i) : MemLp (coordDeriv (c • f) i) 2 (volume.restrict Ω) := by
rw [coordDeriv_smul c (hs.differentiable (by simp))]
exact (hd i).const_smul c
refine ⟨c • f, hf.const_smul c, hb, hs.const_smul c, ?_, ?_⟩
· simpa [hu] using (MemLp.toLp_const_smul c hf).symm
· funext i
change c • u.2 i = _
rw [hud]
simp only [coordDeriv_smul c (hs.differentiable (by simp))]
exact (MemLp.toLp_const_smul c (hd i)).symm
/-- Compactly supported interior test jets, with the actual support condition. -/
def testJetSubmodule (Ω : Set X) : Submodule ℝ (Ambient Ω) where
carrier := TestJets Ω
zero_mem' := by
refine ⟨0, MemLp.zero, fun i => ?_, contDiff_const, HasCompactSupport.zero, ?_, ?_, ?_⟩
· simpa only [coordDeriv_zero] using (MemLp.zero : MemLp (0 : X → V) 2 (volume.restrict Ω))
· simp
· simp
· funext i
change 0 = _
simp only [coordDeriv_zero, MemLp.toLp_zero]
add_mem' := by
rintro u v ⟨f, hf, hd, hs, hc, hsup, hu, hud⟩ ⟨g, hg, he, ht, hgc, hgsup, hv, hvd⟩
have hb (i) : MemLp (coordDeriv (f+g) i) 2 (volume.restrict Ω) := by
rw [coordDeriv_add (hs.differentiable (by simp)) (ht.differentiable (by simp))]
exact (hd i).add (he i)
refine ⟨f+g, hf.add hg, hb, hs.add ht, hc.add hgc,
(tsupport_add f g).trans (union_subset hsup hgsup), ?_, ?_⟩
· simpa [hu, hv] using (MemLp.toLp_add hf hg).symm
· funext i
simp only [Prod.snd_add, Pi.add_apply, hud, hvd]
simp only [coordDeriv_add (hs.differentiable (by simp)) (ht.differentiable (by simp))]
exact (MemLp.toLp_add (hd i) (he i)).symm
smul_mem' := by
rintro c u ⟨f, hf, hd, hs, hc, hsup, hu, hud⟩
have hb (i) : MemLp (coordDeriv (c • f) i) 2 (volume.restrict Ω) := by
rw [coordDeriv_smul c (hs.differentiable (by simp))]
exact (hd i).const_smul c
refine ⟨c • f, hf.const_smul c, hb, hs.const_smul c, (hc.smul_left : HasCompactSupport ((fun _ : X => c) • f)),
(tsupport_smul_subset_right (fun _ : X => c) f).trans hsup, ?_, ?_⟩
· simpa [hu] using (MemLp.toLp_const_smul c hf).symm
· funext i
change c • u.2 i = _
rw [hud]
simp only [coordDeriv_smul c (hs.differentiable (by simp))]
exact (MemLp.toLp_const_smul c (hd i)).symm
lemma testJetSubmodule_le (Ω : Set X) : testJetSubmodule Ω ≤ smoothJetSubmodule Ω := by
rintro u ⟨f,hf,hd,hs,_,_,hu,hud⟩
exact ⟨f,hf,hd,hs,hu,hud⟩
def h1Submodule (Ω : Set X) : Submodule ℝ (Ambient Ω) :=
(smoothJetSubmodule Ω).topologicalClosure
def h10Submodule (Ω : Set X) : Submodule ℝ (Ambient Ω) :=
(testJetSubmodule Ω).topologicalClosure
lemma h10Submodule_le (Ω : Set X) : h10Submodule Ω ≤ h1Submodule Ω :=
Submodule.topologicalClosure_mono (testJetSubmodule_le Ω)
lemma sameTrace_refl (Ω : Set X) (u : H1 Ω) : SameTrace Ω u u := by
exact show u.val - u.val ∈ h10Submodule Ω by rw [sub_self]; exact Submodule.zero_mem _
lemma sameTrace_symm (Ω : Set X) {u v : H1 Ω} (h : SameTrace Ω u v) :
SameTrace Ω v u := by
exact show v.val - u.val ∈ h10Submodule Ω by
rw [← neg_sub]; exact Submodule.neg_mem _ h
lemma sameTrace_trans (Ω : Set X) {u v w : H1 Ω}
(h : SameTrace Ω u v) (h' : SameTrace Ω v w) : SameTrace Ω u w := by
exact show u.val - w.val ∈ h10Submodule Ω by
convert Submodule.add_mem (h10Submodule Ω) h h' using 1; abel
abbrev JetH (Ω : Set X) := PiLp 2 (fun _ : Option (Fin 3) => Lp V 2 (volume.restrict Ω))
def jetEquiv (Ω : Set X) : JetH Ω ≃L[ℝ] Ambient Ω := by
let e : (Option (Fin 3) → Lp V 2 (volume.restrict Ω)) ≃L[ℝ] Ambient Ω :=
{ toLinearEquiv := LinearEquiv.piOptionEquivProd ℝ
continuous_toFun := (continuous_apply none).prodMk
(continuous_pi fun i => continuous_apply (some i))
continuous_invFun := continuous_pi fun i => by
cases i with
| none => exact continuous_fst
| some i => exact (continuous_apply i).comp continuous_snd }
exact (PiLp.continuousLinearEquiv 2 ℝ _).trans e
@[simp] lemma jetEquiv_apply (Ω : Set X) (u : JetH Ω) :
jetEquiv Ω u = (u none, fun i => u (some i)) := rfl
def H1Hilbert (Ω : Set X) : Submodule ℝ (JetH Ω) :=
(h1Submodule Ω).comap (jetEquiv Ω).toLinearMap
def H10Hilbert (Ω : Set X) : Submodule ℝ (JetH Ω) :=
(h10Submodule Ω).comap (jetEquiv Ω).toLinearMap
lemma isClosed_H1Hilbert (Ω : Set X) : IsClosed (H1Hilbert Ω : Set (JetH Ω)) :=
(smoothJetSubmodule Ω).isClosed_topologicalClosure.preimage (jetEquiv Ω).continuous
lemma isClosed_H10Hilbert (Ω : Set X) : IsClosed (H10Hilbert Ω : Set (JetH Ω)) :=
(testJetSubmodule Ω).isClosed_topologicalClosure.preimage (jetEquiv Ω).continuous
instance (Ω : Set X) : CompleteSpace (H1Hilbert Ω) := (isClosed_H1Hilbert Ω).completeSpace_coe
instance (Ω : Set X) : CompleteSpace (H10Hilbert Ω) := (isClosed_H10Hilbert Ω).completeSpace_coe
lemma H10Hilbert_le (Ω : Set X) : H10Hilbert Ω ≤ H1Hilbert Ω :=
Submodule.comap_mono (h10Submodule_le Ω)
/-- The Hilbert version is exactly the H¹ jet closure, not an extra
regularity hypothesis or a replacement by a smaller test space. -/
def h1Equiv (Ω : Set X) : (H1Hilbert Ω) ≃ H1 Ω where
toFun u := ⟨jetEquiv Ω u, u.property⟩
invFun u := ⟨(jetEquiv Ω).symm u.val, by
change jetEquiv Ω ((jetEquiv Ω).symm u.val) ∈ h1Submodule Ω
rw [ContinuousLinearEquiv.apply_symm_apply]
exact u.property⟩
left_inv u := by apply Subtype.ext; exact (jetEquiv Ω).symm_apply_apply u.val
right_inv u := by apply Subtype.ext; exact (jetEquiv Ω).apply_symm_apply u.val
end Elasticity
end
end
section
/-! The physical energy is a continuous bilinear form on the actual
Hilbert jet space. Bounded coefficients below are proved from admissibility
later, rather than added to the inverse theorem. -/
noncomputable section
open MeasureTheory
open scoped BigOperators
namespace Elasticity
abbrev ScalarL2 (Ω : Set X) := Lp ℝ 2 (volume.restrict Ω)
structure BoundedCoefficient (Ω : Set X) (a : X → ℝ) : Prop where
measurable : AEStronglyMeasurable a (volume.restrict Ω)
bound : ∃ C : ℝ, ∀ᵐ x ∂(volume.restrict Ω), ‖a x‖ ≤ C
namespace BoundedCoefficient
variable {Ω : Set X} {a : X → ℝ} (ha : BoundedCoefficient Ω a)
include ha in
lemma mul_memLp (f : ScalarL2 Ω) : MemLp (fun x => a x * f x) 2 (volume.restrict Ω) := by
obtain ⟨C,hC⟩ := ha.bound
apply (Lp.memLp f).of_le_mul (c := C) (ha.measurable.mul (Lp.aestronglyMeasurable f))
filter_upwards [hC] with x hx
simpa only [Pi.mul_apply, norm_mul] using mul_le_mul_of_nonneg_right hx (norm_nonneg (f x))
def mulL : ScalarL2 Ω →L[ℝ] ScalarL2 Ω := by
let F : ScalarL2 Ω →ₗ[ℝ] ScalarL2 Ω :=
{ toFun f := (ha.mul_memLp f).toLp _
map_add' f g := by
apply Lp.ext
filter_upwards [(ha.mul_memLp (f+g)).coeFn_toLp,
(ha.mul_memLp f).coeFn_toLp, (ha.mul_memLp g).coeFn_toLp,
Lp.coeFn_add f g, Lp.coeFn_add ((ha.mul_memLp f).toLp _) ((ha.mul_memLp g).toLp _)]
with x hfg hf hg hadd he
rw [hfg,he]
simp only [Pi.add_apply]
rw [hf,hg,hadd]
exact mul_add ..
map_smul' c f := by
apply Lp.ext
filter_upwards [(ha.mul_memLp (c • f)).coeFn_toLp,
(ha.mul_memLp f).coeFn_toLp, Lp.coeFn_smul c f,
Lp.coeFn_smul c ((ha.mul_memLp f).toLp _)] with x hcf hf hs ht
simp only [RingHom.id_apply]
rw [hcf,ht]
simp only [Pi.smul_apply, smul_eq_mul]
rw [hf,hs]
simp only [Pi.smul_apply, smul_eq_mul]
ring }
let C := ha.bound.choose
have hC := ha.bound.choose_spec
exact F.mkContinuous C (fun f => by
apply Lp.norm_le_mul_norm_of_ae_le_mul
filter_upwards [(ha.mul_memLp f).coeFn_toLp,hC] with x hx hb
change ‖(ha.mul_memLp f).toLp _ x‖ ≤ _
rw [hx,norm_mul]
exact mul_le_mul_of_nonneg_right hb (norm_nonneg _))
lemma mulL_ae (f : ScalarL2 Ω) : ha.mulL f =ᵐ[volume.restrict Ω] fun x => a x*f x :=
(ha.mul_memLp f).coeFn_toLp
lemma inner_mulL (f g : ScalarL2 Ω) :
inner ℝ (ha.mulL f) g = ∫ x, a x*f x*g x ∂(volume.restrict Ω) := by
rw [MeasureTheory.L2.inner_def]
apply integral_congr_ae
filter_upwards [ha.mulL_ae f] with x hx
rw [hx,real_inner_comm]
rfl
end BoundedCoefficient
variable {Ω : Set X}
lemma lp_sum_ae {ι : Type*} (s : Finset ι) (f : ι → ScalarL2 Ω) :
((∑ i ∈ s, f i : ScalarL2 Ω) : X → ℝ) =ᵐ[volume.restrict Ω] fun x => ∑ i ∈ s, f i x := by
classical
induction s using Finset.induction_on with
| empty =>
simp only [Finset.sum_empty]
filter_upwards [Lp.coeFn_zero ℝ 2 (volume.restrict Ω)] with x hx
exact hx
| @insert i s hi ih =>
simp only [Finset.sum_insert hi]
filter_upwards [Lp.coeFn_add (f i) (∑ j ∈ s, f j), ih] with x hx hy
simp only [Pi.add_apply] at hx
exact hx.trans (congrArg (fun t => f i x+t) hy)
def jetEntry (Ω : Set X) (i j : Fin 3) : JetH Ω →L[ℝ] ScalarL2 Ω :=
((EuclideanSpace.proj i).compLpL 2 (volume.restrict Ω)).comp
(PiLp.proj 2 (fun _ : Option (Fin 3) => Lp V 2 (volume.restrict Ω)) (some j))
def jetDiv (Ω : Set X) : JetH Ω →L[ℝ] ScalarL2 Ω := ∑ i, jetEntry Ω i i
def jetStrain (Ω : Set X) (i j : Fin 3) : JetH Ω →L[ℝ] ScalarL2 Ω :=
(1/2 : ℝ) • (jetEntry Ω i j + jetEntry Ω j i)
lemma jetEntry_ae (u : JetH Ω) (i j : Fin 3) :
jetEntry Ω i j u =ᵐ[volume.restrict Ω] fun x => (u (some j) x) i :=
ContinuousLinearMap.coeFn_compLpL _ _
lemma jetDiv_ae (u : JetH Ω) :
jetDiv Ω u =ᵐ[volume.restrict Ω] fun x => ∑ i, (u (some i) x) i := by
have hs := lp_sum_ae Finset.univ (fun i => jetEntry Ω i i u)
have he : ∀ᵐ x ∂(volume.restrict Ω), ∀ i, jetEntry Ω i i u x = (u (some i) x) i :=
Filter.eventually_all.mpr (fun i => jetEntry_ae u i i)
filter_upwards [hs,he] with x hx hy
change (∑ i, jetEntry Ω i i) u x = _
simpa only [sum_apply,hy] using hx
lemma jetStrain_ae (u : JetH Ω) (i j : Fin 3) :
jetStrain Ω i j u =ᵐ[volume.restrict Ω]
fun x => ((u (some j) x) i+(u (some i) x) j)/2 := by
filter_upwards [Lp.coeFn_smul (1/2 : ℝ) (jetEntry Ω i j u+jetEntry Ω j i u),
Lp.coeFn_add (jetEntry Ω i j u) (jetEntry Ω j i u),
jetEntry_ae u i j, jetEntry_ae u j i] with x hs ha hi hj
change ((1/2 : ℝ) • (jetEntry Ω i j u+jetEntry Ω j i u)) x = _
rw [hs]
simp only [Pi.smul_apply,smul_eq_mul]
rw [ha]
simp only [Pi.add_apply,hi,hj]
ring
def jetEnergy {lam mu : X → ℝ} (hl : BoundedCoefficient Ω lam)
(hm : BoundedCoefficient Ω mu) : JetH Ω →L[ℝ] JetH Ω →L[ℝ] ℝ :=
(innerSL ℝ).bilinearComp (hl.mulL.comp (jetDiv Ω)) (jetDiv Ω) +
(2 : ℝ) • ∑ i, ∑ j, (innerSL ℝ).bilinearComp
(hm.mulL.comp (jetStrain Ω i j)) (jetStrain Ω i j)
lemma jetEnergy_apply {lam mu : X → ℝ} (hl : BoundedCoefficient Ω lam)
(hm : BoundedCoefficient Ω mu) (u v : JetH Ω) :
jetEnergy hl hm u v = inner ℝ (hl.mulL (jetDiv Ω u)) (jetDiv Ω v) +
2 * ∑ i, ∑ j, inner ℝ (hm.mulL (jetStrain Ω i j u)) (jetStrain Ω i j v) := by
simp [jetEnergy,sum_apply,ContinuousLinearMap.bilinearComp_apply,
innerSL_apply_apply]
end Elasticity
end
end
section
/-! Actual Korn and supported Poincaré identities, needed for variational
wellposedness of the physical DN map. No coercivity is assumed. -/
noncomputable section
open MeasureTheory SchwartzMap
open scoped BigOperators LineDeriv SchwartzMap
namespace ElasticityKorn
abbrev X := EuclideanSpace ℝ (Fin 3)
abbrev S := SchwartzMap X ℝ
abbrev L2 : S →L[ℝ] Lp ℝ 2 (volume : Measure X) := SchwartzMap.toLpCLM ℝ ℝ 2 volume
def norm2 (f : S) := ‖L2 f‖
def pair (f g : S) : ℝ := inner ℝ (L2 f) (L2 g)
def e (i : Fin 3) : X := EuclideanSpace.single i 1
def d (v : X) : S →ₗ[ℝ] S := (LineDeriv.lineDerivOpCLM ℝ S v).toLinearMap
@[simp] lemma d_apply (v : X) (f : S) (x : X) :
d v f x = fderiv ℝ (f : X → ℝ) x v := rfl
lemma smooth (f : S) : ContDiff ℝ (⊤ : ℕ∞) (f : X → ℝ) := f.smooth _
lemma pair_integral (f g : S) : pair f g = ∫ x : X, f x * g x := by
rw [pair, MeasureTheory.L2.inner_def]
apply integral_congr_ae
filter_upwards [f.coeFn_toLp 2 volume, g.coeFn_toLp 2 volume] with x hx hy
change inner ℝ (f.toLp 2 volume x) (g.toLp 2 volume x) = _
rw [hx, hy]
exact real_inner_comm _ _
lemma pair_self (f : S) : pair f f = norm2 f ^ 2 := real_inner_self_eq_norm_sq _
lemma pair_symm (f g : S) : pair f g = pair g f := real_inner_comm _ _
lemma pair_add_left (f g h : S) : pair (f+g) h = pair f h + pair g h := by
simp only [pair, map_add, inner_add_left]
lemma pair_add_right (f g h : S) : pair f (g+h) = pair f g + pair f h := by
simp only [pair, map_add, inner_add_right]
lemma pair_smul_left (c : ℝ) (f g : S) : pair (c • f) g = c * pair f g := by
simp only [pair, map_smul, real_inner_smul_left]
lemma pair_smul_right (c : ℝ) (f g : S) : pair f (c • g) = c * pair f g := by
simp only [pair, map_smul, real_inner_smul_right]
lemma pair_sum_left {ι : Type*} (s : Finset ι) (f : ι → S) (g : S) :
pair (∑ i ∈ s, f i) g = ∑ i ∈ s, pair (f i) g := by
simp only [pair, map_sum, sum_inner]
lemma pair_sum_right {ι : Type*} (s : Finset ι) (f : S) (g : ι → S) :
pair f (∑ i ∈ s, g i) = ∑ i ∈ s, pair f (g i) := by
simp only [pair, map_sum, inner_sum]
lemma pair_bound (f g : S) : |pair f g| ≤ norm2 f * norm2 g := abs_real_inner_le_norm _ _
lemma integrable_pair (f g : S) : Integrable (fun x : X => f x*g x) :=
(SchwartzMap.pairing (ContinuousLinearMap.mul ℝ ℝ) f g).integrable
lemma pair_d (f g : S) (v : X) : pair f (d v g) = -pair (d v f) g := by
simp only [pair_integral]
exact integral_mul_fderiv_eq_neg_fderiv_mul_of_integrable
(integrable_pair (d v f) g) (integrable_pair f (d v g)) (integrable_pair f g)
(fun x _ => (smooth f).differentiable (by simp) x)
(fun x _ => (smooth g).differentiable (by simp) x)
lemma d_d (v w : X) (f : S) (x : X) :
d v (d w f) x = fderiv ℝ (fderiv ℝ (f : X → ℝ)) x v w := by
have hd : Differentiable ℝ (fderiv ℝ (f : X → ℝ)) :=
((smooth f).fderiv_right (m := (⊤ : ℕ∞)) (by simp)).differentiable (by simp)
change fderiv ℝ (fun y => fderiv ℝ (f : X → ℝ) y w) x v = _
rw [fderiv_clm_apply (hd x) (differentiableAt_const w)]
simp
lemma d_comm (v w : X) (f : S) : d v (d w f) = d w (d v f) := by
ext x
rw [d_d, d_d]
exact (smooth f).contDiffAt.isSymmSndFDerivAt (by
simp only [minSmoothness_of_isRCLikeNormedField]
exact WithTop.coe_le_coe.mpr (le_top : (2 : ℕ∞) ≤ ⊤)) _ _
lemma cross (v w : X) (f g : S) : pair (d v f) (d w g) = pair (d w f) (d v g) := by
have h := pair_d (d v f) g w
have h' := pair_d (d w f) g v
rw [d_comm] at h
exact h.trans h'.symm
def divergence (u : Fin 3 → S) : S := ∑ i, d (e i) (u i)
def gradEnergy (u : Fin 3 → S) : ℝ := ∑ i, ∑ j, norm2 (d (e i) (u j)) ^ 2
def strainEnergy (u : Fin 3 → S) : ℝ :=
∑ i, ∑ j, norm2 ((1/2 : ℝ) • (d (e i) (u j) + d (e j) (u i))) ^ 2
lemma norm2_half_add_sq (f g : S) :
norm2 ((1/2 : ℝ) • (f+g)) ^ 2 = (norm2 f ^ 2 + 2*pair f g + norm2 g ^ 2)/4 := by
rw [← pair_self, pair_smul_left, pair_smul_right, pair_add_left,
pair_add_right, pair_add_right, pair_self, pair_self, pair_symm g f]
ring
lemma cross_sum (u : Fin 3 → S) :
(∑ i, ∑ j, pair (d (e i) (u j)) (d (e j) (u i))) = norm2 (divergence u) ^ 2 := by
rw [← pair_self, divergence, pair_sum_left]
simp_rw [pair_sum_right]
apply Finset.sum_congr rfl
intro i _
apply Finset.sum_congr rfl
intro j _
rw [cross]
exact pair_symm _ _
/-- The classical exact whole-space Korn identity, by two integrations by parts. -/
theorem korn_identity (u : Fin 3 → S) :
2*strainEnergy u = gradEnergy u + norm2 (divergence u)^2 := by
simp only [strainEnergy, norm2_half_add_sq, add_div, mul_div_assoc]
simp_rw [Finset.sum_add_distrib, ← Finset.sum_div, ← Finset.mul_sum]
have hs : (∑ i, ∑ j, norm2 (d (e j) (u i))^2) = gradEnergy u := Finset.sum_comm
simp_rw [← Finset.sum_div]
rw [hs, cross_sum u]
change 2*((gradEnergy u/4 + 2*(norm2 (divergence u)^2/4)) + gradEnergy u/4) = _
ring
theorem korn (u : Fin 3 → S) : gradEnergy u ≤ 2*strainEnergy u := by
rw [korn_identity]
exact le_add_of_nonneg_right (sq_nonneg _)
def qCLM : X →L[ℝ] ℝ := EuclideanSpace.proj 0
def Q : S →ₗ[ℝ] S := (SchwartzMap.smulLeftCLM ℝ qCLM).toLinearMap
@[simp] lemma Q_apply (f : S) (x : X) : Q f x = x 0 * f x :=
SchwartzMap.smulLeftCLM_apply_apply qCLM.hasTemperateGrowth f x
lemma d_Q (f : S) : d (e 0) (Q f) = f + Q (d (e 0) f) := by
ext x
rw [d_apply]
have hc : (Q f : X → ℝ) = fun x => x 0 * f x := by ext x; exact Q_apply f x
rw [hc]
change _ = f x + Q (d (e 0) f) x
rw [Q_apply, d_apply]
have h := congrArg (fun L : X →L[ℝ] ℝ => L (e 0))
(((EuclideanSpace.proj (𝕜 := ℝ) 0).hasFDerivAt (x := x)).mul
((smooth f).differentiable (by simp) x).hasFDerivAt).fderiv
simpa [e, add_comm, Pi.mul_def] using h
lemma pair_Q (f g : S) : pair f (Q g) = pair (Q f) g := by
simp only [pair_integral, Q_apply]
congr 1
ext x
ring
lemma norm2_Q_supported {R : ℝ} (f : S) (hf : ∀ x, f x ≠ 0 → |x 0| ≤ R) :
norm2 (Q f) ≤ R*norm2 f := by
apply Lp.norm_le_mul_norm_of_ae_le_mul
filter_upwards [(Q f).coeFn_toLp 2 volume, f.coeFn_toLp 2 volume] with x hx hy
change ‖(Q f).toLp 2 volume x‖ ≤ R*‖f.toLp 2 volume x‖
rw [hx, hy, Q_apply, norm_mul, Real.norm_eq_abs]
by_cases hz : f x=0
· simp [hz]
· exact mul_le_mul_of_nonneg_right (hf x hz) (norm_nonneg _)
/-- Supported Poincaré with explicit constant; support is imposed on the actual
function, not on an abstract or assumed Sobolev norm. -/
theorem poincare {R : ℝ} (f : S) (hf : ∀ x, f x ≠ 0 → |x 0| ≤ R) :
norm2 f ≤ 2*R*norm2 (d (e 0) f) := by
have he := pair_d (Q f) f (e 0)
rw [d_Q, pair_add_left, pair_self, pair_symm (Q (d (e 0) f)) f, pair_Q] at he
have ht := pair_bound (Q f) (d (e 0) f)
have hq := norm2_Q_supported f hf
have hnn : 0 ≤ norm2 (d (e 0) f) := norm_nonneg _
have hn : 0 ≤ norm2 f := norm_nonneg _
have hmul := mul_le_mul_of_nonneg_right hq hnn
by_cases hzero : norm2 f = 0
· rw [hzero]
by_cases hR : 0 ≤ R
· positivity
· have hz : f=0 := by
apply SchwartzMap.injective_toLp 2 volume
change L2 f = L2 0
rw [map_zero]
exact norm_eq_zero.mp hzero
rw [hz, map_zero]
change 0 ≤ 2*R*‖L2 0‖
rw [map_zero, norm_zero, mul_zero]
· have hp : 0 < norm2 f := lt_of_le_of_ne hn (Ne.symm hzero)
have ha := neg_le_abs (pair (Q f) (d (e 0) f))
nlinarith
end ElasticityKorn
end
end
section
noncomputable section
open MeasureTheory SchwartzMap Set
open scoped BigOperators
namespace Elasticity
variable {Ω : Set X}
instance temperate_restrict_volume (Ω : Set X) : (volume.restrict Ω).HasTemperateGrowth :=
⟨⟨volume.integrablePower,
(Measure.integrable_pow_neg_integrablePower (volume : Measure X)).mono_measure
Measure.restrict_le_self⟩⟩
abbrev schwartzR (Ω : Set X) : SchwartzMap X ℝ →L[ℝ] ScalarL2 Ω :=
SchwartzMap.toLpCLM ℝ ℝ 2 (volume.restrict Ω)
lemma schwartzR_norm_sq (f : SchwartzMap X ℝ) :
‖schwartzR Ω f‖^2 = ∫ x, (f x)^2 ∂(volume.restrict Ω) := by
rw [← real_inner_self_eq_norm_sq,MeasureTheory.L2.inner_def]
apply integral_congr_ae
filter_upwards [f.coeFn_toLp 2 (volume.restrict Ω)] with x hx
change inner ℝ (f.toLp 2 (volume.restrict Ω) x) (f.toLp 2 (volume.restrict Ω) x) = _
rw [hx,real_inner_comm]
exact (sq _).symm
lemma schwartzR_supported_norm (f : SchwartzMap X ℝ) (hf : tsupport (f : X → ℝ) ⊆ Ω) :
‖schwartzR Ω f‖ = ElasticityKorn.norm2 f := by
have hsq : ‖schwartzR Ω f‖^2 = ElasticityKorn.norm2 f^2 := by
rw [schwartzR_norm_sq,← ElasticityKorn.pair_self,ElasticityKorn.pair_integral]
simp only [← sq]
apply setIntegral_eq_integral_of_forall_compl_eq_zero
intro x hx
have hz : f x=0 := image_eq_zero_of_notMem_tsupport (fun ht => hx (hf ht))
simp [hz]
have hnon : 0 ≤ ElasticityKorn.norm2 f := norm_nonneg _
nlinarith [norm_nonneg (schwartzR Ω f)]
def jetScalar (Ω : Set X) (k : Option (Fin 3)) (i : Fin 3) :
JetH Ω →L[ℝ] ScalarL2 Ω :=
((EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω)).comp
(PiLp.proj 2 (fun _ : Option (Fin 3) => Lp V 2 (volume.restrict Ω)) k)
lemma jetScalar_ae (u : JetH Ω) (k : Option (Fin 3)) (i : Fin 3) :
jetScalar Ω k i u =ᵐ[volume.restrict Ω] fun x => (u k x) i :=
ContinuousLinearMap.coeFn_compLpL _ _
lemma scalar_projection_norm_sq (u : Lp V 2 (volume.restrict Ω)) :
‖u‖^2 = ∑ i, ‖(EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω) u‖^2 := by
let F (i : Fin 3) : ScalarL2 Ω := (EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω) u
have hmeas (i : Fin 3) : Integrable (fun x => (F i x)^2) (volume.restrict Ω) := by
simpa only [real_inner_self_eq_norm_sq, Real.norm_eq_abs, sq_abs] using (L2.integrable_inner (𝕜 := ℝ) (F i) (F i))
have hnorm (i : Fin 3) : ‖F i‖^2 = ∫ x, (F i x)^2 ∂(volume.restrict Ω) := by
rw [← real_inner_self_eq_norm_sq, L2.inner_def]
simp only [real_inner_self_eq_norm_sq, Real.norm_eq_abs, sq_abs]
change ‖u‖^2 = ∑ i, ‖F i‖^2
simp_rw [hnorm]
rw [← integral_finsetSum Finset.univ (fun i _ => hmeas i),← real_inner_self_eq_norm_sq,
L2.inner_def]
have he : ∀ᵐ x ∂(volume.restrict Ω), ∀ i, F i x=(u x) i :=
Filter.eventually_all.mpr (fun i => ContinuousLinearMap.coeFn_compLpL _ u)
apply integral_congr_ae
filter_upwards [he] with x hx
simp only [hx,real_inner_self_eq_norm_sq,EuclideanSpace.real_norm_sq_eq]
def jetValueSq (Ω : Set X) (u : JetH Ω) : ℝ := ∑ i, ‖jetScalar Ω none i u‖^2
def jetGradSq (Ω : Set X) (u : JetH Ω) : ℝ := ∑ i, ∑ j, ‖jetEntry Ω i j u‖^2
def jetStrainSq (Ω : Set X) (u : JetH Ω) : ℝ := ∑ i, ∑ j, ‖jetStrain Ω i j u‖^2
lemma jet_norm_sq (u : JetH Ω) : ‖u‖^2 = jetValueSq Ω u+jetGradSq Ω u := by
rw [PiLp.norm_sq_eq_of_L2,Fintype.sum_option]
simp_rw [scalar_projection_norm_sq]
change jetValueSq Ω u+ (∑ j, ∑ i, ‖jetEntry Ω i j u‖^2) = _
rw [Finset.sum_comm]
rfl
lemma continuous_jetValueSq : Continuous (jetValueSq Ω) := by
unfold jetValueSq
fun_prop
lemma continuous_jetGradSq : Continuous (jetGradSq Ω) := by
unfold jetGradSq
fun_prop
lemma continuous_jetStrainSq : Continuous (jetStrainSq Ω) := by
unfold jetStrainSq
fun_prop
/-- The scalar derivatives of an actual vector-valued smooth test field. -/
lemma coordDeriv_scalar (f : X → V) (hf : ContDiff ℝ (⊤ : ℕ∞) f)
(i j : Fin 3) (x : X) :
fderiv ℝ (fun y => (f y) i) x (coordVector j) = (coordDeriv f j x) i := by
have h := ((EuclideanSpace.proj (𝕜 := ℝ) i).hasFDerivAt (x := f x)).comp x
((hf.differentiable (by simp) x).hasFDerivAt)
change fderiv ℝ ((EuclideanSpace.proj (𝕜 := ℝ) i) ∘ f) x (coordVector j) = _
rw [h.fderiv]
rfl
lemma scalar_test_support (f : X → V) (i : Fin 3) :
tsupport (fun x => (f x) i) ⊆ tsupport f :=
tsupport_comp_subset (g := fun y : V => y i) rfl f
lemma jet_test_representation (u : JetH Ω) (hu : jetEquiv Ω u ∈ TestJets Ω) :
∃ F : Fin 3 → SchwartzMap X ℝ,
(∀ i, tsupport (F i : X → ℝ) ⊆ Ω) ∧
(∀ i, jetScalar Ω none i u = schwartzR Ω (F i)) ∧
∀ i j, jetEntry Ω i j u = schwartzR Ω (ElasticityKorn.d (ElasticityKorn.e j) (F i)) := by
obtain ⟨f,hf,hd,hs,hc,hsub,hu,hud⟩ := hu
let F (i : Fin 3) : SchwartzMap X ℝ :=
((hc.comp_left (g := fun y : V => y i) rfl)).toSchwartzMap
((EuclideanSpace.proj (𝕜 := ℝ) i).contDiff.comp hs)
have hF (i) (x : X) : F i x=(f x) i := rfl
refine ⟨F,fun i => (scalar_test_support f i).trans hsub,?_,?_⟩
· intro i
apply Lp.ext
have hv : (u none : X → V) =ᵐ[volume.restrict Ω] f := by
change (jetEquiv Ω u).1 =ᵐ[volume.restrict Ω] f
rw [hu]
exact hf.coeFn_toLp
filter_upwards [jetScalar_ae u none i,hv,(F i).coeFn_toLp 2 (volume.restrict Ω)] with x hx hy hz
exact hx.trans ((congrArg (fun y : V => y i) hy).trans hz.symm)
· intro i j
apply Lp.ext
have hv : (u (some j) : X → V) =ᵐ[volume.restrict Ω] coordDeriv f j := by
change (jetEquiv Ω u).2 j =ᵐ[volume.restrict Ω] coordDeriv f j
rw [hud]
exact (hd j).coeFn_toLp
filter_upwards [jetEntry_ae u i j,hv,
(ElasticityKorn.d (ElasticityKorn.e j) (F i)).coeFn_toLp 2 (volume.restrict Ω)] with x hx hy hz
change jetEntry Ω i j u x = (ElasticityKorn.d (ElasticityKorn.e j) (F i)).toLp 2 (volume.restrict Ω) x
rw [hz,ElasticityKorn.d_apply]
change jetEntry Ω i j u x = fderiv ℝ (fun y => (f y) i) x (coordVector j)
rw [coordDeriv_scalar f hs i j x,hx,hy]
end Elasticity
end
end
section
noncomputable section
open MeasureTheory SchwartzMap Set
open scoped BigOperators
namespace Elasticity
variable {Ω : Set X}
lemma schwartz_d_support (f : SchwartzMap X ℝ) (v : X) :
tsupport (ElasticityKorn.d v f : X → ℝ) ⊆ tsupport (f : X → ℝ) :=
tsupport_fderiv_apply_subset ℝ v
lemma schwartz_strain_support (f g : SchwartzMap X ℝ) (v w : X)
(hf : tsupport (f : X → ℝ) ⊆ Ω) (hg : tsupport (g : X → ℝ) ⊆ Ω) :
tsupport (((1/2 : ℝ) • (ElasticityKorn.d v f+ElasticityKorn.d w g)) : X → ℝ) ⊆ Ω := by
exact (tsupport_smul_subset_right (fun _ : X => (1/2 : ℝ)) _).trans
((tsupport_add _ _).trans (union_subset ((schwartz_d_support f v).trans hf)
((schwartz_d_support g w).trans hg)))
lemma jet_test_energies (u : JetH Ω) (hu : jetEquiv Ω u ∈ TestJets Ω) :
∃ F : Fin 3 → SchwartzMap X ℝ,
(∀ i, tsupport (F i : X → ℝ) ⊆ Ω) ∧
jetValueSq Ω u = ∑ i, ElasticityKorn.norm2 (F i)^2 ∧
jetGradSq Ω u = ElasticityKorn.gradEnergy F ∧
jetStrainSq Ω u = ElasticityKorn.strainEnergy F := by
obtain ⟨F,hF,hval,hgrad⟩ := jet_test_representation u hu
refine ⟨F,hF,?_,?_,?_⟩
· unfold jetValueSq
simp_rw [hval]
congr 1
funext i
rw [schwartzR_supported_norm _ (hF i)]
· unfold jetGradSq ElasticityKorn.gradEnergy
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro i _
apply Finset.sum_congr rfl
intro j _
rw [hgrad,schwartzR_supported_norm _ ((schwartz_d_support _ _).trans (hF j))]
· unfold jetStrainSq ElasticityKorn.strainEnergy
apply Finset.sum_congr rfl
intro i _
apply Finset.sum_congr rfl
intro j _
change ‖(1/2 : ℝ) • (jetEntry Ω i j u+jetEntry Ω j i u)‖^2 = _
rw [hgrad,hgrad,← map_add,← map_smul]
rw [schwartzR_supported_norm _ (schwartz_strain_support _ _ _ _ (hF i) (hF j)),add_comm]
lemma test_korn (u : JetH Ω) (hu : jetEquiv Ω u ∈ TestJets Ω) :
jetGradSq Ω u ≤ 2*jetStrainSq Ω u := by
obtain ⟨F,_,_,hg,hs⟩ := jet_test_energies u hu
rw [hg,hs]
exact ElasticityKorn.korn F
lemma test_poincare {R : ℝ} (hR : 0 < R) (hbound : ∀ x ∈ Ω, |x 0| ≤ R)
(u : JetH Ω) (hu : jetEquiv Ω u ∈ TestJets Ω) :
jetValueSq Ω u ≤ 4*R^2*jetGradSq Ω u := by
obtain ⟨F,hF,hv,hg,_⟩ := jet_test_energies u hu
rw [hv,hg,ElasticityKorn.gradEnergy,Finset.sum_comm,Finset.mul_sum]
apply Finset.sum_le_sum
intro i _
have hp := ElasticityKorn.poincare (F i) (fun x hx =>
hbound x (hF i (subset_tsupport _ hx)))
have hsq : ElasticityKorn.norm2 (F i)^2 ≤
4*R^2*ElasticityKorn.norm2 (ElasticityKorn.d (ElasticityKorn.e 0) (F i))^2 := by
have := sq_le_sq₀ (norm_nonneg (ElasticityKorn.L2 (F i)))
(show 0 ≤ 2*R*ElasticityKorn.norm2 (ElasticityKorn.d (ElasticityKorn.e 0) (F i)) by
exact mul_nonneg (by positivity) (norm_nonneg _))
have ht : ElasticityKorn.norm2 (F i)^2 ≤
(2*R*ElasticityKorn.norm2 (ElasticityKorn.d (ElasticityKorn.e 0) (F i)))^2 := this.mpr hp
nlinarith [ht]
refine hsq.trans (mul_le_mul_of_nonneg_left ?_ (by positivity))
exact Finset.single_le_sum
(fun j _ => sq_nonneg (ElasticityKorn.norm2 (ElasticityKorn.d (ElasticityKorn.e j) (F i))))
(Finset.mem_univ (0 : Fin 3))
lemma h10_induction_closed {P : JetH Ω → Prop} (hP : IsClosed {u | P u})
(htest : ∀ u, jetEquiv Ω u ∈ TestJets Ω → P u)
(u : H10Hilbert Ω) : P u := by
have hclosed : IsClosed {v : Ambient Ω | P ((jetEquiv Ω).symm v)} :=
hP.preimage (jetEquiv Ω).symm.continuous
have hsubset : closure (TestJets Ω) ⊆ {v : Ambient Ω | P ((jetEquiv Ω).symm v)} :=
closure_minimal (fun v hv => htest _ (by simpa using hv)) hclosed
have h := hsubset u.property
change P ((jetEquiv Ω).symm (jetEquiv Ω u.val)) at h
simpa only [ContinuousLinearEquiv.symm_apply_apply] using h
lemma h10_korn (u : H10Hilbert Ω) : jetGradSq Ω u ≤ 2*jetStrainSq Ω u := by
apply h10_induction_closed
(isClosed_le continuous_jetGradSq (continuous_const.mul continuous_jetStrainSq))
test_korn u
lemma h10_poincare {R : ℝ} (hR : 0 < R) (hbound : ∀ x ∈ Ω, |x 0| ≤ R)
(u : H10Hilbert Ω) : jetValueSq Ω u ≤ 4*R^2*jetGradSq Ω u := by
apply h10_induction_closed
(isClosed_le continuous_jetValueSq (continuous_const.mul continuous_jetGradSq))
(test_poincare hR hbound) u
lemma h10_norm_strain (hB : Bornology.IsBounded Ω) :
∃ C : ℝ, 0 < C ∧ ∀ u : H10Hilbert Ω, ‖u‖^2 ≤ C*jetStrainSq Ω u := by
obtain ⟨R,hR,hbound⟩ := hB.exists_pos_norm_le
have hb (x : X) (hx : x ∈ Ω) : |x 0| ≤ R := by
have hn : |x 0| ≤ ‖x‖ := by
simpa only [Real.norm_eq_abs] using PiLp.norm_apply_le x 0
exact hn.trans (hbound x hx)
refine ⟨2*(4*R^2+1),by positivity,?_⟩
intro u
have hp := h10_poincare hR hb u
have hk := h10_korn u
have he := jet_norm_sq u.val
have hh : 0 ≤ 4*R^2+1 := by positivity
have := mul_le_mul_of_nonneg_left hk hh
change ‖u.val‖^2 ≤ _
nlinarith
end Elasticity
end
end
section
noncomputable section
open MeasureTheory Set
open scoped BigOperators
namespace Elasticity
variable {Ω : Set X}
lemma SmoothUpTo.continuousOn_closure {a : X → ℝ} (ha : SmoothUpTo Ω a) :
ContinuousOn a (closure Ω) := by
obtain ⟨U,_,hs,hf⟩ := ha
exact hf.continuousOn.mono hs
lemma SmoothUpTo.boundedCoefficient {a : X → ℝ} (ha : SmoothUpTo Ω a)
(hO : IsOpen Ω) (hB : Bornology.IsBounded Ω) : BoundedCoefficient Ω a := by
have hc := ha.continuousOn_closure
refine ⟨(hc.mono subset_closure).aestronglyMeasurable hO.measurableSet, ?_⟩
obtain ⟨C,hC⟩ := hB.isCompact_closure.bddAbove_image hc.norm
refine ⟨C, ?_⟩
filter_upwards [self_mem_ae_restrict hO.measurableSet] with x hx
exact hC ⟨x,subset_closure hx,rfl⟩
lemma Admissible.uniform_positive {lam mu : X → ℝ} (ha : Admissible Ω lam mu)
(hB : Bornology.IsBounded Ω) :
∃ c : ℝ, 0 < c ∧ ∀ x ∈ closure Ω, c ≤ mu x ∧ c ≤ 3*lam x+2*mu x := by
have hl := ha.1.continuousOn_closure
have hm := ha.2.1.continuousOn_closure
have hp : ContinuousOn (fun x => min (mu x) (3*lam x+2*mu x)) (closure Ω) :=
hm.inf ((hl.const_mul 3).add (hm.const_mul 2))
obtain ⟨c,hc,hbound⟩ := hB.isCompact_closure.exists_forall_le' hp
(fun x hx => lt_min (ha.2.2 x hx).1 (ha.2.2 x hx).2)
exact ⟨c,hc,fun x hx => le_min_iff.mp (hbound x hx)⟩
lemma trace_sq_le (A : Fin 3 → Fin 3 → ℝ) :
(∑ i, A i i)^2 ≤ 3*∑ i, ∑ j, A i j^2 := by
have ht : (∑ i, A i i)^2 ≤ 3*∑ i, A i i^2 := by
simpa using (sq_sum_le_card_mul_sum_sq (s := Finset.univ) (f := fun i => A i i))
refine ht.trans (mul_le_mul_of_nonneg_left ?_ (by norm_num))
apply Finset.sum_le_sum
intro i _
exact Finset.single_le_sum (fun j _ => sq_nonneg (A i j)) (Finset.mem_univ i)
/-- Pointwise strong convexity controls the full physical symmetric strain,
including negative lambda. This uses the exact hypothesis 3λ+2μ>0. -/
lemma elasticity_density_lower (lam mu c : ℝ) (hc : 0 ≤ c) (hm : c ≤ mu)
(hlm : c ≤ 3*lam+2*mu) (A : Fin 3 → Fin 3 → ℝ) :
c*(∑ i, ∑ j, A i j^2) ≤ lam*(∑ i, A i i)^2+2*mu*(∑ i, ∑ j, A i j^2) := by
have hA : 0 ≤ ∑ i, ∑ j, A i j^2 :=
Finset.sum_nonneg (fun i _ => Finset.sum_nonneg (fun j _ => sq_nonneg (A i j)))
by_cases hl : 0 ≤ lam
· have h1 := mul_nonneg hl (sq_nonneg (∑ i, A i i))
have h2 := mul_le_mul_of_nonneg_right hm hA
have h3 := mul_nonneg (hc.trans hm) hA
nlinarith
· have ht := mul_le_mul_of_nonpos_left (trace_sq_le A) (le_of_not_ge hl)
have hk := mul_le_mul_of_nonneg_right hlm hA
nlinarith
lemma weighted_integrable {a : X → ℝ} (ha : BoundedCoefficient Ω a)
(f g : ScalarL2 Ω) : Integrable (fun x => a x*f x*g x) (volume.restrict Ω) := by
simpa only [Pi.mul_def] using (ha.mul_memLp f).integrable_mul (Lp.memLp g)
lemma jetEnergy_integral {lam mu : X → ℝ} (hl : BoundedCoefficient Ω lam)
(hm : BoundedCoefficient Ω mu) (u v : JetH Ω) :
jetEnergy hl hm u v = ∫ x, lam x*jetDiv Ω u x*jetDiv Ω v x+
2*mu x*∑ i, ∑ j, jetStrain Ω i j u x*jetStrain Ω i j v x ∂(volume.restrict Ω) := by
have hL := weighted_integrable hl (jetDiv Ω u) (jetDiv Ω v)
have hS (i j) := weighted_integrable hm (jetStrain Ω i j u) (jetStrain Ω i j v)
rw [jetEnergy_apply,BoundedCoefficient.inner_mulL]
simp_rw [BoundedCoefficient.inner_mulL]
have hsum : Integrable (fun x => ∑ i, ∑ j,
mu x*jetStrain Ω i j u x*jetStrain Ω i j v x) (volume.restrict Ω) :=
integrable_finsetSum _ (fun i _ => integrable_finsetSum _ (fun j _ => hS i j))
calc
_ = (∫ x, lam x*jetDiv Ω u x*jetDiv Ω v x ∂(volume.restrict Ω))+
2*(∫ x, ∑ i, ∑ j, mu x*jetStrain Ω i j u x*jetStrain Ω i j v x
∂(volume.restrict Ω)) := by
rw [integral_finsetSum _ (fun i _ =>
integrable_finsetSum _ (fun j _ => hS i j))]
simp_rw [integral_finsetSum _ (fun j _ => hS _ j)]
_ = ∫ x, lam x*jetDiv Ω u x*jetDiv Ω v x+
2*(∑ i, ∑ j, mu x*jetStrain Ω i j u x*jetStrain Ω i j v x)
∂(volume.restrict Ω) := by
rw [integral_add hL (hsum.const_mul 2),integral_const_mul]
_ = _ := by
apply integral_congr_ae
exact Filter.Eventually.of_forall (fun x => by
simp only [Finset.mul_sum,mul_assoc])
lemma jetEnergy_eq_energy {lam mu : X → ℝ} (hl : BoundedCoefficient Ω lam)
(hm : BoundedCoefficient Ω mu) (u v : H1Hilbert Ω) :
jetEnergy hl hm u v = energy Ω lam mu (h1Equiv Ω u) (h1Equiv Ω v) := by
rw [jetEnergy_integral,energy]
apply integral_congr_ae
have hsu : ∀ᵐ x ∂(volume.restrict Ω), ∀ i j,
jetStrain Ω i j u.val x=((u.val (some j) x) i+(u.val (some i) x) j)/2 :=
Filter.eventually_all.mpr (fun i => Filter.eventually_all.mpr (fun j => jetStrain_ae u.val i j))
have hsv : ∀ᵐ x ∂(volume.restrict Ω), ∀ i j,
jetStrain Ω i j v.val x=((v.val (some j) x) i+(v.val (some i) x) j)/2 :=
Filter.eventually_all.mpr (fun i => Filter.eventually_all.mpr (fun j => jetStrain_ae v.val i j))
filter_upwards [jetDiv_ae u.val,jetDiv_ae v.val,hsu,hsv] with x hu hv hsu hsv
simp only [hu,hv,hsu,hsv,div,strain,h1Equiv,Equiv.coe_fn_mk,jetEquiv_apply]
end Elasticity
end
end
section
noncomputable section
open MeasureTheory Set
open scoped BigOperators
namespace Elasticity
variable {Ω : Set X} {lam mu : X → ℝ}
lemma scalarL2_norm_sq (f : ScalarL2 Ω) :
‖f‖^2 = ∫ x, (f x)^2 ∂(volume.restrict Ω) := by
rw [← real_inner_self_eq_norm_sq,L2.inner_def]
simp only [real_inner_self_eq_norm_sq,Real.norm_eq_abs,sq_abs]
lemma scalarL2_integrable_sq (f : ScalarL2 Ω) :
Integrable (fun x => (f x)^2) (volume.restrict Ω) := by
simpa only [real_inner_self_eq_norm_sq,Real.norm_eq_abs,sq_abs] using
L2.integrable_inner (𝕜 := ℝ) f f
lemma jetDiv_strain_ae (u : JetH Ω) :
jetDiv Ω u =ᵐ[volume.restrict Ω] fun x => ∑ i, jetStrain Ω i i u x := by
have hs : ∀ᵐ x ∂(volume.restrict Ω), ∀ i,
jetStrain Ω i i u x=((u (some i) x) i+(u (some i) x) i)/2 :=
Filter.eventually_all.mpr (fun i => jetStrain_ae u i i)
filter_upwards [jetDiv_ae u,hs] with x hx hy
rw [hx]
apply Finset.sum_congr rfl
intro i _
rw [hy]
ring
lemma jetStrainSq_integral (u : JetH Ω) :
jetStrainSq Ω u = ∫ x, ∑ i, ∑ j, (jetStrain Ω i j u x)^2 ∂(volume.restrict Ω) := by
unfold jetStrainSq
simp_rw [scalarL2_norm_sq]
rw [integral_finsetSum _ (fun i _ =>
integrable_finsetSum _ (fun j _ => scalarL2_integrable_sq _))]
simp_rw [integral_finsetSum _ (fun j _ => scalarL2_integrable_sq _)]
lemma jetEnergy_lower (hl : BoundedCoefficient Ω lam) (hm : BoundedCoefficient Ω mu)
(hO : IsOpen Ω) {c : ℝ} (hc : 0 ≤ c)
(hp : ∀ x ∈ Ω, c ≤ mu x ∧ c ≤ 3*lam x+2*mu x) (u : JetH Ω) :
c*jetStrainSq Ω u ≤ jetEnergy hl hm u u := by
rw [jetStrainSq_integral,jetEnergy_integral,← integral_const_mul]
have hS : Integrable (fun x => ∑ i, ∑ j, (jetStrain Ω i j u x)^2)
(volume.restrict Ω) :=
integrable_finsetSum _ (fun i _ =>
integrable_finsetSum _ (fun j _ => scalarL2_integrable_sq _))
have hR : Integrable (fun x => lam x*jetDiv Ω u x*jetDiv Ω u x+
2*mu x*∑ i, ∑ j, jetStrain Ω i j u x*jetStrain Ω i j u x)
(volume.restrict Ω) := by
have hsum := (integrable_finsetSum Finset.univ (fun i _ =>
integrable_finsetSum Finset.univ (fun j _ =>
weighted_integrable hm (jetStrain Ω i j u) (jetStrain Ω i j u)))).const_mul 2
convert (weighted_integrable hl (jetDiv Ω u) (jetDiv Ω u)).add hsum using 1
ext point
simp only [Finset.mul_sum,mul_assoc,Pi.add_apply]
apply integral_mono_ae (hS.const_mul c) hR
filter_upwards [self_mem_ae_restrict hO.measurableSet,jetDiv_strain_ae u] with x hx hd
have h := elasticity_density_lower (lam x) (mu x) c hc (hp x hx).1 (hp x hx).2
(fun i j => jetStrain Ω i j u x)
simpa only [hd,sq,mul_assoc] using h
/-- The actual Dirichlet physical energy on the exact zero-trace Hilbert space. -/
def zeroTraceEnergy (hl : BoundedCoefficient Ω lam) (hm : BoundedCoefficient Ω mu) :
H10Hilbert Ω →L[ℝ] H10Hilbert Ω →L[ℝ] ℝ :=
(jetEnergy hl hm).bilinearComp (H10Hilbert Ω).subtypeL (H10Hilbert Ω).subtypeL
lemma zeroTraceEnergy_apply (hl : BoundedCoefficient Ω lam) (hm : BoundedCoefficient Ω mu)
(u v : H10Hilbert Ω) : zeroTraceEnergy hl hm u v = jetEnergy hl hm u.val v.val := rfl
/-- Korn, supported Poincare and the exact strong convexity yield coercivity;
there is no sign restriction on lambda beyond 3 lambda + 2 mu > 0. -/
theorem physical_coercive (ha : Admissible Ω lam mu) (hO : IsOpen Ω)
(hB : Bornology.IsBounded Ω) :
IsCoercive (zeroTraceEnergy (ha.1.boundedCoefficient hO hB)
(ha.2.1.boundedCoefficient hO hB)) := by
obtain ⟨c,hc,hp⟩ := ha.uniform_positive hB
obtain ⟨C,hC,hbound⟩ := h10_norm_strain hB
refine ⟨c/C,div_pos hc hC,?_⟩
intro u
have hlower := jetEnergy_lower (ha.1.boundedCoefficient hO hB)
(ha.2.1.boundedCoefficient hO hB) hO hc.le (fun x hx => hp x (subset_closure hx)) u.val
have hn := mul_le_mul_of_nonneg_left (hbound u) (div_pos hc hC).le
rw [zeroTraceEnergy_apply]
have he : c/C*C=c := div_mul_cancel₀ c (ne_of_gt hC)
have hprod : c/C*‖u‖^2 ≤ c*jetStrainSq Ω u := by
simpa only [← mul_assoc,he] using hn
nlinarith
end Elasticity
end
end
section
noncomputable section
open MeasureTheory Set
open scoped BigOperators
namespace Elasticity
variable {Ω : Set X} {lam mu : X → ℝ}
def traceSetoid (Ω : Set X) : Setoid (H1 Ω) where
r := SameTrace Ω
iseqv := ⟨sameTrace_refl Ω,fun h => sameTrace_symm Ω h,fun h h' => sameTrace_trans Ω h h'⟩
lemma trace_eq_iff (u v : H1 Ω) : trace Ω u = trace Ω v ↔ SameTrace Ω u v := by
exact ⟨fun h => Quotient.exact (s := traceSetoid Ω) h, Quot.sound⟩
lemma hasZeroTrace_h1Equiv (u : H1Hilbert Ω) :
HasZeroTrace Ω (h1Equiv Ω u) ↔ u.val ∈ H10Hilbert Ω := Iff.rfl
lemma sameTrace_h1Equiv (u v : H1Hilbert Ω) :
SameTrace Ω (h1Equiv Ω u) (h1Equiv Ω v) ↔ u.val-v.val ∈ H10Hilbert Ω := by
change (jetEquiv Ω u.val-jetEquiv Ω v.val ∈ h10Submodule Ω) ↔
jetEquiv Ω (u.val-v.val) ∈ h10Submodule Ω
rw [map_sub]
lemma weakSolution_h1Equiv (hl : BoundedCoefficient Ω lam) (hm : BoundedCoefficient Ω mu)
(u : H1Hilbert Ω) : WeakSolution Ω lam mu (h1Equiv Ω u) ↔
∀ v : H10Hilbert Ω, jetEnergy hl hm u.val v.val=0 := by
constructor
· intro h v
let v' : H1Hilbert Ω := ⟨v.val,H10Hilbert_le Ω v.property⟩
exact (jetEnergy_eq_energy hl hm u v').trans (h _ v.property)
· intro h v hv
let v' := (h1Equiv Ω).symm v
have hz : v'.val ∈ H10Hilbert Ω := by
rw [← hasZeroTrace_h1Equiv]
simpa only [v',Equiv.apply_symm_apply] using hv
have he := jetEnergy_eq_energy hl hm u v'
simp only [v',Equiv.apply_symm_apply] at he
rw [← he]
exact h ⟨v'.val,hz⟩
/-- Lax--Milgram applied to the actual physical form and the exact jet
closures. The prescribed trace is arbitrary, not restricted to smooth data. -/
theorem dirichlet_exists (ha : Admissible Ω lam mu) (hO : IsOpen Ω)
(hB : Bornology.IsBounded Ω) (f : BoundaryData Ω) :
∃ u : H1 Ω, trace Ω u=f ∧ WeakSolution Ω lam mu u := by
let hl := ha.1.boundedCoefficient hO hB
let hm := ha.2.1.boundedCoefficient hO hB
let w := (h1Equiv Ω).symm f.out
let L : H10Hilbert Ω →L[ℝ] ℝ := -(jetEnergy hl hm w.val).comp (H10Hilbert Ω).subtypeL
let F := (InnerProductSpace.toDual ℝ (H10Hilbert Ω)).symm L
have hC : IsCoercive (zeroTraceEnergy hl hm) := physical_coercive ha hO hB
let z := hC.continuousLinearEquivOfBilin.symm F
have hz (v : H10Hilbert Ω) : jetEnergy hl hm z.val v.val = -jetEnergy hl hm w.val v.val := by
rw [← zeroTraceEnergy_apply,← hC.continuousLinearEquivOfBilin_apply]
change inner ℝ (hC.continuousLinearEquivOfBilin (hC.continuousLinearEquivOfBilin.symm F)) v = _
rw [ContinuousLinearEquiv.apply_symm_apply]
exact InnerProductSpace.toDual_symm_apply
let u : H1Hilbert Ω := ⟨w.val+z.val,
(H1Hilbert Ω).add_mem w.property (H10Hilbert_le Ω z.property)⟩
refine ⟨h1Equiv Ω u,?_,?_⟩
· have ht : SameTrace Ω (h1Equiv Ω u) (h1Equiv Ω w) := by
apply (sameTrace_h1Equiv u w).mpr
change w.val+z.val-w.val ∈ H10Hilbert Ω
simpa only [add_sub_cancel_left] using z.property
calc
trace Ω (h1Equiv Ω u) = trace Ω (h1Equiv Ω w) := Quot.sound ht
_ = trace Ω f.out := by rw [Equiv.apply_symm_apply]
_ = f := Quot.out_eq f
· apply (weakSolution_h1Equiv hl hm u).mpr
intro v
change jetEnergy hl hm (w.val+z.val) v.val = 0
rw [map_add,add_apply,hz]
exact add_neg_cancel _
theorem dirichletSolution_spec (ha : Admissible Ω lam mu) (hO : IsOpen Ω)
(hB : Bornology.IsBounded Ω) (f : BoundaryData Ω) :
trace Ω (dirichletSolution Ω lam mu f)=f ∧
WeakSolution Ω lam mu (dirichletSolution Ω lam mu f) := by
have hex := dirichlet_exists ha hO hB f
simp only [dirichletSolution,dite_eq_left hex]
exact Classical.choose_spec hex
theorem dirichlet_unique (ha : Admissible Ω lam mu) (hO : IsOpen Ω)
(hB : Bornology.IsBounded Ω) (u v : H1 Ω)
(hu : WeakSolution Ω lam mu u) (hv : WeakSolution Ω lam mu v)
(ht : trace Ω u=trace Ω v) : u=v := by
let hl := ha.1.boundedCoefficient hO hB
let hm := ha.2.1.boundedCoefficient hO hB
let u' := (h1Equiv Ω).symm u
let v' := (h1Equiv Ω).symm v
have htu : SameTrace Ω (h1Equiv Ω u') (h1Equiv Ω v') := by
simpa only [u',v',Equiv.apply_symm_apply] using (trace_eq_iff u v).mp ht
let z : H10Hilbert Ω := ⟨u'.val-v'.val,(sameTrace_h1Equiv u' v').mp htu⟩
have hu' : ∀ w : H10Hilbert Ω, jetEnergy hl hm u'.val w.val=0 :=
(weakSolution_h1Equiv hl hm u').mp (by simpa only [u',Equiv.apply_symm_apply] using hu)
have hv' : ∀ w : H10Hilbert Ω, jetEnergy hl hm v'.val w.val=0 :=
(weakSolution_h1Equiv hl hm v').mp (by simpa only [v',Equiv.apply_symm_apply] using hv)
have hz : zeroTraceEnergy hl hm z z=0 := by
change jetEnergy hl hm (u'.val-v'.val) z.val=0
rw [map_sub (jetEnergy hl hm) u'.val v'.val,sub_apply,hu',hv',sub_self]
obtain ⟨c,hc,hbound⟩ := physical_coercive ha hO hB
have hn : ‖z‖=0 := by
have hh := hbound z
rw [hz] at hh
have hs : ‖z‖*‖z‖ ≤ 0 := (mul_le_mul_iff_right₀ hc).mp (by nlinarith only [hh])
nlinarith [norm_nonneg z]
have he : u'=v' := by
apply Subtype.ext
have hval := congrArg Subtype.val (norm_eq_zero.mp hn)
change u'.val-v'.val=0 at hval
exact sub_eq_zero.mp hval
exact (h1Equiv Ω).symm.injective he
end Elasticity
end
end
section
noncomputable section
open MeasureTheory Set
open scoped BigOperators
namespace Elasticity
variable {Ω : Set X} {lam mu : X → ℝ}
lemma jetEnergy_symm (hl : BoundedCoefficient Ω lam) (hm : BoundedCoefficient Ω mu)
(u v : JetH Ω) : jetEnergy hl hm u v=jetEnergy hl hm v u := by
rw [jetEnergy_integral,jetEnergy_integral]
apply integral_congr_ae
exact Filter.Eventually.of_forall (fun x => by
have hs : (∑ i, ∑ j, jetStrain Ω i j u x*jetStrain Ω i j v x)=
∑ i, ∑ j, jetStrain Ω i j v x*jetStrain Ω i j u x := by
apply Finset.sum_congr rfl
intro i _
apply Finset.sum_congr rfl
intro j _
exact mul_comm _ _
dsimp only
rw [hs]
ring)
lemma energy_symm (hl : BoundedCoefficient Ω lam) (hm : BoundedCoefficient Ω mu)
(u v : H1 Ω) : energy Ω lam mu u v=energy Ω lam mu v u := by
have h := jetEnergy_symm hl hm ((h1Equiv Ω).symm u).val ((h1Equiv Ω).symm v).val
rwa [jetEnergy_eq_energy,jetEnergy_eq_energy,Equiv.apply_symm_apply,
Equiv.apply_symm_apply] at h
lemma energy_eq_of_sameTrace (hl : BoundedCoefficient Ω lam) (hm : BoundedCoefficient Ω mu)
{u v w : H1 Ω} (hu : WeakSolution Ω lam mu u) (hvw : SameTrace Ω v w) :
energy Ω lam mu u v=energy Ω lam mu u w := by
let u' := (h1Equiv Ω).symm u
let v' := (h1Equiv Ω).symm v
let w' := (h1Equiv Ω).symm w
have ht : v'.val-w'.val ∈ H10Hilbert Ω :=
(sameTrace_h1Equiv v' w').mp (by simpa only [v',w',Equiv.apply_symm_apply] using hvw)
have he := (weakSolution_h1Equiv hl hm u').mp (by
simpa only [u',Equiv.apply_symm_apply] using hu) ⟨v'.val-w'.val,ht⟩
change jetEnergy hl hm u'.val (v'.val-w'.val)=0 at he
rw [map_sub] at he
have hv' := jetEnergy_eq_energy hl hm u' v'
have hw' := jetEnergy_eq_energy hl hm u' w'
simp only [u',v',w',Equiv.apply_symm_apply] at hv' hw'
rw [hv',hw'] at he
exact sub_eq_zero.mp he
lemma DN_eq_energy (ha : Admissible Ω lam mu) (hO : IsOpen Ω)
(hB : Bornology.IsBounded Ω) (f : BoundaryData Ω) (v : H1 Ω) :
DN Ω lam mu f (trace Ω v)=energy Ω lam mu (dirichletSolution Ω lam mu f) v := by
apply energy_eq_of_sameTrace (ha.1.boundedCoefficient hO hB)
(ha.2.1.boundedCoefficient hO hB) (dirichletSolution_spec ha hO hB f).2
apply (trace_eq_iff _ _).mp
exact Quot.out_eq (trace Ω v)
lemma solution_eq_dirichlet (ha : Admissible Ω lam mu) (hO : IsOpen Ω)
(hB : Bornology.IsBounded Ω) {u : H1 Ω} (hu : WeakSolution Ω lam mu u) :
u=dirichletSolution Ω lam mu (trace Ω u) :=
dirichlet_unique ha hO hB _ _ hu (dirichletSolution_spec ha hO hB _).2
(dirichletSolution_spec ha hO hB _).1.symm
theorem interior_physical_transfer {lam₁ mu₁ lam₂ mu₂ : X → ℝ}
(ha₁ : Admissible Ω lam₁ mu₁) (ha₂ : Admissible Ω lam₂ mu₂)
(hO : IsOpen Ω) (hB : Bornology.IsBounded Ω)
(hDN : DN Ω lam₁ mu₁=DN Ω lam₂ mu₂)
{u₁ : H1 Ω} (hu₁ : WeakSolution Ω lam₁ mu₁ u₁) :
∃ u₂ : H1 Ω, WeakSolution Ω lam₂ mu₂ u₂ ∧ trace Ω u₂=trace Ω u₁ ∧
∀ v : H1 Ω, energy Ω lam₂ mu₂ u₂ v=energy Ω lam₁ mu₁ u₁ v := by
let u₂ := dirichletSolution Ω lam₂ mu₂ (trace Ω u₁)
have hs := dirichletSolution_spec ha₂ hO hB (trace Ω u₁)
refine ⟨u₂,hs.2,hs.1,?_⟩
intro v
rw [← DN_eq_energy ha₂ hO hB,← hDN,DN_eq_energy ha₁ hO hB]
rw [← solution_eq_dirichlet ha₁ hO hB hu₁]
end Elasticity
end
end
end OAI
import OAI.MathematicalPhysics.Elasticity.Basic
namespace OAI
section
noncomputable section
open MeasureTheory Set
open scoped BigOperators
namespace Elasticity
open scoped BigOperators
lemma coordDeriv_add {f g : X → V} (hf : Differentiable ℝ f)
(hg : Differentiable ℝ g) (i : Fin 3) :
coordDeriv (f+g) i = coordDeriv f i + coordDeriv g i := by
funext x
exact congrArg (fun L : X →L[ℝ] V => L (coordVector i))
(fderiv_add (hf x) (hg x))
lemma coordDeriv_smul (c : ℝ) {f : X → V} (hf : Differentiable ℝ f)
(i : Fin 3) : coordDeriv (c • f) i = c • coordDeriv f i := by
funext x
exact congrArg (fun L : X →L[ℝ] V => L (coordVector i))
(fderiv_const_smul (hf x) c)
lemma coordDeriv_zero (i : Fin 3) : coordDeriv (0 : X → V) i = 0 := by
ext x j
simp [coordDeriv]
def smoothJetSubmodule (Ω : Set X) : Submodule ℝ (Ambient Ω) where
carrier := SmoothJets Ω
zero_mem' := by
refine ⟨0, MemLp.zero, fun i => ?_, contDiff_const, ?_, ?_⟩
· simpa only [coordDeriv_zero] using (MemLp.zero : MemLp (0 : X → V) 2 (volume.restrict Ω))
· simp
· funext i
change 0 = _
simp only [coordDeriv_zero, MemLp.toLp_zero]
add_mem' := by
rintro u v ⟨f, hf, hd, hs, hu, hud⟩ ⟨g, hg, he, ht, hv, hvd⟩
have hb (i) : MemLp (coordDeriv (f+g) i) 2 (volume.restrict Ω) := by
rw [coordDeriv_add (hs.differentiable (by simp)) (ht.differentiable (by simp))]
exact (hd i).add (he i)
refine ⟨f+g, hf.add hg, hb, hs.add ht, ?_, ?_⟩
· simpa [hu, hv] using (MemLp.toLp_add hf hg).symm
· funext i
simp only [Prod.snd_add, Pi.add_apply, hud, hvd]
simp only [coordDeriv_add (hs.differentiable (by simp)) (ht.differentiable (by simp))]
exact (MemLp.toLp_add (hd i) (he i)).symm
smul_mem' := by
rintro c u ⟨f, hf, hd, hs, hu, hud⟩
have hb (i) : MemLp (coordDeriv (c • f) i) 2 (volume.restrict Ω) := by
rw [coordDeriv_smul c (hs.differentiable (by simp))]
exact (hd i).const_smul c
refine ⟨c • f, hf.const_smul c, hb, hs.const_smul c, ?_, ?_⟩
· simpa [hu] using (MemLp.toLp_const_smul c hf).symm
· funext i
change c • u.2 i = _
rw [hud]
simp only [coordDeriv_smul c (hs.differentiable (by simp))]
exact (MemLp.toLp_const_smul c (hd i)).symm
/-- Compactly supported interior test jets, with the actual support condition. -/
def testJetSubmodule (Ω : Set X) : Submodule ℝ (Ambient Ω) where
carrier := TestJets Ω
zero_mem' := by
refine ⟨0, MemLp.zero, fun i => ?_, contDiff_const, HasCompactSupport.zero, ?_, ?_, ?_⟩
· simpa only [coordDeriv_zero] using (MemLp.zero : MemLp (0 : X → V) 2 (volume.restrict Ω))
· simp
· simp
· funext i
change 0 = _
simp only [coordDeriv_zero, MemLp.toLp_zero]
add_mem' := by
rintro u v ⟨f, hf, hd, hs, hc, hsup, hu, hud⟩ ⟨g, hg, he, ht, hgc, hgsup, hv, hvd⟩
have hb (i) : MemLp (coordDeriv (f+g) i) 2 (volume.restrict Ω) := by
rw [coordDeriv_add (hs.differentiable (by simp)) (ht.differentiable (by simp))]
exact (hd i).add (he i)
refine ⟨f+g, hf.add hg, hb, hs.add ht, hc.add hgc,
(tsupport_add f g).trans (union_subset hsup hgsup), ?_, ?_⟩
· simpa [hu, hv] using (MemLp.toLp_add hf hg).symm
· funext i
simp only [Prod.snd_add, Pi.add_apply, hud, hvd]
simp only [coordDeriv_add (hs.differentiable (by simp)) (ht.differentiable (by simp))]
exact (MemLp.toLp_add (hd i) (he i)).symm
smul_mem' := by
rintro c u ⟨f, hf, hd, hs, hc, hsup, hu, hud⟩
have hb (i) : MemLp (coordDeriv (c • f) i) 2 (volume.restrict Ω) := by
rw [coordDeriv_smul c (hs.differentiable (by simp))]
exact (hd i).const_smul c
refine ⟨c • f, hf.const_smul c, hb, hs.const_smul c, (hc.smul_left : HasCompactSupport ((fun _ : X => c) • f)),
(tsupport_smul_subset_right (fun _ : X => c) f).trans hsup, ?_, ?_⟩
· simpa [hu] using (MemLp.toLp_const_smul c hf).symm
· funext i
change c • u.2 i = _
rw [hud]
simp only [coordDeriv_smul c (hs.differentiable (by simp))]
exact (MemLp.toLp_const_smul c (hd i)).symm