| 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 |
| |
