| import OAI.MathematicalPhysics.Elasticity.Variational |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open MeasureTheory Set |
| open scoped ENNReal |
| namespace Elasticity |
| variable {α E : Type*} [MeasurableSpace α] [NormedAddCommGroup E] [NormedSpace ℝ E] |
| variable (μ : Measure α) (s : Set α) |
| def lpRestrictCLM : Lp E 2 μ →L[ℝ] Lp E 2 (μ.restrict s) := |
| Lp.LpToLpOfMeasureLeSMul (c := 1) (by simp) (by simpa using Measure.restrict_le_self (μ := μ) (s := s)) |
| lemma lpRestrict_coe (f : Lp E 2 μ) : (lpRestrictCLM μ s f : α → E)=ᵐ[μ.restrict s] f := |
| Lp.coeFn_LpToLpOfMeasureLeSMul _ _ f |
| variable (hs : MeasurableSet s) |
| def lpZeroValue (f : Lp E 2 (μ.restrict s)) : Lp E 2 μ := |
| ((memLp_indicator_iff_restrict hs).mpr (Lp.memLp f)).toLp (s.indicator f) |
| omit [NormedSpace ℝ E] in |
| lemma lpZeroValue_coe (f : Lp E 2 (μ.restrict s)) : |
| (lpZeroValue μ s hs f : α → E)=ᵐ[μ] s.indicator f := by |
| unfold lpZeroValue |
| exact @MemLp.coeFn_toLp α E _ 2 μ _ (s.indicator (⇑f)) |
| ((memLp_indicator_iff_restrict (p := 2) (μ := μ) hs).mpr (Lp.memLp f)) |
| omit [NormedSpace ℝ E] in |
| lemma lpZeroValue_add (f g : Lp E 2 (μ.restrict s)) : |
| lpZeroValue μ s hs (f+g)=lpZeroValue μ s hs f+lpZeroValue μ s hs g := by |
| apply Lp.ext |
| filter_upwards [lpZeroValue_coe μ s hs (f+g),lpZeroValue_coe μ s hs f, |
| lpZeroValue_coe μ s hs g,Lp.coeFn_add (lpZeroValue μ s hs f) (lpZeroValue μ s hs g), |
| (ae_restrict_iff' hs).mp (Lp.coeFn_add f g)] with x h1 h2 h3 h4 h5 |
| rw [h1,h4] |
| change s.indicator (⇑(f+g)) x=lpZeroValue μ s hs f x+lpZeroValue μ s hs g x |
| rw [h2,h3] |
| by_cases hx : x∈s |
| · simp only [indicator_of_mem hx,h5 hx,Pi.add_apply] |
| · simp only [indicator_of_notMem hx,add_zero] |
| lemma lpZeroValue_smul (c : ℝ) (f : Lp E 2 (μ.restrict s)) : |
| lpZeroValue μ s hs (c • f)=c • lpZeroValue μ s hs f := by |
| apply Lp.ext |
| filter_upwards [lpZeroValue_coe μ s hs (c • f),lpZeroValue_coe μ s hs f, |
| Lp.coeFn_smul c (lpZeroValue μ s hs f), |
| (ae_restrict_iff' hs).mp (Lp.coeFn_smul c f)] with x h1 h2 h3 h4 |
| rw [h1,h3] |
| change s.indicator (⇑(c • f)) x=c • lpZeroValue μ s hs f x |
| rw [h2] |
| by_cases hx : x∈s |
| · simp only [indicator_of_mem hx,h4 hx,Pi.smul_apply] |
| · simp only [indicator_of_notMem hx,smul_zero] |
| def lpZeroExtend : Lp E 2 (μ.restrict s) →ₗ[ℝ] Lp E 2 μ where |
| toFun := lpZeroValue μ s hs |
| map_add' := lpZeroValue_add μ s hs |
| map_smul' := lpZeroValue_smul μ s hs |
| lemma lpZeroExtend_norm (f : Lp E 2 (μ.restrict s)) : ‖lpZeroExtend μ s hs f‖=‖f‖ := by |
| change ‖((memLp_indicator_iff_restrict hs).mpr (Lp.memLp f)).toLp (s.indicator f)‖=‖f‖ |
| rw [Lp.norm_toLp,Lp.norm_def,eLpNorm_indicator_eq_eLpNorm_restrict hs] |
| def lpZeroExtendCLM : Lp E 2 (μ.restrict s) →L[ℝ] Lp E 2 μ := |
| (lpZeroExtend μ s hs).mkContinuous 1 (fun f => by rw [lpZeroExtend_norm,one_mul]) |
| lemma lpZeroExtend_coe (f : Lp E 2 (μ.restrict s)) : |
| (lpZeroExtendCLM μ s hs f : α → E)=ᵐ[μ] s.indicator f := lpZeroValue_coe μ s hs f |
| lemma lpRestrict_zeroExtend (f : Lp E 2 (μ.restrict s)) : |
| lpRestrictCLM μ s (lpZeroExtendCLM μ s hs f)=f := by |
| apply Lp.ext |
| filter_upwards [lpRestrict_coe μ s (lpZeroExtendCLM μ s hs f), |
| ae_restrict_of_ae (lpZeroExtend_coe μ s hs f),ae_restrict_mem hs] with x h1 h2 hx |
| rw [h1,h2,indicator_of_mem hx] |
| end Elasticity |
|
|
| end |
| end |
| section |
| noncomputable section |
| open MeasureTheory Set |
| namespace Elasticity |
| variable {Ω B : Set X} |
| def lpRestrictBetween (h : Ω⊆B) : Lp V 2 (volume.restrict B) →L[ℝ] Lp V 2 (volume.restrict Ω) := |
| Lp.LpToLpOfMeasureLeSMul (c := 1) (by simp) |
| (by simpa using Measure.restrict_mono h (le_refl (volume : Measure X))) |
| lemma lpRestrictBetween_coe (h : Ω⊆B) (f : Lp V 2 (volume.restrict B)) : |
| (lpRestrictBetween h f : X → V)=ᵐ[volume.restrict Ω] f := |
| Lp.coeFn_LpToLpOfMeasureLeSMul _ _ f |
| lemma lpRestrictBetween_toLp (h : Ω⊆B) (f : X → V) |
| (hf : MemLp f 2 (volume.restrict B)) (hg : MemLp f 2 (volume.restrict Ω)) : |
| lpRestrictBetween h (hf.toLp f)=hg.toLp f := by |
| apply Lp.ext |
| exact (lpRestrictBetween_coe h (hf.toLp f)).trans |
| ((Measure.absolutelyContinuous_of_le (Measure.restrict_mono h (le_refl (volume : Measure X)))).ae_eq hf.coeFn_toLp |>.trans hg.coeFn_toLp.symm) |
| def ambientRestrict (h : Ω⊆B) : Ambient B →L[ℝ] Ambient Ω := |
| (lpRestrictBetween h).prodMap (ContinuousLinearMap.pi |
| (fun i : Fin 3 => (lpRestrictBetween h).comp (ContinuousLinearMap.proj i))) |
| lemma restrict_smoothJet (h : Ω⊆B) {u : Ambient B} (hu : u∈SmoothJets B) : |
| ambientRestrict h u∈SmoothJets Ω := by |
| obtain ⟨f,hf,hd,hsm,hval,hder⟩ := hu |
| have hm : volume.restrict Ω≤volume.restrict B := Measure.restrict_mono h (le_refl (volume : Measure X)) |
| refine ⟨f,hf.mono_measure hm,(fun i => (hd i).mono_measure hm),hsm,?_,?_⟩ |
| · change lpRestrictBetween h u.1=_ |
| rw [hval,lpRestrictBetween_toLp] |
| · funext i |
| change lpRestrictBetween h (u.2 i)=_ |
| rw [hder,lpRestrictBetween_toLp] |
| lemma restrict_h1 (h : Ω⊆B) {u : Ambient B} (hu : u∈closure (SmoothJets B)) : |
| ambientRestrict h u∈closure (SmoothJets Ω) := by |
| exact (show MapsTo (ambientRestrict h) (SmoothJets B) (SmoothJets Ω) from |
| fun _ hu => restrict_smoothJet h hu).closure (ambientRestrict h).continuous hu |
| def h1Restrict (h : Ω⊆B) (u : H1 B) : H1 Ω := ⟨ambientRestrict h u.val,restrict_h1 h u.property⟩ |
| def lpExtendBetween (hΩ : MeasurableSet Ω) : |
| Lp V 2 (volume.restrict Ω) →L[ℝ] Lp V 2 (volume.restrict B) := |
| (lpRestrictCLM volume B).comp (lpZeroExtendCLM volume Ω hΩ) |
| lemma lpExtendBetween_coe (hΩ : MeasurableSet Ω) (f : Lp V 2 (volume.restrict Ω)) : |
| (lpExtendBetween (B := B) hΩ f : X → V)=ᵐ[volume.restrict B] Ω.indicator f := |
| (lpRestrict_coe volume B _).trans (ae_restrict_of_ae (lpZeroExtend_coe volume Ω hΩ f)) |
| lemma lpExtendBetween_toLp (hΩ : MeasurableSet Ω) (f : X → V) (hf : MemLp f 2 (volume.restrict Ω)) |
| (hg : MemLp f 2 (volume.restrict B)) (hs : tsupport f⊆Ω) : |
| lpExtendBetween hΩ (hf.toLp f)=hg.toLp f := by |
| apply Lp.ext |
| have hval : ∀ᵐ x ∂(volume : Measure X), x∈Ω → hf.toLp f x=f x := (ae_restrict_iff' hΩ).mp hf.coeFn_toLp |
| filter_upwards [lpExtendBetween_coe (B := B) hΩ (hf.toLp f), |
| ae_restrict_of_ae hval,hg.coeFn_toLp] with x h1 h2 h3 |
| rw [h1,h3] |
| by_cases hx : x∈Ω |
| · rw [indicator_of_mem hx,h2 hx] |
| · rw [indicator_of_notMem hx,image_eq_zero_of_notMem_tsupport (fun h => hx (hs h))] |
| def ambientExtend (hΩ : MeasurableSet Ω) : Ambient Ω →L[ℝ] Ambient B := |
| (lpExtendBetween hΩ).prodMap (ContinuousLinearMap.pi |
| (fun i : Fin 3 => (lpExtendBetween hΩ).comp (ContinuousLinearMap.proj i))) |
| lemma extend_testJet (hΩ : MeasurableSet Ω) (h : Ω⊆B) {u : Ambient Ω} (hu : u∈TestJets Ω) : |
| ambientExtend (B := B) hΩ u∈TestJets B := by |
| obtain ⟨f,hf,hd,hsm,hc,hs,hval,hder⟩ := hu |
| have hdf (i : Fin 3) : ContDiff ℝ (⊤ : ℕ∞) (coordDeriv f i) := |
| (hsm.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).clm_apply contDiff_const |
| have hcd (i : Fin 3) : HasCompactSupport (coordDeriv f i) := hc.fderiv_apply ℝ _ |
| have hsd (i : Fin 3) : tsupport (coordDeriv f i)⊆Ω := |
| (tsupport_fderiv_apply_subset ℝ (coordVector i)).trans hs |
| have hfg : MemLp f 2 (volume.restrict B) := (hsm.continuous.memLp_of_hasCompactSupport hc).restrict B |
| have hdg (i : Fin 3) : MemLp (coordDeriv f i) 2 (volume.restrict B) := |
| ((hdf i).continuous.memLp_of_hasCompactSupport (hcd i)).restrict B |
| refine ⟨f,hfg,hdg,hsm,hc,hs.trans h,?_,?_⟩ |
| · change lpExtendBetween hΩ u.1=_ |
| rw [hval,lpExtendBetween_toLp hΩ f hf hfg hs] |
| · funext i |
| change lpExtendBetween hΩ (u.2 i)=_ |
| rw [hder,lpExtendBetween_toLp hΩ _ (hd i) (hdg i) (hsd i)] |
| lemma extend_h10 (hΩ : MeasurableSet Ω) (h : Ω⊆B) {u : Ambient Ω} (hu : u∈closure (TestJets Ω)) : |
| ambientExtend (B := B) hΩ u∈closure (TestJets B) := by |
| exact (show MapsTo (ambientExtend (B := B) hΩ) (TestJets Ω) (TestJets B) from |
| fun _ hu => extend_testJet hΩ h hu).closure (ambientExtend hΩ).continuous hu |
| end Elasticity |
|
|
| end |
| end |
| section |
| noncomputable section |
| open MeasureTheory Set |
| open scoped BigOperators |
| namespace Elasticity |
| variable {Ω B : Set X} |
| def gradient (u : Ambient Ω) (x : X) : Fin 3 → V := fun i => u.2 i x |
| def elasticDensity (lam mu : ℝ) (P Q : Fin 3 → V) : ℝ := |
| lam*(∑ i, P i i)*(∑ i, Q i i)+2*mu*∑ i, ∑ j, |
| ((P j i+P i j)/2)*((Q j i+Q i j)/2) |
| def ambientDensity (lam mu : X → ℝ) (u v : Ambient Ω) (x : X) : ℝ := |
| elasticDensity (lam x) (mu x) (gradient u x) (gradient v x) |
| def ambientEnergy (lam mu : X → ℝ) (u v : Ambient Ω) : ℝ := |
| ∫ x, ambientDensity lam mu u v x ∂(volume.restrict Ω) |
| lemma energy_eq_ambient (lam mu : X → ℝ) (u v : H1 Ω) : |
| energy Ω lam mu u v=ambientEnergy lam mu u.val v.val := rfl |
| lemma elasticDensity_symm (a b : ℝ) (P Q : Fin 3 → V) : |
| elasticDensity a b P Q=elasticDensity a b Q P := by |
| unfold elasticDensity |
| have hs : (∑ i, ∑ j, ((P j i+P i j)/2)*((Q j i+Q i j)/2))= |
| ∑ i, ∑ j, ((Q j i+Q i j)/2)*((P j i+P i j)/2) := by |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| exact mul_comm _ _ |
| rw [hs] |
| ring |
| @[simp] lemma elasticDensity_zero_right (a b : ℝ) (P : Fin 3 → V) : |
| elasticDensity a b P 0=0 := by simp [elasticDensity] |
| lemma gradient_restrict (h : Ω⊆B) (u : Ambient B) : |
| (fun x => gradient (ambientRestrict h u) x)=ᵐ[volume.restrict Ω] gradient u := by |
| have he := Filter.eventually_all.mpr (fun i : Fin 3 => lpRestrictBetween_coe h (u.2 i)) |
| filter_upwards [he] with x hx |
| exact funext hx |
| lemma gradient_extend (hΩ : MeasurableSet Ω) (u : Ambient Ω) : |
| (fun x => gradient (ambientExtend (B := B) hΩ u) x)=ᵐ[volume.restrict B] Ω.indicator (gradient u) := by |
| have he := Filter.eventually_all.mpr (fun i : Fin 3 => lpExtendBetween_coe (B := B) hΩ (u.2 i)) |
| filter_upwards [he] with x hx |
| by_cases hm : x∈Ω |
| · rw [indicator_of_mem hm] |
| funext i |
| exact (hx i).trans (indicator_of_mem hm _) |
| · rw [indicator_of_notMem hm] |
| funext i |
| exact (hx i).trans (indicator_of_notMem hm _) |
| lemma entry_memLp (u : Ambient Ω) (i j : Fin 3) : |
| MemLp (fun x => u.2 j x i) 2 (volume.restrict Ω) := |
| (EuclideanSpace.proj i : V →L[ℝ] ℝ).comp_memLp (u.2 j) |
| lemma BoundedCoefficient.mul_memLp_fun {a f : X → ℝ} (ha : BoundedCoefficient Ω a) |
| (hf : MemLp f 2 (volume.restrict Ω)) : MemLp (fun x => a x*f x) 2 (volume.restrict Ω) := by |
| obtain ⟨C,hC⟩ := ha.bound |
| apply hf.of_le_mul (c := C) (ha.measurable.mul hf.aestronglyMeasurable) |
| 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)) |
| lemma ambientDensity_integrable {lam mu : X → ℝ} (hl : BoundedCoefficient Ω lam) |
| (hm : BoundedCoefficient Ω mu) (u v : Ambient Ω) : |
| Integrable (ambientDensity lam mu u v) (volume.restrict Ω) := by |
| have hd (w : Ambient Ω) : MemLp (fun x => ∑ i, w.2 i x i) 2 (volume.restrict Ω) := |
| memLp_finsetSum _ (fun i _ => entry_memLp w i i) |
| have hs (w : Ambient Ω) (i j : Fin 3) : |
| MemLp (fun x => (w.2 j x i+w.2 i x j)/2) 2 (volume.restrict Ω) := |
| by simpa only [div_eq_mul_inv,Pi.add_apply] using |
| ((entry_memLp w i j).add (entry_memLp w j i)).mul_const (2 : ℝ)⁻¹ |
| have hL := (hl.mul_memLp_fun (hd u)).integrable_mul (hd v) |
| have hS (i j) := (hm.mul_memLp_fun (hs u i j)).integrable_mul (hs v i j) |
| have hsum := integrable_finsetSum Finset.univ (fun i _ => |
| integrable_finsetSum Finset.univ (fun j _ => hS i j)) |
| apply (hL.add (hsum.const_mul 2)).congr |
| exact Filter.Eventually.of_forall (fun x => by |
| simp only [ambientDensity,elasticDensity,gradient,Pi.mul_apply,Pi.add_apply,Finset.mul_sum,mul_assoc]) |
| lemma ambientEnergy_symm (lam mu : X → ℝ) (u v : Ambient Ω) : |
| ambientEnergy lam mu u v=ambientEnergy lam mu v u := by |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall (fun x => elasticDensity_symm _ _ _ _) |
| end Elasticity |
|
|
| end |
| end |
| section |
| noncomputable section |
| open MeasureTheory Set |
| open scoped BigOperators |
| namespace Elasticity |
| variable {Ω B : Set X} |
| lemma ambientEnergy_extend_right (hΩ : MeasurableSet Ω) (h : Ω⊆B) |
| (lam mu : X → ℝ) (u : Ambient B) (v : Ambient Ω) : |
| ambientEnergy lam mu u (ambientExtend hΩ v)= |
| ambientEnergy lam mu (ambientRestrict h u) v := by |
| let f := fun x => elasticDensity (lam x) (mu x) (gradient u x) (gradient v x) |
| calc |
| _ = ∫ x, Ω.indicator f x ∂(volume.restrict B) := by |
| apply integral_congr_ae |
| filter_upwards [gradient_extend (B := B) hΩ v] with x hx |
| change elasticDensity _ _ _ _=_ |
| rw [hx] |
| by_cases hm : x∈Ω |
| · simp only [indicator_of_mem hm] |
| rfl |
| · simp only [indicator_of_notMem hm,elasticDensity_zero_right] |
| _ = ∫ x, f x ∂(volume.restrict Ω) := by |
| rw [integral_indicator hΩ,Measure.restrict_restrict hΩ,inter_eq_left.mpr h] |
| _ = _ := by |
| apply integral_congr_ae |
| filter_upwards [gradient_restrict h u] with x hx |
| exact congrArg (fun P => elasticDensity (lam x) (mu x) P (gradient v x)) hx.symm |
| lemma ambientEnergy_extend_left (hΩ : MeasurableSet Ω) (h : Ω⊆B) |
| (lam mu : X → ℝ) (u : Ambient Ω) (v : Ambient B) : |
| ambientEnergy lam mu (ambientExtend hΩ u) v= |
| ambientEnergy lam mu u (ambientRestrict h v) := by |
| rw [ambientEnergy_symm,ambientEnergy_extend_right hΩ h,ambientEnergy_symm] |
| lemma BoundedCoefficient.restrict {a : X → ℝ} (ha : BoundedCoefficient B a) (h : Ω⊆B) : |
| BoundedCoefficient Ω a := by |
| have hm : volume.restrict Ω≤volume.restrict B := Measure.restrict_mono h (le_refl (volume : Measure X)) |
| refine ⟨ha.measurable.mono_measure hm,?_⟩ |
| obtain ⟨C,hC⟩ := ha.bound |
| exact ⟨C,ae_mono hm hC⟩ |
| lemma energy_coefficient_locality {lam₁ mu₁ lam₂ mu₂ : X → ℝ} |
| (hl₁ : BoundedCoefficient B lam₁) (hm₁ : BoundedCoefficient B mu₁) |
| (hl₂ : BoundedCoefficient B lam₂) (hm₂ : BoundedCoefficient B mu₂) |
| (hΩ : MeasurableSet Ω) (h : Ω⊆B) |
| (he : ∀ x∉Ω, lam₁ x=lam₂ x ∧ mu₁ x=mu₂ x) (u v : Ambient B) : |
| ambientEnergy lam₂ mu₂ u v-ambientEnergy lam₁ mu₁ u v= |
| ambientEnergy lam₂ mu₂ (ambientRestrict h u) (ambientRestrict h v)- |
| ambientEnergy lam₁ mu₁ (ambientRestrict h u) (ambientRestrict h v) := by |
| let f := fun x => ambientDensity lam₂ mu₂ u v x-ambientDensity lam₁ mu₁ u v x |
| calc |
| _ = ∫ x, f x ∂(volume.restrict B) := (integral_sub |
| (ambientDensity_integrable hl₂ hm₂ u v) (ambientDensity_integrable hl₁ hm₁ u v)).symm |
| _ = ∫ x, Ω.indicator f x ∂(volume.restrict B) := by |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall (fun x => by |
| by_cases hx : x∈Ω |
| · rw [indicator_of_mem hx] |
| · rw [indicator_of_notMem hx] |
| dsimp [f,ambientDensity] |
| rw [(he x hx).1,(he x hx).2,sub_self]) |
| _ = ∫ x, f x ∂(volume.restrict Ω) := by |
| rw [integral_indicator hΩ,Measure.restrict_restrict hΩ,inter_eq_left.mpr h] |
| _ = ∫ x, ambientDensity lam₂ mu₂ (ambientRestrict h u) (ambientRestrict h v) x- |
| ambientDensity lam₁ mu₁ (ambientRestrict h u) (ambientRestrict h v) x ∂(volume.restrict Ω) := by |
| apply integral_congr_ae |
| filter_upwards [gradient_restrict h u,gradient_restrict h v] with x hu hv |
| simp only [f,ambientDensity,hu,hv] |
| _ = _ := integral_sub (ambientDensity_integrable (hl₂.restrict h) (hm₂.restrict h) _ _) |
| (ambientDensity_integrable (hl₁.restrict h) (hm₁.restrict h) _ _) |
| lemma elasticDensity_add_left (a b : ℝ) (P Q R : Fin 3 → V) : |
| elasticDensity a b (P+Q) R=elasticDensity a b P R+elasticDensity a b Q R := by |
| simp only [elasticDensity,Pi.add_apply,PiLp.add_apply] |
| have he (i j : Fin 3) : ((P j i+Q j i+(P i j+Q i j))/2)*((R j i+R i j)/2)= |
| ((P j i+P i j)/2)*((R j i+R i j)/2)+((Q j i+Q i j)/2)*((R j i+R i j)/2) := by ring |
| simp only [he,Finset.sum_add_distrib] |
| ring |
| lemma gradient_add (u v : Ambient Ω) : |
| gradient (u+v)=ᵐ[volume.restrict Ω] fun x => gradient u x+gradient v x := by |
| have he := Filter.eventually_all.mpr (fun i : Fin 3 => Lp.coeFn_add (u.2 i) (v.2 i)) |
| filter_upwards [he] with x hx |
| exact funext hx |
| lemma ambientEnergy_add_left {lam mu : X → ℝ} (hl : BoundedCoefficient Ω lam) |
| (hm : BoundedCoefficient Ω mu) (u v w : Ambient Ω) : |
| ambientEnergy lam mu (u+v) w=ambientEnergy lam mu u w+ambientEnergy lam mu v w := by |
| rw [ambientEnergy,ambientEnergy,ambientEnergy,← integral_add |
| (ambientDensity_integrable hl hm u w) (ambientDensity_integrable hl hm v w)] |
| apply integral_congr_ae |
| filter_upwards [gradient_add u v] with x hx |
| change elasticDensity _ _ _ _=_ |
| rw [hx,elasticDensity_add_left] |
| rfl |
| lemma ambientEnergy_sub_left {lam mu : X → ℝ} (hl : BoundedCoefficient Ω lam) |
| (hm : BoundedCoefficient Ω mu) (u v w : Ambient Ω) : |
| ambientEnergy lam mu (u-v) w=ambientEnergy lam mu u w-ambientEnergy lam mu v w := by |
| have he := ambientEnergy_add_left hl hm (u-v) v w |
| rw [sub_add_cancel] at he |
| linarith |
| end Elasticity |
|
|
| end |
| end |
| section |
| noncomputable section |
| open MeasureTheory Set |
| namespace Elasticity |
| variable {Ω B : Set X} |
| lemma lpRestrictBetween_extend (hΩ : MeasurableSet Ω) (h : Ω⊆B) |
| (f : Lp V 2 (volume.restrict Ω)) : lpRestrictBetween h (lpExtendBetween hΩ f)=f := by |
| apply Lp.ext |
| have hm : volume.restrict Ω≤volume.restrict B := Measure.restrict_mono h (le_refl (volume : Measure X)) |
| filter_upwards [lpRestrictBetween_coe h (lpExtendBetween hΩ f), |
| (Measure.absolutelyContinuous_of_le hm).ae_eq (lpExtendBetween_coe (B := B) hΩ f), |
| ae_restrict_mem hΩ] with x hx hy hz |
| rw [hx,hy,indicator_of_mem hz] |
| lemma ambientRestrict_extend (hΩ : MeasurableSet Ω) (h : Ω⊆B) (u : Ambient Ω) : |
| ambientRestrict h (ambientExtend hΩ u)=u := by |
| apply Prod.ext |
| · exact lpRestrictBetween_extend hΩ h u.1 |
| · funext i |
| exact lpRestrictBetween_extend hΩ h (u.2 i) |
| def h1Extend (hΩ : MeasurableSet Ω) (h : Ω⊆B) (u : H1 Ω) (hu : HasZeroTrace Ω u) : H1 B := |
| ⟨ambientExtend hΩ u.val,h10Submodule_le B (extend_h10 hΩ h hu)⟩ |
| lemma weakSolution_restrict (hΩ : MeasurableSet Ω) (h : Ω⊆B) {lam mu : X → ℝ} |
| {u : H1 B} (hu : WeakSolution B lam mu u) : WeakSolution Ω lam mu (h1Restrict h u) := by |
| intro v hv |
| have he := hu (h1Extend hΩ h v hv) (extend_h10 hΩ h hv) |
| change ambientEnergy lam mu u.val (ambientExtend hΩ v.val)=0 at he |
| rw [ambientEnergy_extend_right hΩ h] at he |
| exact he |
| def gluedH1 (hΩ : MeasurableSet Ω) (h : Ω⊆B) (u : H1 B) (v : H1 Ω) |
| (ht : SameTrace Ω v (h1Restrict h u)) : H1 B := |
| ⟨u.val+ambientExtend hΩ (v.val-ambientRestrict h u.val), |
| (h1Submodule B).add_mem u.property (h10Submodule_le B (extend_h10 hΩ h ht))⟩ |
| lemma gluedH1_restrict (hΩ : MeasurableSet Ω) (h : Ω⊆B) (u : H1 B) (v : H1 Ω) |
| (ht : SameTrace Ω v (h1Restrict h u)) : h1Restrict h (gluedH1 hΩ h u v ht)=v := by |
| apply Subtype.ext |
| change ambientRestrict h (u.val+ambientExtend hΩ (v.val-ambientRestrict h u.val))=v.val |
| rw [map_add,ambientRestrict_extend] |
| abel |
| lemma gluedH1_exterior_gradient (hΩ : MeasurableSet Ω) (h : Ω⊆B) (u : H1 B) (v : H1 Ω) |
| (ht : SameTrace Ω v (h1Restrict h u)) : |
| ∀ᵐ x ∂(volume.restrict B), x∉Ω → gradient (gluedH1 hΩ h u v ht).val x=gradient u.val x := by |
| filter_upwards [gradient_add u.val (ambientExtend (B := B) hΩ (v.val-ambientRestrict h u.val)), |
| gradient_extend (B := B) hΩ (v.val-ambientRestrict h u.val)] with x ha he hx |
| change gradient (u.val+ambientExtend hΩ (v.val-ambientRestrict h u.val)) x=_ |
| rw [ha,he,indicator_of_notMem hx,add_zero] |
| lemma gluedH1_exterior_value (hΩ : MeasurableSet Ω) (h : Ω⊆B) (u : H1 B) (v : H1 Ω) |
| (ht : SameTrace Ω v (h1Restrict h u)) : |
| ∀ᵐ x ∂(volume.restrict B), x∉Ω → (gluedH1 hΩ h u v ht).val.1 x=u.val.1 x := by |
| filter_upwards [Lp.coeFn_add u.val.1 (lpExtendBetween (B := B) hΩ (v.val-ambientRestrict h u.val).1), |
| lpExtendBetween_coe (B := B) hΩ (v.val-ambientRestrict h u.val).1] with x ha he hx |
| change (u.val.1+lpExtendBetween hΩ (v.val-ambientRestrict h u.val).1 : Lp V 2 (volume.restrict B)) x=_ |
| rw [ha] |
| change u.val.1 x+lpExtendBetween hΩ (v.val-ambientRestrict h u.val).1 x=_ |
| rw [he,indicator_of_notMem hx,add_zero] |
|
|
| theorem physical_weak_transfer {lam₁ mu₁ lam₂ mu₂ : X → ℝ} |
| (ha₁ : Admissible Ω lam₁ mu₁) (ha₂ : Admissible Ω lam₂ mu₂) |
| (hO : IsOpen Ω) (hOB : Bornology.IsBounded Ω) (h : Ω⊆B) |
| (hl₁ : BoundedCoefficient B lam₁) (hm₁ : BoundedCoefficient B mu₁) |
| (hl₂ : BoundedCoefficient B lam₂) (hm₂ : BoundedCoefficient B mu₂) |
| (he : ∀ x∉Ω, lam₁ x=lam₂ x ∧ mu₁ x=mu₂ x) |
| (hDN : DN Ω lam₁ mu₁=DN Ω lam₂ mu₂) |
| {u : H1 B} (hu : WeakSolution B lam₁ mu₁ u) : |
| ∃ v : H1 B, WeakSolution B lam₂ mu₂ v ∧ |
| (∀ᵐ x ∂(volume.restrict B), x∉Ω → v.val.1 x=u.val.1 x) ∧ |
| (∀ᵐ x ∂(volume.restrict B), x∉Ω → gradient v.val x=gradient u.val x) := by |
| obtain ⟨v,hv,ht,hpair⟩ := interior_physical_transfer ha₁ ha₂ hO hOB hDN |
| (weakSolution_restrict hO.measurableSet h hu) |
| have ht' : SameTrace Ω v (h1Restrict h u) := (trace_eq_iff _ _).mp ht |
| refine ⟨gluedH1 hO.measurableSet h u v ht',?_, |
| gluedH1_exterior_value hO.measurableSet h u v ht', |
| gluedH1_exterior_gradient hO.measurableSet h u v ht'⟩ |
| intro w hw |
| have hw0 := hu w hw |
| have hp := hpair (h1Restrict h w) |
| simp only [energy_eq_ambient] at hp hw0 ⊢ |
| change ambientEnergy lam₂ mu₂ (u.val+ambientExtend hO.measurableSet |
| (v.val-ambientRestrict h u.val)) w.val=0 |
| rw [ambientEnergy_add_left hl₂ hm₂,ambientEnergy_extend_left hO.measurableSet h, |
| ambientEnergy_sub_left (hl₂.restrict h) (hm₂.restrict h)] |
| have hc := energy_coefficient_locality hl₁ hm₁ hl₂ hm₂ hO.measurableSet h he u.val w.val |
| change ambientEnergy lam₂ mu₂ v.val (ambientRestrict h w.val)= |
| ambientEnergy lam₁ mu₁ (ambientRestrict h u.val) (ambientRestrict h w.val) at hp |
| linarith |
| end Elasticity |
|
|
| end |
| end |
| section |
| noncomputable section |
| open MeasureTheory Set SchwartzMap |
| open scoped BigOperators |
| namespace Elasticity |
| variable {Ω : Set X} |
| def ambientScalar (Ω : Set X) (k : Option (Fin 3)) (i : Fin 3) : |
| Ambient Ω →L[ℝ] ScalarL2 Ω := (jetScalar Ω k i).comp (jetEquiv Ω).symm.toContinuousLinearMap |
| lemma ambientScalar_ae (u : Ambient Ω) (k : Option (Fin 3)) (i : Fin 3) : |
| ambientScalar Ω k i u =ᵐ[volume.restrict Ω] fun x => ((jetEquiv Ω).symm u k x) i := |
| jetScalar_ae _ _ _ |
| lemma scalar_pair_smooth {f : X → V} (hf : MemLp f 2 (volume.restrict Ω)) |
| (g : SchwartzMap X ℝ) (i : Fin 3) : |
| inner ℝ ((EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω) (hf.toLp f)) |
| (schwartzR Ω g) = ∫ x, (f x) i*g x ∂(volume.restrict Ω) := by |
| rw [L2.inner_def] |
| apply integral_congr_ae |
| filter_upwards [ContinuousLinearMap.coeFn_compLpL (EuclideanSpace.proj (𝕜 := ℝ) i) (hf.toLp f), |
| hf.coeFn_toLp,g.coeFn_toLp 2 (volume.restrict Ω)] with x hx hy hz |
| change inner ℝ (((EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω) (hf.toLp f)) x) (g.toLp 2 (volume.restrict Ω) x)=_ |
| rw [hx,hz,hy] |
| exact real_inner_comm _ _ |
| lemma smooth_ibp {f : X → ℝ} (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) |
| (hs : tsupport (g : X → ℝ) ⊆ Ω) (j : Fin 3) : |
| (∫ x, f x*ElasticityKorn.d (coordVector j) g x ∂(volume.restrict Ω)) = |
| -(∫ x, fderiv ℝ f x (coordVector j)*g x ∂(volume.restrict Ω)) := by |
| have hg : ContDiff ℝ (⊤ : ℕ∞) (g : X → ℝ) := g.smooth _ |
| have hd : Continuous (fun x => fderiv ℝ f x (coordVector j)) := |
| (hf.continuous_fderiv (by simp)).clm_apply continuous_const |
| have hgd : Continuous (fun x => fderiv ℝ (g : X → ℝ) x (coordVector j)) := |
| (hg.continuous_fderiv (by simp)).clm_apply continuous_const |
| rw [setIntegral_eq_integral_of_forall_compl_eq_zero (fun x hx => by |
| have hz := image_eq_zero_of_notMem_tsupport (f := (ElasticityKorn.d (coordVector j) g : X → ℝ)) |
| (fun ht => hx (hs ((tsupport_fderiv_apply_subset ℝ (coordVector j)) ht))) |
| rw [hz,mul_zero]), |
| setIntegral_eq_integral_of_forall_compl_eq_zero (fun x hx => by |
| rw [image_eq_zero_of_notMem_tsupport (f := (g : X → ℝ)) (fun ht => hx (hs ht)),mul_zero])] |
| exact integral_mul_fderiv_eq_neg_fderiv_mul_of_integrable |
| ((hd.mul hg.continuous).integrable_of_hasCompactSupport (hc.mul_left)) |
| ((hf.continuous.mul hgd).integrable_of_hasCompactSupport ((hc.fderiv_apply ℝ _).mul_left)) |
| ((hf.continuous.mul hg.continuous).integrable_of_hasCompactSupport (hc.mul_left)) |
| (fun x _ => hf.differentiable (by simp) x) (fun x _ => hg.differentiable (by simp) x) |
|
|
| def weakDerivativePair (Ω : Set X) (g : SchwartzMap X ℝ) (i j : Fin 3) : Ambient Ω →L[ℝ] ℝ := |
| ((innerSL ℝ (schwartzR Ω (ElasticityKorn.d (coordVector j) g))).comp (ambientScalar Ω none i)) + |
| ((innerSL ℝ (schwartzR Ω g)).comp (ambientScalar Ω (some j) i)) |
| lemma weakDerivativePair_smooth (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) |
| (hs : tsupport (g : X → ℝ) ⊆ Ω) (i j : Fin 3) {u : Ambient Ω} (hu : u∈SmoothJets Ω) : |
| weakDerivativePair Ω g i j u=0 := by |
| obtain ⟨f,hf,hd,hsm,hu,huj⟩ := hu |
| have he0 : ambientScalar Ω none i u= |
| (EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω) (hf.toLp f) := by |
| change (EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω) u.1=_ |
| rw [hu] |
| have he1 : ambientScalar Ω (some j) i u= |
| (EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω) ((hd j).toLp (coordDeriv f j)) := by |
| change (EuclideanSpace.proj (𝕜 := ℝ) i).compLpL 2 (volume.restrict Ω) (u.2 j)=_ |
| rw [huj] |
| simp only [weakDerivativePair,add_apply,ContinuousLinearMap.comp_apply, |
| innerSL_apply_apply,he0,he1] |
| rw [← real_inner_comm (schwartzR Ω (ElasticityKorn.d (coordVector j) g)), |
| ← real_inner_comm (schwartzR Ω g),scalar_pair_smooth,scalar_pair_smooth] |
| have hh := smooth_ibp ((EuclideanSpace.proj (𝕜 := ℝ) i).contDiff.comp hsm) g hc hs j |
| change (∫ x, (f x) i * ElasticityKorn.d (coordVector j) g x ∂(volume.restrict Ω)) = |
| -(∫ x, fderiv ℝ (fun y => (f y) i) x (coordVector j) * g x ∂(volume.restrict Ω)) at hh |
| simp only [coordDeriv_scalar f hsm] at hh |
| rw [hh,neg_add_cancel] |
| /-- The gradient components in the closure-of-jets H1 really are weak |
| partial derivatives of its value. No weak-derivative property is assumed. -/ |
| theorem h1_weak_derivative (u : H1 Ω) (g : SchwartzMap X ℝ) |
| (hc : HasCompactSupport (g : X → ℝ)) (hs : tsupport (g : X → ℝ) ⊆ Ω) |
| (i j : Fin 3) : |
| inner ℝ (ambientScalar Ω none i u.val) (schwartzR Ω (ElasticityKorn.d (coordVector j) g)) = |
| -inner ℝ (ambientScalar Ω (some j) i u.val) (schwartzR Ω g) := by |
| have hm : MapsTo (weakDerivativePair Ω g i j) (SmoothJets Ω) ({0} : Set ℝ) := |
| fun _ hu => weakDerivativePair_smooth g hc hs i j hu |
| have hh := hm.closure (weakDerivativePair Ω g i j).continuous u.property |
| rw [closure_singleton] at hh |
| change weakDerivativePair Ω g i j u.val=0 at hh |
| simp only [weakDerivativePair,add_apply,ContinuousLinearMap.comp_apply, |
| innerSL_apply_apply] at hh |
| rw [← real_inner_comm (schwartzR Ω (ElasticityKorn.d (coordVector j) g)), |
| ← real_inner_comm (schwartzR Ω g)] at hh |
| linarith |
| end Elasticity |
|
|
| end |
| end |
| section |
| noncomputable section |
| open MeasureTheory Set |
| open scoped BigOperators |
| namespace Elasticity |
| variable {Ω : Set X} |
| def testField (g : SchwartzMap X ℝ) (i : Fin 3) : X → V := fun x => g x • coordVector i |
| lemma testField_smooth (g : SchwartzMap X ℝ) (i : Fin 3) : ContDiff ℝ (⊤ : ℕ∞) (testField g i) := |
| (g.smooth _).smul contDiff_const |
| lemma testField_deriv (g : SchwartzMap X ℝ) (i j : Fin 3) : |
| coordDeriv (testField g i) j=fun x => ElasticityKorn.d (coordVector j) g x • coordVector i := by |
| funext x |
| have h := ((ContinuousLinearMap.toSpanSingleton ℝ (coordVector i)).hasFDerivAt (x := g x)).comp x |
| (g.differentiableAt (x := x)).hasFDerivAt |
| change fderiv ℝ ((ContinuousLinearMap.toSpanSingleton ℝ (coordVector i)) ∘ (g : X → ℝ)) x (coordVector j)=_ |
| rw [h.fderiv] |
| rfl |
| lemma testField_compact (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) (i : Fin 3) : |
| HasCompactSupport (testField g i) := hc.comp_left (g := fun a : ℝ => a • coordVector i) (zero_smul ..) |
| lemma testField_support (g : SchwartzMap X ℝ) (i : Fin 3) : |
| tsupport (testField g i) ⊆ tsupport (g : X → ℝ) := |
| tsupport_comp_subset (g := fun a : ℝ => a • coordVector i) (zero_smul ..) _ |
| lemma testField_memLp (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) (i : Fin 3) : |
| MemLp (testField g i) 2 (volume.restrict Ω) := |
| ((testField_smooth g i).continuous.memLp_of_hasCompactSupport (testField_compact g hc i)).restrict Ω |
| lemma testField_deriv_memLp (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) (i j : Fin 3) : |
| MemLp (coordDeriv (testField g i) j) 2 (volume.restrict Ω) := |
| (((testField_smooth g i).continuous_fderiv (by simp)).clm_apply continuous_const |
| |>.memLp_of_hasCompactSupport ((testField_compact g hc i).fderiv_apply ℝ (coordVector j))).restrict Ω |
| def testFieldJet (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) (i : Fin 3) : Ambient Ω := |
| ((testField_memLp g hc i).toLp _,fun j => (testField_deriv_memLp g hc i j).toLp _) |
| lemma testFieldJet_mem (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) |
| (hs : tsupport (g : X → ℝ)⊆Ω) (i : Fin 3) : testFieldJet (Ω := Ω) g hc i∈TestJets Ω := by |
| refine ⟨testField g i,testField_memLp g hc i,testField_deriv_memLp g hc i,testField_smooth g i,testField_compact g hc i, |
| (testField_support g i).trans hs,rfl,rfl⟩ |
| def testH1 (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) |
| (hs : tsupport (g : X → ℝ)⊆Ω) (i : Fin 3) : H1 Ω := |
| ⟨testFieldJet g hc i,h10Submodule_le Ω (subset_closure (testFieldJet_mem g hc hs i))⟩ |
| lemma testH1_zeroTrace (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) |
| (hs : tsupport (g : X → ℝ)⊆Ω) (i : Fin 3) : HasZeroTrace Ω (testH1 g hc hs i) := |
| subset_closure (testFieldJet_mem g hc hs i) |
| lemma testH1_gradient (g : SchwartzMap X ℝ) (hc : HasCompactSupport (g : X → ℝ)) |
| (hs : tsupport (g : X → ℝ)⊆Ω) (i : Fin 3) : |
| ∀ᵐ x ∂(volume.restrict Ω), gradient (testH1 g hc hs i).val x= |
| fun j => ElasticityKorn.d (coordVector j) g x • coordVector i := by |
| have he : ∀ᵐ x ∂(volume.restrict Ω), ∀ j, (testFieldJet (Ω := Ω) g hc i).2 j x=coordDeriv (testField g i) j x := |
| Filter.eventually_all.mpr (fun j => (testField_deriv_memLp g hc i j).coeFn_toLp) |
| filter_upwards [he] with x hx |
| funext j |
| change (testFieldJet (Ω := Ω) g hc i).2 j x=_ |
| rw [hx,testField_deriv] |
| lemma density_single (a b : ℝ) (P : Fin 3 → V) (v : Fin 3 → ℝ) (i : Fin 3) : |
| elasticDensity a b P (fun j => v j • coordVector i)= |
| a*(∑ k, P k k)*v i+b*∑ j, (P j i+P i j)*v j := by |
| fin_cases i <;> simp [elasticDensity,Fin.sum_univ_succ,coordVector] <;> ring |
| end Elasticity |
| |
| end |
| end |
| |
| end OAI |
| |
