Download data/lean/OAI/MathematicalPhysics/Elasticity/Solvability.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 34.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Elasticity/Solvability.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/Elasticity/Solvability.lean
-
curl -L -o Solvability.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Elasticity/Solvability.lean
34.3 kB
| import OAI.MathematicalPhysics.Elasticity.Regularity | |
| namespace OAI | |
| noncomputable section | |
| /-! The Hahn--Banach / Riesz step used by the physical solvability argument. | |
| This proves the functional-analytic implication, rather than postulating | |
| existence of a right inverse. The physical test estimate is proved separately. -/ | |
| namespace ElasticityDualSolvability | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| /-- A lower norm estimate on an (unbounded) test operator gives a weak solution | |
| for every Hilbert-space forcing, with precisely the same constant. No density | |
| or completeness of the test space, or closedness of the range, is assumed. -/ | |
| theorem exists_weak_solution (D : Submodule β H) (A : D ββ[β] H) | |
| (C : β) (hC : 0 β€ C) (hA : β v : D, β(v : H)β β€ C * βA vβ) (f : H) : | |
| β z : H, βzβ β€ C * βfβ β§ β v : D, inner β z (A v) = inner β f (v : H) := by | |
| have hinj : Function.Injective A := by | |
| intro v w hvw | |
| apply sub_eq_zero.mp | |
| apply Subtype.val_injective | |
| apply norm_eq_zero.mp | |
| have ht := hA (v-w) | |
| rw [map_sub, hvw, sub_self, norm_zero, mul_zero] at ht | |
| exact le_antisymm ht (norm_nonneg _) | |
| let T := (LinearEquiv.ofInjective A hinj).symm | |
| let l : A.range ββ[β] β := | |
| ((innerSL β f).toLinearMap.comp D.subtype).comp T.toLinearMap | |
| have hT (y : A.range) : A (T y) = (y : H) := by | |
| exact congrArg Subtype.val ((LinearEquiv.ofInjective A hinj).apply_symm_apply y) | |
| have hl : β y : A.range, βl yβ β€ (C*βfβ)*βyβ := by | |
| intro y | |
| change βinner β f ((T y : D) : H)β β€ _ | |
| calc | |
| _ β€ βfβ * β((T y : D) : H)β := norm_inner_le_norm _ _ | |
| _ β€ βfβ * (C*βA (T y)β) := mul_le_mul_of_nonneg_left (hA (T y)) (norm_nonneg _) | |
| _ = _ := by rw [hT]; change βfβ * (C * βyβ) = _; ring | |
| let L : A.range βL[β] β := l.mkContinuous (C*βfβ) hl | |
| obtain β¨G, hG, hnormβ© := exists_extension_norm_eq A.range L | |
| let z : H := (InnerProductSpace.toDual β H).symm G | |
| refine β¨z, ?_, fun v => ?_β© | |
| Β· calc | |
| βzβ = βGβ := (InnerProductSpace.toDual β H).symm.norm_map _ | |
| _ = βLβ := hnorm | |
| _ β€ C*βfβ := l.mkContinuous_norm_le (mul_nonneg hC (norm_nonneg _)) hl | |
| Β· change inner β ((InnerProductSpace.toDual β H).symm G) (A v) = _ | |
| rw [InnerProductSpace.toDual_symm_apply] | |
| change G ((LinearEquiv.ofInjective A hinj v : A.range) : H) = _ | |
| rw [hG] | |
| change inner β f ((T (LinearEquiv.ofInjective A hinj v) : D) : H) = _ | |
| rw [LinearEquiv.symm_apply_apply] | |
| end ElasticityDualSolvability | |
| open MeasureTheory Complex SchwartzMap | |
| open scoped BigOperators FourierTransform SchwartzMap LineDeriv ENNReal | |
| namespace ElasticityPhysicalDual | |
| open ElasticityBessel ElasticitySchwartzCarleman ElasticityNegativeOrder | |
| open ElasticityPhysicalAlgebra ElasticityPhysicalEstimate | |
| abbrev X := ElasticityBessel.X | |
| abbrev H := PiLp 2 (fun _ : Fin 3 => Lp β 2 (volume : Measure X)) | |
| def embed : (Fin 3 β S) ββ[β] H where | |
| toFun u := WithLp.toLp 2 (fun i => L2 (u i)) | |
| map_add' u v := by apply PiLp.ext; intro i; exact map_add L2 _ _ | |
| map_smul' a u := by apply PiLp.ext; intro i; exact map_smul L2 _ _ | |
| lemma embed_apply (u : Fin 3 β S) (i : Fin 3) : embed u i = L2 (u i) := rfl | |
| lemma embed_injective : Function.Injective embed := by | |
| intro u v h | |
| funext i | |
| apply SchwartzMap.injective_toLp 2 volume | |
| exact congrArg (fun w : H => w i) h | |
| lemma norm_embed (h : β) (u : Fin 3 β S) : βembed uβ = sobNorm h 0 u := by | |
| rw [PiLp.norm_eq_of_L2] | |
| simp only [embed_apply, sobNorm, J_zero, norm2] | |
| lemma inner_embed (u v : Fin 3 β S) : | |
| inner β (embed u) (embed v) = β i, pair (u i) (v i) := by | |
| rw [PiLp.inner_apply] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| exact ip_integral _ _ | |
| def adjPhase (z : Fin 3 β β) (i : Fin 3) : β := -star (z i) | |
| lemma pair_neg_left (f g : S) : pair (-f) g = -pair f g := by | |
| simpa only [neg_one_smul, star_neg, star_one, neg_mul, one_mul] using pair_smul_left f g (-1) | |
| lemma pair_neg_right (f g : S) : pair f (-g) = -pair f g := by | |
| simpa only [neg_one_smul, neg_mul, one_mul] using pair_smul_right f g (-1) | |
| lemma pair_shift (z : Fin 3 β β) (i : Fin 3) (f g : S) : | |
| pair f (shiftD z i g) = -pair (shiftD (adjPhase z) i f) g := by | |
| simp only [shiftD_apply, pair_add_right, pair_add_left, pair_smul_left, | |
| pair_smul_right, pair_d, adjPhase, star_neg, star_star] | |
| ring | |
| lemma pair_mult (a : X β β) (ha : a.HasTemperateGrowth) (hr : β x, star (a x) = a x) | |
| (f g : S) : pair f (mult a g) = pair (mult a f) g := by | |
| unfold pair | |
| apply integral_congr_ae | |
| filter_upwards [] with x | |
| simp only [mult_apply a ha, star_mul, hr] | |
| ring | |
| lemma pair_two_shift (z : Fin 3 β β) (i j : Fin 3) (a : X β β) | |
| (ha : a.HasTemperateGrowth) (hr : β x, star (a x) = a x) (f g : S) : | |
| pair f (shiftD z i (mult a (shiftD z j g))) = | |
| pair (shiftD (adjPhase z) j (mult a (shiftD (adjPhase z) i f))) g := by | |
| rw [pair_shift, pair_mult a ha hr, pair_shift, neg_neg] | |
| lemma pair_eq_ip (f g : S) : pair f g = ip f g := (ip_integral f g).symm | |
| lemma pair_sum_left {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β S) (g : S) : | |
| pair (β i β s, f i) g = β i β s, pair (f i) g := by | |
| simpa only [pair_eq_ip, ip, map_sum] using | |
| (sum_inner (π := β) (s := s) (f := fun i => L2 (f i)) (L2 g)) | |
| lemma pair_sum_right {ΞΉ : Type*} (s : Finset ΞΉ) (f : S) (g : ΞΉ β S) : | |
| pair f (β i β s, g i) = β i β s, pair f (g i) := by | |
| simpa only [pair_eq_ip, ip, map_sum] using | |
| (inner_sum (π := β) (s := s) (f := fun i => L2 (g i)) (L2 f)) | |
| lemma physical_adjoint (z : Fin 3 β β) (lam m : X β β) | |
| (hl : lam.HasTemperateGrowth) (hm : m.HasTemperateGrowth) | |
| (hrl : β x, star (lam x) = lam x) (hrm : β x, star (m x) = m x) | |
| (u v : Fin 3 β S) : | |
| inner β (embed v) (embed (physical z lam m u)) = | |
| inner β (embed (physical (adjPhase z) lam m v)) (embed u) := by | |
| simp only [inner_embed, physical, map_sum, map_add, pair_add_left, pair_add_right, | |
| pair_sum_left, pair_sum_right, pair_two_shift z _ _ lam hl hrl, | |
| pair_two_shift z _ _ m hm hrm, Finset.sum_add_distrib] | |
| congr 1 | |
| Β· rw [Finset.sum_comm] | |
| Β· congr 1 | |
| rw [Finset.sum_comm] | |
| /-- Supported Schwartz vectors, regarded as an actual subspace of L2. -/ | |
| def supported (R : β) : Submodule β (Fin 3 β S) where | |
| carrier := {u | β i, BallSupported R (u i)} | |
| zero_mem' _i := BallSupported.zero R | |
| add_mem' hu hv i := (hu i).add (hv i) | |
| smul_mem' a _u hu i := (hu i).smul a | |
| lemma physical_add (z : Fin 3 β β) (lam m : X β β) (u v : Fin 3 β S) : | |
| physical z lam m (u+v) = physical z lam m u + physical z lam m v := by | |
| funext i | |
| simp only [physical, Pi.add_apply, map_add, Finset.sum_add_distrib] | |
| abel | |
| lemma physical_smul (z : Fin 3 β β) (lam m : X β β) (a : β) (u : Fin 3 β S) : | |
| physical z lam m (a β’ u) = a β’ physical z lam m u := by | |
| funext i | |
| simp only [physical, Pi.smul_apply, map_smul, β smul_add, β Finset.smul_sum] | |
| /-- Exact shifted stress-divergence as a linear map, for duality on its range. -/ | |
| def physicalLM (z : Fin 3 β β) (lam m : X β β) : (Fin 3 β S) ββ[β] (Fin 3 β S) where | |
| toFun := physical z lam m | |
| map_add' := physical_add z lam m | |
| map_smul' := physical_smul z lam m | |
| /-- The physical weak equation follows from the actual uniform test estimate. | |
| The forcing and unknown belong to the genuine vector-valued L2 Hilbert space. -/ | |
| theorem weak_physical_from_test (R h : β) (z : Fin 3 β β) (lam m : X β β) | |
| (C : β) (hC : 0 β€ C) | |
| (htest : β u : Fin 3 β S, (β i, BallSupported R (u i)) β | |
| sobNorm h 0 u β€ C*sobNorm h 0 (physical (adjPhase z) lam m u)) (F : H) : | |
| β w : H, βwβ β€ C*βFβ β§ β v : Fin 3 β S, (β i, BallSupported R (v i)) β | |
| inner β w (embed (physical (adjPhase z) lam m v)) = inner β F (embed v) := by | |
| let V := supported R | |
| let T : V ββ[β] H := embed.comp V.subtype | |
| have hinj : Function.Injective T := by | |
| intro v w hvw | |
| exact Subtype.val_injective (embed_injective hvw) | |
| let E := LinearEquiv.ofInjective T hinj | |
| let B : T.range ββ[β] H := | |
| (((embed.comp (physicalLM (adjPhase z) lam m)).comp V.subtype).comp E.symm.toLinearMap) | |
| have hT (y : T.range) : T (E.symm y) = (y : H) := | |
| congrArg Subtype.val (E.apply_symm_apply y) | |
| have hB (y : T.range) : β(y : H)β β€ C*βB yβ := by | |
| rw [β hT y] | |
| change βembed ((E.symm y : V) : Fin 3 β S)β β€ | |
| C * βembed (physical (adjPhase z) lam m ((E.symm y : V) : Fin 3 β S))β | |
| rw [norm_embed h, norm_embed h] | |
| exact htest _ (E.symm y).property | |
| obtain β¨w, hw, heqβ© := ElasticityDualSolvability.exists_weak_solution T.range B C hC hB F | |
| refine β¨w, hw, fun v hv => ?_β© | |
| let v' : V := β¨v, hvβ© | |
| have hh := heq (E v') | |
| change inner β w (embed (physical (adjPhase z) lam m ((E.symm (E v') : V) : Fin 3 β S))) = | |
| inner β F (T v') at hh | |
| rw [E.symm_apply_apply] at hh | |
| exact hh | |
| lemma adjPhase_phase (h : β) (Ξ± Ξ² : X) : | |
| adjPhase (phase h Ξ± Ξ²) = phase h (-Ξ±) Ξ² := by | |
| funext i | |
| simp only [adjPhase, phase, Complex.star_def, map_divβ, map_add, map_mul, | |
| Complex.conj_ofReal, Complex.conj_I, PiLp.neg_apply, Complex.ofReal_neg] | |
| ring | |
| end ElasticityPhysicalDual | |
| open MeasureTheory Complex SchwartzMap | |
| open scoped BigOperators SchwartzMap LineDeriv | |
| open scoped SchwartzMap LineDeriv BigOperators | |
| open MeasureTheory Complex SchwartzMap | |
| open scoped BigOperators SchwartzMap LineDeriv | |
| namespace ElasticityDistribution | |
| section | |
| open ElasticityPhysicalAlgebra ElasticityPhysicalDual ElasticityNegativeOrder | |
| abbrev S := π’(X,β) | |
| def cj (Ο : S) : S := Ο.postcompCLM Complex.conjCLE.toContinuousLinearMap | |
| @[simp] lemma cj_apply (Ο : S) (x : X) : cj Ο x = star (Ο x) := rfl | |
| lemma cj_add (Ο Ο : S) : cj (Ο+Ο) = cj Ο+cj Ο := by ext x; simp | |
| lemma cj_smul (c : β) (Ο : S) : cj (c β’ Ο) = star c β’ cj Ο := by ext x; simp | |
| lemma cj_sum {ΞΉ : Type*} (s : Finset ΞΉ) (Ο : ΞΉ β S) : cj (β i β s, Ο i) = β i β s, cj (Ο i) := by | |
| ext x | |
| simp | |
| lemma cj_cj (Ο : S) : cj (cj Ο) = Ο := by ext x; simp | |
| lemma cj_deriv (i : Fin 3) (Ο : S) : cj (β_{ElasticityAugmented.e i} Ο) = β_{ElasticityAugmented.e i} (cj Ο) := by | |
| ext x | |
| change star (fderiv β Ο x (ElasticityAugmented.e i)) = fderiv β (cj Ο) x (ElasticityAugmented.e i) | |
| have h := Complex.conjCLE.toContinuousLinearMap.hasFDerivAt.comp x (Ο.hasFDerivAt x) | |
| exact (congrArg (fun T : X βL[β] β => T (ElasticityAugmented.e i)) h.fderiv).symm | |
| lemma cj_shift (z : Fin 3 β β) (i : Fin 3) (Ο : S) : | |
| cj (shiftD z i Ο) = shiftD (fun i => star (z i)) i (cj Ο) := by | |
| simp only [shiftD_apply,cj_add,cj_smul] | |
| congr 1 | |
| exact cj_deriv i Ο | |
| lemma cj_mult (a : X β β) (ha : a.HasTemperateGrowth) (hr : β x, star (a x)=a x) (Ο : S) : | |
| cj (mult a Ο) = mult a (cj Ο) := by | |
| ext x | |
| simp only [cj_apply,mult_apply a ha,star_mul,hr] | |
| exact mul_comm _ _ | |
| lemma cj_physical (z : Fin 3 β β) (lam m : X β β) | |
| (hl : lam.HasTemperateGrowth) (hm : m.HasTemperateGrowth) | |
| (hrl : β x, star (lam x)=lam x) (hrm : β x, star (m x)=m x) (Ο : Fin 3 β S) | |
| {index : Fin 3} : | |
| cj (physical z lam m Ο index) = | |
| physical (fun i => star (z i)) lam m (fun i => cj (Ο i)) index := by | |
| simp only [physical,cj_add,cj_shift,cj_mult lam hl hrl,cj_mult m hm hrm,cj_sum] | |
| lemma cj_supported {R : β} {Ο : S} (h : BallSupported R Ο) : BallSupported R (cj Ο) := by | |
| intro x hx | |
| exact h x (fun h0 => hx (by simp [h0])) | |
| lemma Lp_test (w : Lp β 2 (volume : Measure X)) (Ο : S) : | |
| (w : Dist) Ο = inner β (ElasticityBessel.L2 (cj Ο)) w := by | |
| rw [Lp.toTemperedDistribution_apply,MeasureTheory.L2.inner_def] | |
| apply integral_congr_ae | |
| filter_upwards [(cj Ο).coeFn_toLp 2 volume] with x hx | |
| change Ο x β’ w x = inner β ((ElasticityBessel.L2 (cj Ο)) x) (w x) | |
| change (ElasticityBessel.L2 (cj Ο) : X β β) x = cj Ο x at hx | |
| rw [hx] | |
| simp only [cj_apply,RCLike.inner_apply',starRingEnd_apply,star_star,smul_eq_mul,mul_comm] | |
| open ElasticityAugmented TemperedDistribution | |
| open ElasticityPhysicalAlgebra (shiftD shiftD_apply) | |
| open ElasticityNegativeOrder (mult) | |
| lemma sd_test (z : Fin 3 β β) (i : Fin 3) (u : Dist) (Ο : S) : | |
| (sd z i u) Ο = -u (shiftD (-z) i Ο) := by | |
| simp only [sd_apply,dd_apply,lineDerivOp_apply_apply,add_apply,smul_apply, | |
| shiftD_apply,map_neg,map_add,map_smul,Pi.neg_apply,neg_smul] | |
| change -u (β_{e i} Ο)+z i β’ u Ο = -(u (β_{e i} Ο)+ -(z i β’ u Ο)) | |
| abel | |
| lemma coeff_test (a : Coeff) (u : Dist) (Ο : S) : | |
| (a β’ u) Ο = u (mult (eval a) Ο) := rfl | |
| lemma coeff_smul_add (a : Coeff) (u v : Dist) : a β’ (u+v)=aβ’u+aβ’v := | |
| (TemperedDistribution.smulLeftCLM β (eval a)).map_add u v | |
| lemma two_sd_test (z : Fin 3 β β) (i j : Fin 3) (a : Coeff) (u : Dist) (Ο : S) : | |
| (sd z i (a β’ sd z j u)) Ο = | |
| u (shiftD (-z) j (mult (eval a) (shiftD (-z) i Ο))) := by | |
| rw [sd_test,coeff_test,sd_test,neg_neg] | |
| /-- Formal transpose of the actual complex physical distribution operator. | |
| It is proved by evaluation on Schwartz tests, so no integration-by-parts | |
| regularity of the unknown is assumed. -/ | |
| theorem physical_transpose (z : Fin 3 β β) (lam m : Coeff) (u : Fin 3 β Dist) (Ο : Fin 3 β S) : | |
| (β i, phys z lam m u i (Ο i)) = | |
| β i, u i (ElasticityPhysicalAlgebra.physical (-z) (eval lam) (eval m) Ο i) := by | |
| have h_lam : (β i, β j, u j (shiftD (-z) j (mult (eval lam) (shiftD (-z) i (Ο i))))) = | |
| β i, β j, u i (shiftD (-z) i (mult (eval lam) (shiftD (-z) j (Ο j)))) := | |
| Finset.sum_comm | |
| have hm : (β i, β j, u j (shiftD (-z) i (mult (eval m) (shiftD (-z) j (Ο i))))) = | |
| β i, β j, u i (shiftD (-z) j (mult (eval m) (shiftD (-z) i (Ο j)))) := | |
| Finset.sum_comm | |
| simp only [phys,divd,Finset.smul_sum,map_sum,coeff_smul_add,map_add,sum_apply,add_apply, | |
| two_sd_test,Finset.sum_add_distrib, | |
| ElasticityPhysicalAlgebra.physical] | |
| rw [h_lam,hm] | |
| end | |
| open ElasticityPhysicalAlgebra ElasticityPhysicalDual ElasticityNegativeOrder | |
| /-- The actual Hilbert weak equation is the actual physical distribution equation. | |
| This lemma does not assume regularity of the unknown and does not replace the | |
| physical stress-divergence operator by an abstract PDE hypothesis. -/ | |
| theorem weak_to_vector_distribution (R : β) (z : Fin 3 β β) (lam m : Coeff) | |
| (hrl : β x, star (eval lam x)=eval lam x) (hrm : β x, star (eval m x)=eval m x) | |
| (w F : H) | |
| (heq : β v : Fin 3 β S, (β i, BallSupported R (v i)) β | |
| inner β w (embed (physical (adjPhase z) (eval lam) (eval m) v)) = inner β F (embed v)) | |
| (Ο : Fin 3 β S) (hΟ : β i, BallSupported R (Ο i)) : | |
| (β i, phys z lam m (fun j => (w j : Dist)) i (Ο i)) = | |
| β i, (F i : Dist) (Ο i) := by | |
| rw [physical_transpose] | |
| simp only [Lp_test] | |
| have h := congrArg star (heq (fun i => cj (Ο i)) (fun i => cj_supported (hΟ i))) | |
| have hs (a b : H) : star (inner β a b)=inner β b a := | |
| inner_conj_symm (π := β) b a | |
| simp only [hs] at h | |
| rw [PiLp.inner_apply,PiLp.inner_apply] at h | |
| have hh (i : Fin 3) : physical (adjPhase z) (eval lam) (eval m) (fun j => cj (Ο j)) i = | |
| cj (physical (-z) (eval lam) (eval m) Ο i) := by | |
| rw [cj_physical _ _ _ (growth lam) (growth m) hrl hrm] | |
| rfl | |
| simpa only [embed_apply,hh] using h | |
| theorem weak_to_local_physical (Ξ© : Set X) (R : β) (hΞ© : Ξ© β Metric.closedBall 0 R) | |
| (z : Fin 3 β β) (lam m : Coeff) | |
| (hrl : β x, star (eval lam x)=eval lam x) (hrm : β x, star (eval m x)=eval m x) | |
| (w F : H) | |
| (heq : β v : Fin 3 β S, (β i, BallSupported R (v i)) β | |
| inner β w (embed (physical (adjPhase z) (eval lam) (eval m) v)) = inner β F (embed v)) : | |
| β i, LocalEq Ξ© (phys z lam m (fun j => (w j : Dist)) i) (F i : Dist) := by | |
| classical | |
| intro i Ο _hc hs | |
| let Ο : Fin 3 β S := fun j => if j=i then Ο else 0 | |
| have hΟ : β j, BallSupported R (Ο j) := by | |
| intro j | |
| by_cases hji : j=i | |
| Β· intro x hx | |
| have hx' : Ο x β 0 := by simpa only [Ο,ite_eq_left hji] using hx | |
| have hxx := hΞ© (hs (subset_tsupport _ hx')) | |
| simpa only [Metric.mem_closedBall,dist_zero_right] using hxx | |
| Β· simpa only [Ο,ite_eq_right hji] using BallSupported.zero R | |
| have h := weak_to_vector_distribution R z lam m hrl hrm w F heq Ο hΟ | |
| simpa only [Ο,apply_ite,map_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true] using h | |
| end ElasticityDistribution | |
| open scoped BigOperators | |
| namespace ElasticityCoeffBounds | |
| open ElasticityAugmented ElasticityPhysicalEstimate | |
| abbrev X := ElasticityAugmented.X | |
| def ExteriorConstant (f : Smooth) : Prop := | |
| β c : β, HasCompactSupport (fun x => (f : X β β) x - c) | |
| lemma ExteriorConstant.growth {f : Smooth} (hf : ExteriorConstant f) : | |
| (f : X β β).HasTemperateGrowth := by | |
| obtain β¨c, hcβ© := hf | |
| have hg := hc.hasTemperateGrowth ((smooth_coe f).sub contDiff_const) | |
| convert hg.add (Function.HasTemperateGrowth.const c) using 1 | |
| funext x | |
| simp | |
| lemma ExteriorConstant.bound {f : Smooth} (hf : ExteriorConstant f) : | |
| β C : β, 0 β€ C β§ β x, β(f : X β β) xβ β€ C := by | |
| obtain β¨c, hcβ© := hf | |
| have hcont : Continuous (fun x => β(f : X β β) x - cβ) := | |
| ((smooth_coe f).continuous.sub continuous_const).norm | |
| obtain β¨xβ, hxβ© := hcont.exists_forall_ge_of_hasCompactSupport hc.norm | |
| refine β¨β(f : X β β) xβ - cβ + βcβ, by positivity, fun x => ?_β© | |
| calc | |
| β(f : X β β) xβ = β((f : X β β) x-c)+cβ := by rw [sub_add_cancel] | |
| _ β€ β(f : X β β) x-cβ + βcβ := norm_add_le _ _ | |
| _ β€ β(f : X β β) xβ-cβ + βcβ := by linarith [hx x] | |
| lemma ExteriorConstant.const (c : β) : ExteriorConstant (algebraMap β Smooth c) := by | |
| refine β¨c, ?_β© | |
| change HasCompactSupport (fun _ : X => c-c) | |
| exact HasCompactSupport.intro isCompact_empty (fun _ _ => sub_self c) | |
| lemma ExteriorConstant.add {f g : Smooth} (hf : ExteriorConstant f) (hg : ExteriorConstant g) : | |
| ExteriorConstant (f+g) := by | |
| obtain β¨c, hcβ© := hf | |
| obtain β¨d, hdβ© := hg | |
| refine β¨c+d, ?_β© | |
| have he : (fun x => ((f+g : Smooth) : X β β) x - (c+d)) = | |
| (fun x => (f : X β β) x-c) + (fun x => (g : X β β) x-d) := by | |
| funext x | |
| change (f : X β β) x + (g : X β β) x - (c+d) = _ | |
| dsimp | |
| ring | |
| rw [he] | |
| exact hc.add hd | |
| lemma ExteriorConstant.mul {f g : Smooth} (hf : ExteriorConstant f) (hg : ExteriorConstant g) : | |
| ExteriorConstant (f*g) := by | |
| obtain β¨c, hcβ© := hf | |
| obtain β¨d, hdβ© := hg | |
| refine β¨c*d, ?_β© | |
| have h1 : HasCompactSupport ((fun x => (f : X β β) x-c) * (g : X β β)) := hc.mul_right | |
| have h2 : HasCompactSupport ((fun _ : X => c) * (fun x => (g : X β β) x-d)) := hd.mul_left | |
| have he : (fun x => ((f*g : Smooth) : X β β) x - c*d) = | |
| ((fun x => (f : X β β) x-c) * (g : X β β)) + | |
| ((fun _ : X => c) * (fun x => (g : X β β) x-d)) := by | |
| funext x | |
| change (f : X β β) x * (g : X β β) x - c*d = _ | |
| dsimp | |
| ring | |
| rw [he] | |
| exact h1.add h2 | |
| lemma ExteriorConstant.neg {f : Smooth} (hf : ExteriorConstant f) : ExteriorConstant (-f) := by | |
| obtain β¨c, hcβ© := hf | |
| refine β¨-c, ?_β© | |
| have he : (fun x => ((-f : Smooth) : X β β) x - (-c)) = -(fun x => (f : X β β) x-c) := by | |
| funext x | |
| change -(f : X β β) x - (-c) = -((f : X β β) x-c) | |
| ring | |
| rw [he] | |
| exact hc.neg | |
| lemma ExteriorConstant.sub {f g : Smooth} (hf : ExteriorConstant f) (hg : ExteriorConstant g) : | |
| ExteriorConstant (f-g) := by | |
| simpa only [sub_eq_add_neg] using hf.add hg.neg | |
| lemma ExteriorConstant.coord {f : Smooth} (hf : ExteriorConstant f) (i : Fin 3) : | |
| ExteriorConstant (coord i f) := by | |
| obtain β¨c, hcβ© := hf | |
| refine β¨0, ?_β© | |
| have hs : HasCompactSupport (fun x => fderiv β (fun y => (f : X β β) y-c) x (e i)) := | |
| hc.fderiv_apply (π := β) (e i) | |
| convert hs using 1 | |
| funext x | |
| simp only [sub_zero, coord_apply, fderiv_sub_const] | |
| lemma ExteriorConstant.zero : ExteriorConstant (0 : Smooth) := by | |
| simpa only [map_zero] using ExteriorConstant.const 0 | |
| lemma ExteriorConstant.natCast (n : β) : ExteriorConstant (n : Smooth) := by | |
| simpa only [map_natCast] using ExteriorConstant.const (n : β) | |
| lemma ExteriorConstant.sum {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β Smooth) | |
| (hf : β i β s, ExteriorConstant (f i)) : ExteriorConstant (β i β s, f i) := by | |
| classical | |
| induction s using Finset.induction_on with | |
| | empty => simpa only [Finset.sum_empty] using ExteriorConstant.zero | |
| | @insert i s hi ih => | |
| rw [Finset.sum_insert hi] | |
| exact (hf i (Finset.mem_insert_self _ _)).add | |
| (ih (fun j hj => hf j (Finset.mem_insert_of_mem hj))) | |
| lemma exterior_coeffA {lam m n o : Smooth} (hl : ExteriorConstant lam) (hm : ExteriorConstant m) | |
| (hn : ExteriorConstant n) (ho : ExteriorConstant o) (k : Fin 3) (i j : Fin 4) : | |
| ExteriorConstant (coeffA coord lam m n o k i j) := by | |
| refine Fin.cases ?_ (fun i => ?_) i | |
| Β· refine Fin.cases ?_ (fun j => ?_) j | |
| Β· exact ((ExteriorConstant.natCast 2).mul ho).mul | |
| (((hl.add hm).coord k).sub (((hl.add hm).mul hn).mul (hm.coord k))) | |
| Β· exact ((ExteriorConstant.natCast 2).mul ho).mul | |
| (((hm.coord j).coord k).sub | |
| ((((ExteriorConstant.natCast 2).mul hn).mul (hm.coord k)).mul (hm.coord j))) | |
| Β· refine Fin.cases ?_ (fun j => ?_) j | |
| Β· change ExteriorConstant (if k=i then (lam+m)*n else 0) | |
| split | |
| Β· exact (hl.add hm).mul hn | |
| Β· exact ExteriorConstant.zero | |
| Β· change ExteriorConstant ((if j=i then n*coord k m else 0) + | |
| (if k=i then n*coord j m else 0)) | |
| apply ExteriorConstant.add | |
| Β· split | |
| Β· exact hn.mul (hm.coord k) | |
| Β· exact ExteriorConstant.zero | |
| Β· split | |
| Β· exact hn.mul (hm.coord j) | |
| Β· exact ExteriorConstant.zero | |
| lemma exterior_coeffV {lam m n o : Smooth} (hl : ExteriorConstant lam) (hm : ExteriorConstant m) | |
| (hn : ExteriorConstant n) (ho : ExteriorConstant o) (i j : Fin 4) : | |
| ExteriorConstant (coeffV coord lam m n o i j) := by | |
| refine Fin.cases ?_ (fun i => ?_) i | |
| Β· refine Fin.cases ?_ (fun _ => ExteriorConstant.zero) j | |
| exact ho.mul ((ExteriorConstant.sum Finset.univ _ (fun i _ => (hl.coord i).coord i)).sub | |
| (((ExteriorConstant.natCast 2).mul hn).mul | |
| (ExteriorConstant.sum Finset.univ _ (fun i _ => (hm.coord i).mul (hl.coord i))))) | |
| Β· refine Fin.cases ?_ (fun _ => ExteriorConstant.zero) j | |
| exact hn.mul (hl.coord i) | |
| lemma exterior_cPhys {m n : Smooth} (hm : ExteriorConstant m) (hn : ExteriorConstant n) | |
| (i : Fin 3) : ExteriorConstant (-2*n*coord i m) := | |
| (((ExteriorConstant.natCast 2).neg).mul hn).mul (hm.coord i) | |
| lemma ExteriorConstant.uniform_bound {ΞΉ : Type*} [Fintype ΞΉ] (f : ΞΉ β Smooth) | |
| (hf : β i, ExteriorConstant (f i)) : | |
| β C : β, 0 β€ C β§ β i x, β(f i : X β β) xβ β€ C := by | |
| classical | |
| choose C hC hb using (fun i => (hf i).bound) | |
| refine β¨β i, C i, Finset.sum_nonneg (fun i _ => hC i), fun i x => ?_β© | |
| exact (hb i x).trans (Finset.single_le_sum (fun j _ => hC j) (Finset.mem_univ i)) | |
| /-- The reciprocal is the pointwise reciprocal, not an abstract inverse assumption. -/ | |
| def reciprocal (f : Smooth) (hf : β x, (f : X β β) x β 0) : Smooth := | |
| β¨fun x => ((f : X β β) x)β»ΒΉ, (smooth_coe f).inv hfβ© | |
| lemma reciprocal_mul (f : Smooth) (hf : β x, (f : X β β) x β 0) : | |
| reciprocal f hf * f = 1 := by | |
| apply Subtype.ext | |
| funext x | |
| exact inv_mul_cancelβ (hf x) | |
| lemma ExteriorConstant.reciprocal {f : Smooth} (hf : ExteriorConstant f) | |
| (hn : β x, (f : X β β) x β 0) : ExteriorConstant (reciprocal f hn) := by | |
| obtain β¨c, hcβ© := hf | |
| refine β¨cβ»ΒΉ, hc.mono' ?_β© | |
| intro x hx | |
| change ((f : X β β) x)β»ΒΉ-cβ»ΒΉ β 0 at hx | |
| apply subset_tsupport (fun x => (f : X β β) x-c) | |
| change (f : X β β) x-c β 0 | |
| intro h | |
| apply hx | |
| exact sub_eq_zero.mpr (congrArg Inv.inv (sub_eq_zero.mp h)) | |
| open ElasticityBessel ElasticitySchwartzCarleman ElasticityNegativeOrder | |
| open ElasticityPhysicalAlgebra (physical phase) | |
| theorem physical_test_exterior (R : β) (hR : 1 β€ R) (Ξ± Ξ² : X) (hΞ± : Ξ± β 0) | |
| (lam m : Smooth) (hl : ExteriorConstant lam) (hm : ExteriorConstant m) | |
| (hm0 : β x, (m : X β β) x β 0) | |
| (he0 : β x, ((lam+m+m : Smooth) : X β β) x β 0) : | |
| β C hβ : β, 0 < C β§ 0 < hβ β§ β h : β, 0 < h β h β€ hβ β | |
| β u : Fin 3 β S, (β i, BallSupported R (u i)) β | |
| sobNorm h 0 u β€ C*sobNorm h 0 (physical (phase h Ξ± Ξ²) lam m u) := by | |
| let n := reciprocal m hm0 | |
| let o := reciprocal (lam+m+m) he0 | |
| have hn : ExteriorConstant n := hm.reciprocal hm0 | |
| have ho : ExteriorConstant o := ((hl.add hm).add hm).reciprocal he0 | |
| have ha := exterior_coeffA hl hm hn ho | |
| have hv := exterior_coeffV hl hm hn ho | |
| have hc := exterior_cPhys hm hn | |
| obtain β¨M, hM, hbMβ© := ExteriorConstant.uniform_bound | |
| (fun ij : Fin 3 Γ Fin 4 Γ Fin 4 => coeffA coord lam m n o ij.1 ij.2.1 ij.2.2) | |
| (fun ij => ha ij.1 ij.2.1 ij.2.2) | |
| obtain β¨V, hV, hbVβ© := ExteriorConstant.uniform_bound | |
| (fun ij : Fin 4 Γ Fin 4 => coeffV coord lam m n o ij.1 ij.2) | |
| (fun ij => hv ij.1 ij.2) | |
| obtain β¨Aβ, hAβ, hnAβ© := hn.bound | |
| obtain β¨Aβ, hAβ, hoAβ© := ho.bound | |
| obtain β¨Aβ, hAβ, hcAβ© := ExteriorConstant.uniform_bound (fun i => -2*n*coord i m) hc | |
| obtain β¨D, hD, hodβ© := ExteriorConstant.uniform_bound (fun i => coord i o) (fun i => ho.coord i) | |
| let Z : β := β i, β((Ξ± i : β)+Complex.I*(Ξ² i : β))β | |
| have hZ : 0 β€ Z := Finset.sum_nonneg (fun i _ => norm_nonneg _) | |
| have hbZ (i : Fin 3) : β((Ξ± i : β)+Complex.I*(Ξ² i : β))β β€ Z := | |
| Finset.single_le_sum (fun j _ => norm_nonneg ((Ξ± j : β)+Complex.I*(Ξ² j : β))) (Finset.mem_univ i) | |
| apply physical_test_estimate R hR Ξ± Ξ² hΞ± lam m n o (reciprocal_mul m hm0) | |
| (reciprocal_mul (lam+m+m) he0) hl.growth hm.growth hn.growth ho.growth | |
| (fun k i j => (ha k i j).growth) (fun i j => (hv i j).growth) (fun i => (hc i).growth) | |
| M V (Aβ+Aβ+Aβ) D Z hM hV (by positivity) hD hZ | |
| Β· intro k i j x | |
| simpa only [aPhys, Pi.neg_apply, norm_neg] using hbM (k, i, j) x | |
| Β· intro i j x | |
| simpa only [vPhys, Pi.neg_apply, norm_neg] using hbV (i, j) x | |
| Β· intro x | |
| linarith [hnA x] | |
| Β· intro x | |
| linarith [hoA x] | |
| Β· intro i x | |
| have hh := hcA i x | |
| change β((-2*n*coord i m : Smooth) : X β β) xβ β€ _ | |
| linarith | |
| Β· exact fun x i => hod i x | |
| Β· exact hbZ | |
| end ElasticityCoeffBounds | |
| open MeasureTheory Complex SchwartzMap | |
| open scoped BigOperators FourierTransform SchwartzMap LineDeriv ENNReal | |
| namespace ElasticityPhysicalSolvability | |
| open ElasticityBessel ElasticitySchwartzCarleman ElasticityNegativeOrder | |
| open ElasticityAugmented | |
| open ElasticityPhysicalAlgebra (physical phase) | |
| open ElasticityPhysicalDual ElasticityCoeffBounds | |
| abbrev X := ElasticityAugmented.X | |
| theorem weak_solvability (R : β) (hR : 1 β€ R) (Ξ± Ξ² : X) (hΞ± : Ξ± β 0) | |
| (lam m : Smooth) (hl : ExteriorConstant lam) (hm : ExteriorConstant m) | |
| (hm0 : β x, (m : X β β) x β 0) | |
| (he0 : β x, ((lam+m+m : Smooth) : X β β) x β 0) : | |
| β C hβ : β, 0 < C β§ 0 < hβ β§ β h : β, 0 < h β h β€ hβ β | |
| β F : H, β w : H, βwβ β€ C*βFβ β§ β v : Fin 3 β S, | |
| (β i, BallSupported R (v i)) β | |
| inner β w (embed (physical (adjPhase (phase h Ξ± Ξ²)) lam m v)) = | |
| inner β F (embed v) := by | |
| obtain β¨C, hβ, hC, hhβ, hestβ© := physical_test_exterior R hR (-Ξ±) Ξ² | |
| (neg_ne_zero.mpr hΞ±) lam m hl hm hm0 he0 | |
| refine β¨C, hβ, hC, hhβ, fun h hh hsmall F => ?_β© | |
| apply weak_physical_from_test R h (phase h Ξ± Ξ²) lam m C hC.le ?_ F | |
| intro u hu | |
| rw [adjPhase_phase] | |
| exact hest h hh hsmall u hu | |
| /-- The real smooth coefficients are embedded pointwise, not abstractly. -/ | |
| def realSmooth (f : X β β) (hf : ContDiff β (β€ : ββ) f) : Smooth := | |
| β¨fun x => (f x : β), Complex.ofRealCLM.contDiff.comp hfβ© | |
| lemma realSmooth_real (f : X β β) (hf : ContDiff β (β€ : ββ) f) (x : X) : | |
| star ((realSmooth f hf : X β β) x) = (realSmooth f hf : X β β) x := by | |
| exact Complex.conj_ofReal _ | |
| lemma exterior_of_ball (f : Smooth) (R : β) (c : β) | |
| (hf : β x, R β€ βxβ β (f : X β β) x = c) : ExteriorConstant f := by | |
| refine β¨c, HasCompactSupport.intro (isCompact_closedBall (0 : X) R) ?_β© | |
| intro x hx | |
| have hx' : R < βxβ := by simpa only [Metric.mem_closedBall, dist_zero_right, not_le] using hx | |
| exact sub_eq_zero.mpr (hf x hx'.le) | |
| /-- Coefficient assumptions for this PDE lemma: smooth, strongly | |
| convex, constant outside a ball. No bounds on their derivatives are assumed. -/ | |
| theorem real_weak_solvability (R : β) (hR : 1 β€ R) (Ξ± Ξ² : X) (hΞ± : Ξ± β 0) | |
| (lam m : X β β) (hl : ContDiff β (β€ : ββ) lam) (hm : ContDiff β (β€ : ββ) m) | |
| (hpos : β x, 0 < m x β§ 0 < 3*lam x+2*m x) | |
| (Rext cl cm : β) (hext : β x, Rext β€ βxβ β lam x=cl β§ m x=cm) : | |
| β C hβ : β, 0 < C β§ 0 < hβ β§ β h : β, 0 < h β h β€ hβ β | |
| β F : H, β w : H, βwβ β€ C*βFβ β§ β v : Fin 3 β S, | |
| (β i, BallSupported R (v i)) β | |
| inner β w (embed (physical (adjPhase (phase h Ξ± Ξ²)) | |
| (realSmooth lam hl) (realSmooth m hm) v)) = inner β F (embed v) := by | |
| apply weak_solvability R hR Ξ± Ξ² hΞ± | |
| (realSmooth lam hl) (realSmooth m hm) | |
| Β· exact exterior_of_ball _ Rext (cl : β) (fun x hx => congrArg Complex.ofReal (hext x hx).1) | |
| Β· exact exterior_of_ball _ Rext (cm : β) (fun x hx => congrArg Complex.ofReal (hext x hx).2) | |
| Β· intro x | |
| change (m x : β) β 0 | |
| exact_mod_cast (hpos x).1.ne' | |
| Β· intro x | |
| have hh : lam x+m x+m x β 0 := by linarith [(hpos x).1, (hpos x).2] | |
| change (lam x : β)+(m x : β)+(m x : β) β 0 | |
| exact_mod_cast hh | |
| end ElasticityPhysicalSolvability | |
| open MeasureTheory TemperedDistribution | |
| open scoped ENNReal SchwartzMap BigOperators | |
| namespace ElasticityDistribution | |
| open ElasticityAugmented ElasticityRegularity ElasticityCoeffBounds | |
| open ElasticityPhysicalAlgebra (phase) | |
| open ElasticityPhysicalDual | |
| lemma lp_local_zero (Ξ© : Set X) (u : Lp β 2 (volume : Measure X)) : | |
| ElasticityRegularity.LocalSobolev Ξ© 0 (u : Dist) := | |
| ElasticityRegularity.MemSobolev.local_zero (memSobolev_zero_iff.mpr β¨u,rflβ©) Ξ© | |
| lemma schwartz_local_nat (Ξ© : Set X) (u : S) (N : β) : | |
| ElasticityRegularity.LocalSobolev Ξ© N (u : Dist) := by | |
| intro g hg hc _ | |
| exact sobolev_nat_product (EuclideanSpace.basisFun (Fin 3) β) N hg hc u.memSobolev | |
| /-- Real physical coefficients and pointwise inverses are the actual smooth | |
| coefficients in the distribution formulation. -/ | |
| def exteriorCoeff (f : Smooth) (hf : ExteriorConstant f) : Coeff := β¨f,hf.growthβ© | |
| def inverseCoeff (f : Smooth) (hf : ExteriorConstant f) (hn : β x, (f : X β β) x β 0) : Coeff := | |
| exteriorCoeff (reciprocal f hn) (hf.reciprocal hn) | |
| lemma inverseCoeff_mul (f : Smooth) (hf : ExteriorConstant f) (hn : β x, (f : X β β) x β 0) : | |
| inverseCoeff f hf hn*exteriorCoeff f hf=1 := by | |
| apply Subtype.ext | |
| exact reciprocal_mul f hn | |
| /-- Actual uniform physical weak solvability together with proved interior | |
| smoothness of every cutoff of the physical displacement and shifted divergence. | |
| This combines the supported Carleman/Hahn--Banach construction with the true | |
| augmented distribution identity rather than assuming elliptic regularity. -/ | |
| theorem weak_smooth_solvability (R : β) (hR : 1 β€ R) | |
| (Ξ© : Set X) (hΞ© : Ξ© β Metric.closedBall 0 R) (Ξ± Ξ² : X) (hΞ± : Ξ± β 0) | |
| (lam m : Smooth) (hl : ExteriorConstant lam) (hm : ExteriorConstant m) | |
| (hrl : β x, star ((lam : X β β) x)=(lam : X β β) x) | |
| (hrm : β x, star ((m : X β β) x)=(m : X β β) x) | |
| (hm0 : β x, (m : X β β) x β 0) | |
| (he0 : β x, ((lam+m+m : Smooth) : X β β) x β 0) : | |
| β C hβ : β, 0 < C β§ 0 < hβ β§ β h : β, 0 < h β h β€ hβ β | |
| β f : Fin 3 β S, β w : H, βwβ β€ C*βembed fβ β§ | |
| (β i, LocalEq Ξ© (phys (phase h Ξ± Ξ²) (exteriorCoeff lam hl) (exteriorCoeff m hm) | |
| (fun j => (w j : Dist)) i) (f i : Dist)) β§ | |
| β i : Fin 4, β g : X β β, ContDiff β (β€ : ββ) g β HasCompactSupport g β tsupport g β Ξ© β | |
| β v : BoundedContinuousFunction X β, ContDiff β (β€ : ββ) (v : X β β) β§ | |
| smulLeftCLM β g ((Fin.cons (divd (phase h Ξ± Ξ²) (fun j => (w j : Dist))) | |
| (fun j => (w j : Dist)) : Fin 4 β Dist) i) = | |
| ((v.memLp_top.toLp _ : Lp β β (volume : Measure X)) : Dist) := by | |
| obtain β¨C,hβ,hC,hhβ,hsolβ© := ElasticityPhysicalSolvability.weak_solvability R hR Ξ± Ξ² hΞ± lam m hl hm hm0 he0 | |
| refine β¨C,hβ,hC,hhβ,fun h hh hs f => ?_β© | |
| obtain β¨w,hw,hweβ© := hsol h hh hs (embed f) | |
| have heq := weak_to_local_physical Ξ© R hΞ© (phase h Ξ± Ξ²) (exteriorCoeff lam hl) (exteriorCoeff m hm) | |
| hrl hrm w (embed f) hwe | |
| have heq' : β i, LocalEq Ξ© (phys (phase h Ξ± Ξ²) (exteriorCoeff lam hl) (exteriorCoeff m hm) | |
| (fun j => (w j : Dist)) i) (f i : Dist) := by | |
| intro i | |
| simpa only [embed_apply,ElasticityBessel.L2,SchwartzMap.toLpCLM_apply,Lp.toTemperedDistribution_toLp_eq] using heq i | |
| refine β¨w,hw,heq',fun i g hg hc hgs => ?_β© | |
| let n := inverseCoeff m hm hm0 | |
| let o := inverseCoeff (lam+m+m) ((hl.add hm).add hm) he0 | |
| have hn : n*exteriorCoeff m hm=1 := inverseCoeff_mul m hm hm0 | |
| have ho : o*(exteriorCoeff lam hl+exteriorCoeff m hm+exteriorCoeff m hm)=1 := by | |
| apply Subtype.ext | |
| exact reciprocal_mul (lam+m+m) he0 | |
| exact physical_cutoff_smooth (phase h Ξ± Ξ²) (exteriorCoeff lam hl) (exteriorCoeff m hm) n o hn ho | |
| (fun j => (w j : Dist)) (fun j => (f j : Dist)) heq' (fun j => lp_local_zero Ξ© (w j)) | |
| (fun N j => schwartz_local_nat Ξ© (f j) N) i hg hc hgs | |
| end ElasticityDistribution | |
| end | |
| end OAI | |