Download data/lean/OAI/MathematicalPhysics/Elasticity/Transfer.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 33.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Elasticity/Transfer.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/Elasticity/Transfer.lean
-
curl -L -o Transfer.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Elasticity/Transfer.lean
33.2 kB
| import OAI.MathematicalPhysics.Elasticity.WeakSolutions | |
| import OAI.MathematicalPhysics.Elasticity.CGO | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open Set MeasureTheory | |
| open scoped BigOperators SchwartzMap | |
| namespace ElasticityCGO | |
| open ElasticityAugmented | |
| open ElasticityPhysicalAlgebra (toSmooth toSmooth_apply toSmooth_physical physical phase) | |
| open ElasticityDistribution (finiteResidual) | |
| abbrev S := SchwartzMap X β | |
| /-- A compact cutoff acts on every smooth amplitude, without any temperate | |
| assumption on the amplitude itself. -/ | |
| def cut (Ο : Smooth) (hc : HasCompactSupport (Ο : X β β)) : Smooth ββ[β] S where | |
| toFun f := (hc.mul_right : HasCompactSupport ((Ο : X β β)*(f : X β β))).toSchwartzMap | |
| ((smooth_coe Ο).mul (smooth_coe f)) | |
| map_add' f g := by | |
| ext x | |
| change (Ο : X β β) x*((f : X β β) x+(g : X β β) x)=_ | |
| exact mul_add _ _ _ | |
| map_smul' c f := by | |
| ext x | |
| change (Ο : X β β) x*(c*(f : X β β) x)=c*((Ο : X β β) x*(f : X β β) x) | |
| ring | |
| @[simp] lemma cut_apply (Ο : Smooth) (hc : HasCompactSupport (Ο : X β β)) (f : Smooth) (x : X) : | |
| cut Ο hc f x=(Ο : X β β) x*(f : X β β) x := rfl | |
| lemma cut_local {U : Set X} (Ο : Smooth) (hc : HasCompactSupport (Ο : X β β)) | |
| (hΟ : EqOn (Ο : X β β) 1 U) (f : Smooth) : | |
| restrictSmooth U (toSmooth (cut Ο hc f))=restrictSmooth U f := by | |
| apply (restrictSmooth_eq_iff U _ _).mpr | |
| intro x hx | |
| simp only [toSmooth_apply,cut_apply,hΟ hx,Pi.one_apply,one_mul] | |
| lemma physical_cut_local {U : Set X} (hU : IsOpen U) | |
| (z : Fin 3 β β) (lam m Ο : Smooth) | |
| (hl : (lam : X β β).HasTemperateGrowth) (hm : (m : X β β).HasTemperateGrowth) | |
| (hc : HasCompactSupport (Ο : X β β)) (hΟ : EqOn (Ο : X β β) 1 U) | |
| (u : Fin 3 β Smooth) (i : Fin 3) : | |
| EqOn (physical z lam m (fun j => cut Ο hc (u j)) i : X β β) | |
| ((LT (shifted coord z) lam m u i : Smooth) : X β β) U := by | |
| change EqOn ((toSmooth (physical z lam m (fun j => cut Ο hc (u j)) i) : Smooth) : X β β) _ U | |
| apply (restrictSmooth_eq_iff U _ _).mp | |
| rw [toSmooth_physical z lam m hl hm,restrict_LT hU,restrict_LT hU] | |
| congr 1 | |
| funext j | |
| exact cut_local Ο hc hΟ (u j) | |
| def residual0 (lam m : Smooth) (a : Amplitude Smooth) (i : Fin 3) : Smooth := | |
| R coord lam m a.1 a.2 i+(lam+m)*coord i (div coord a.1-a.2)+ | |
| coord i lam*(div coord a.1-a.2) | |
| def residual1 (ΞΈ : Fin 3 β β) (lam m : Smooth) (a : Amplitude Smooth) (i : Fin 3) : Smooth := | |
| ΞΈ i β’ ((lam+m)*(div coord a.1-a.2)) | |
| /-- The actual Schwartz residual has precisely the two powers h^8 and h^7. | |
| The amplitude recursions are only required on the indicated open region. -/ | |
| theorem cut_truncation_residual {U : Set X} (hU : IsOpen U) | |
| (ΞΈ : Fin 3 β β) (hΞΈ : β i,ΞΈ i*ΞΈ i=0) (lam m Ο : Smooth) | |
| (hl : (lam : X β β).HasTemperateGrowth) (hm : (m : X β β).HasTemperateGrowth) | |
| (hc : HasCompactSupport (Ο : X β β)) (hΟ : EqOn (Ο : X β β) 1 U) | |
| (h : β) (hh : hβ 0) (a : β β Amplitude Smooth) | |
| (hRβ : leadingR (localCoord hU) ΞΈ (restrictSmooth U lam) (restrictSmooth U m) | |
| (localAmp U (a 0)).1 (localAmp U (a 0)).2=0) | |
| (hnβ : normal ΞΈ (a 0).1=0) | |
| (hrec : β j<8,RecursOn hU ΞΈ lam m (a j) (a (j+1))) (i : Fin 3) : | |
| EqOn (physical ((h : β)β»ΒΉ β’ ΞΈ) lam m | |
| (fun j => cut Ο hc ((truncation (h : β) 8 a).1 j)) i : X β β) | |
| (finiteResidual h (fun j => cut Ο hc (residual0 lam m (a 8) j)) | |
| (fun j => cut Ο hc (residual1 ΞΈ lam m (a 8) j)) i : X β β) U := by | |
| intro x hx | |
| rw [physical_cut_local hU _ lam m Ο hl hm hc hΟ _ i hx] | |
| have hh' : (h : β)β 0 := by exact_mod_cast hh | |
| rw [physical_truncation_residual_on hU ΞΈ hΞΈ lam m (h : β) hh' 8 a hRβ hnβ hrec i hx] | |
| change (h : β)^8 * ( _ + ((h : β)β»ΒΉ*ΞΈ i) * _) = | |
| (h : β)^8 * ((Ο : X β β) x * (residual0 lam m (a 8) i : X β β) x) + | |
| (h : β)^7 * ((Ο : X β β) x * (residual1 ΞΈ lam m (a 8) i : X β β) x) | |
| rw [hΟ hx] | |
| change (h : β)^8 * ( _ + ((h : β)β»ΒΉ*ΞΈ i) * _) = | |
| (h : β)^8 * (1 * _) + (h : β)^7 * (1 * (ΞΈ i * _)) | |
| simp only [one_mul,residual0] | |
| field_simp | |
| lemma phase_eq (h : β) (Ξ± Ξ² : X) : | |
| phase h Ξ± Ξ²=(h : β)β»ΒΉ β’ (fun i => (Ξ± i : β)+Complex.I*(Ξ² i : β)) := by | |
| funext i | |
| simp only [phase,Pi.smul_apply,smul_eq_mul,div_eq_mul_inv,mul_comm] | |
| end ElasticityCGO | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set MeasureTheory | |
| open scoped Topology BigOperators SchwartzMap | |
| namespace ElasticityPhysicalAlgebra | |
| open ElasticityAugmented | |
| lemma physical_eqOn_of_eqOn {U : Set X} (hU : IsOpen U) | |
| (z : Fin 3 β β) (lam m : Smooth) | |
| (hl : (lam : X β β).HasTemperateGrowth) (hm : (m : X β β).HasTemperateGrowth) | |
| (f g : Fin 3 β SchwartzMap X β) (hfg : β j,EqOn (f j : X β β) (g j) U) (i : Fin 3) : | |
| EqOn (physical z lam m f i : X β β) (physical z lam m g i) U := by | |
| change EqOn ((toSmooth (physical z lam m f i) : Smooth) : X β β) | |
| ((toSmooth (physical z lam m g i) : Smooth) : X β β) U | |
| apply (restrictSmooth_eq_iff U _ _).mp | |
| rw [toSmooth_physical z lam m hl hm,toSmooth_physical z lam m hl hm, | |
| restrict_LT hU,restrict_LT hU] | |
| congr 1 | |
| funext j | |
| exact (restrictSmooth_eq_iff U _ _).mpr (hfg j) | |
| /-- A local physical transfer that agrees off a compact set gives a genuinely | |
| compact supported global difference, without changing the physical equation | |
| on its open domain. -/ | |
| theorem compactify_physical_transfer {K U : Set X} (hK : IsCompact K) | |
| (hU : IsOpen U) (hKU : KβU) (lam m : Smooth) | |
| (hl : (lam : X β β).HasTemperateGrowth) (hm : (m : X β β).HasTemperateGrowth) | |
| (F G : Fin 3 β SchwartzMap X β) (hG : β i,EqOn (physical 0 lam m G i : X β β) 0 U) | |
| (he : β i,EqOn (G i : X β β) (F i) (U\K)) : | |
| β H : Fin 3 β SchwartzMap X β,(β i,tsupport (H i)βK) β§ | |
| (β i,EqOn (physical 0 lam m (F+H) i : X β β) 0 U) β§ | |
| (β i,EqOn ((F+H) i : X β β) (G i) U) := by | |
| obtain β¨Ο,hΟ,hc,hs,h1,_β© := ElasticityBoundary.compact_smooth_cutoff hK hU hKU | |
| let c : Smooth := β¨fun x => (Ο x : β),Complex.ofRealCLM.contDiff.comp hΟβ© | |
| have hc' : HasCompactSupport (c : X β β) := hc.comp_left Complex.ofReal_zero | |
| let H : Fin 3 β SchwartzMap X β := fun i => ElasticityCGO.cut c hc' (toSmooth (G i-F i)) | |
| have hH (i) (x) : H i x=(Ο x : β)*(G i x-F i x) := rfl | |
| have heq : β i,EqOn ((F+H) i : X β β) (G i) U := by | |
| intro i x hx | |
| change F i x+H i x=G i x | |
| rw [hH] | |
| by_cases hxK : xβK | |
| Β· have hx1 : Ο x=1 := mem_of_mem_nhds (s := {y : X | Ο y=1}) (x := x) (h1.filter_mono (nhds_le_nhdsSet hxK)) | |
| rw [hx1,Complex.ofReal_one,one_mul] | |
| ring | |
| Β· rw [he i β¨hx,hxKβ©,sub_self,mul_zero,add_zero] | |
| refine β¨H,?_,?_,heqβ© | |
| Β· intro i | |
| apply closure_minimal _ hK.isClosed | |
| intro x hx | |
| by_contra hnot | |
| apply hx | |
| rw [hH] | |
| by_cases hxU : xβU | |
| Β· rw [he i β¨hxU,hnotβ©,sub_self,mul_zero] | |
| Β· have hz : Ο x=0 := image_eq_zero_of_notMem_tsupport (fun hh => hxU (hs hh)) | |
| rw [hz,Complex.ofReal_zero,zero_mul] | |
| Β· intro i x hx | |
| exact (physical_eqOn_of_eqOn hU 0 lam m hl hm (F+H) G heq i hx).trans (hG i hx) | |
| end ElasticityPhysicalAlgebra | |
| namespace Elasticity | |
| open ElasticityDistribution | |
| open ElasticityPhysicalAlgebra (physical) | |
| variable {Ξ© B B' : Set X} {lamβ muβ lamβ muβ : X β β} | |
| /-- A supported smooth physical difference derived from the actual DN equality. | |
| This is the literal compact support needed for the augmented Carleman estimate. -/ | |
| theorem physical_supported_transfer | |
| (haβ : Admissible Ξ© lamβ muβ) (haβ : Admissible Ξ© lamβ muβ) | |
| (hΞ© : IsOpen Ξ©) (hOB : Bornology.IsBounded Ξ©) (hΞ©B : Ξ©βB) | |
| (hB : IsOpen B) (hB' : IsOpen B') (hsub : B'βB) (hcl : closure Ξ©β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β) | |
| (Lβ Mβ Lβ Mβ Nβ Oβ : Coeff) (hN : Nβ*Mβ=1) (hO : Oβ*(Lβ+Mβ+Mβ)=1) | |
| (hLβ : βα΅ x β(volume.restrict B), eval Lβ x=(lamβ x : β)) | |
| (hMβ : βα΅ x β(volume.restrict B), eval Mβ x=(muβ x : β)) | |
| (hLβ : βα΅ x β(volume.restrict B), eval Lβ x=(lamβ x : β)) | |
| (hMβ : βα΅ x β(volume.restrict B), eval Mβ x=(muβ x : β)) | |
| {g : X β β} (hg : ContDiff β (β€ : ββ) g) (hc : HasCompactSupport g) | |
| (hs : tsupport gβB) (h1 : Set.EqOn g 1 B') (F : Fin 3 β SchwartzMap X β) | |
| (hF : β i, Set.EqOn (physical 0 (eval Lβ) (eval Mβ) F i : X β β) 0 B) : | |
| β H : Fin 3 β SchwartzMap X β,(β i,tsupport (H i)βclosure Ξ©) β§ | |
| (β i,EqOn (physical 0 (eval Lβ) (eval Mβ) (F+H) i : X β β) 0 B') β§ | |
| (β i,EqOn ((F+H) i : X β β) (F i) (closure Ξ©)αΆ) := by | |
| obtain β¨G,hG,heGβ© := physical_classical_transfer haβ haβ hΞ© hOB hΞ©B hB hB' hsub | |
| hlβ hmβ hlβ hmβ he hDN Lβ Mβ Lβ Mβ Nβ Oβ hN hO hLβ hMβ hLβ hMβ hg hc hs h1 F hF | |
| obtain β¨H,hH,hp,_β© := ElasticityPhysicalAlgebra.compactify_physical_transfer | |
| hOB.isCompact_closure hB' hcl Lβ.val Mβ.val (growth Lβ) (growth Mβ) F G hG heG | |
| refine β¨H,hH,hp,?_β© | |
| intro i x hx | |
| have hz : H i x=0 := image_eq_zero_of_notMem_tsupport (fun hh => hx (hH i hh)) | |
| change F i x+H i x=F i x | |
| rw [hz,add_zero] | |
| end Elasticity | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open scoped BigOperators | |
| namespace ElasticityAugmented | |
| section Algebra | |
| variable {A : Type*} [CommRing A] [Algebra β A] | |
| variable {ΞΉ : Type*} [Fintype ΞΉ] | |
| variable (D : ΞΉ β Derivation β A A) (z : ΞΉ β β) (Ο : A) | |
| omit [Fintype ΞΉ] in | |
| lemma deriv_phase_mul (hΟ : β i,D i Ο=z i β’ Ο) (i : ΞΉ) (f : A) : | |
| D i (Ο*f)=Ο*(shifted D z i f) := by | |
| rw [partial_mul,hΟ,shifted_apply] | |
| simp only [Algebra.smul_def] | |
| ring | |
| /-- The shifted operator is the literal exponential conjugation of the | |
| physical stress-divergence, not a new PDE declared equivalent by hypothesis. -/ | |
| theorem physical_phase_conjugation (hΟ : β i,D i Ο=z i β’ Ο) | |
| (lam m : A) (u : ΞΉ β A) (i : ΞΉ) : | |
| LT (fun j => (D j).toLinearMap) lam m (fun j => Ο*u j) i = | |
| Ο*LT (shifted D z) lam m u i := by | |
| have hd (j) (f) := deriv_phase_mul D z Ο hΟ j f | |
| change D i (lam*(β j,D j (Ο*u j)))+ | |
| β j,D j (m*(D j (Ο*u i)+D i (Ο*u j)))=_ | |
| simp only [hd,β Finset.mul_sum,β mul_add] | |
| have hfirst : lam*(Ο*(β j,shifted D z j (u j)))=Ο*(lam*(β j,shifted D z j (u j))) := by ring | |
| have hsecond (j) : m*(Ο*(shifted D z j (u i)+shifted D z i (u j)))= | |
| Ο*(m*(shifted D z j (u i)+shifted D z i (u j))) := by ring | |
| rw [hfirst,hd] | |
| simp_rw [hsecond,hd] | |
| rw [β Finset.mul_sum,β mul_add] | |
| rfl | |
| end Algebra | |
| /-- An arbitrary complex linear frequency gives a genuine global smooth | |
| exponential on the physical real space. -/ | |
| def exponential (L : X βL[β] β) : Smooth := β¨fun x => Complex.exp (L x),by | |
| exact (show ContDiff β (β€ : ββ) (fun x => Complex.exp (L x)) from L.contDiff.cexp)β© | |
| lemma coord_exponential (L : X βL[β] β) (i : Fin 3) : | |
| coord i (exponential L)=L (e i) β’ exponential L := by | |
| apply Subtype.ext | |
| funext x | |
| have hh := congrArg (fun K : X βL[β] β => K (e i)) (L.hasFDerivAt.cexp.fderiv (x := x)) | |
| change fderiv β (fun y => Complex.exp (L y)) x (e i)=L (e i)*Complex.exp (L x) | |
| simpa only [smul_apply,smul_eq_mul,mul_comm] using hh | |
| lemma exponential_ne_zero (L : X βL[β] β) (x : X) : (exponential L : X β β) xβ 0 := | |
| Complex.exp_ne_zero _ | |
| theorem physical_exponential_conjugation (L : X βL[β] β) (lam m : Smooth) | |
| (u : Fin 3 β Smooth) (i : Fin 3) : | |
| LT (fun j => (coord j).toLinearMap) lam m (fun j => exponential L*u j) i= | |
| exponential L*LT (shifted coord (fun j => L (e j))) lam m u i := | |
| physical_phase_conjugation coord (fun j => L (e j)) (exponential L) (coord_exponential L) lam m u i | |
| end ElasticityAugmented | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped BigOperators FourierTransform | |
| namespace ElasticityCarleman | |
| abbrev X := EuclideanSpace β (Fin 3) | |
| abbrev Y := EuclideanSpace β (Fin 4) | |
| abbrev Direction := Fin 3 β β | |
| def e (i : Fin 3) : X := EuclideanSpace.single i 1 | |
| def deriv (f : X β Y) (i : Fin 3) : X β Y := | |
| fun x => fderiv β f x (e i) | |
| def laplacian (f : X β Y) : X β Y := | |
| fun x => β i, deriv (deriv f i) i x | |
| def phase (ΞΈ : Direction) (x : X) : β := β i, ΞΈ i * (x i : β) | |
| def conjugate (ΞΈ : Direction) (h : β) (f : X β Y) : X β Y := | |
| fun x => Complex.exp (-(h : β)β»ΒΉ * phase ΞΈ x) β’ f x | |
| /-- The sum-of-component semiclassical Fourier norm, written using the | |
| Euclidean norm on the target; this is exactly that sum under the square root. -/ | |
| def sobolevNorm (h s : β) (f : X β Y) : β := | |
| Real.sqrt (β« ΞΎ : X, (1 + h ^ 2 * βΞΎβ ^ 2) ^ s * βπ f ΞΎβ ^ 2) | |
| def normalizedOperator (A : Fin 3 β X β Y βL[β] Y) (Aβ : X β Y βL[β] Y) | |
| (f : X β Y) : X β Y := | |
| fun x => laplacian f x + (β i, A i x (deriv f i x)) + Aβ x (f x) | |
| def SupportedCarlemanClaim : Prop := | |
| β (A : Fin 3 β X β Y βL[β] Y) (Aβ : X β Y βL[β] Y), | |
| (β i, ContDiff β (β€ : ββ) (A i)) β ContDiff β (β€ : ββ) Aβ β | |
| β (ΞΈ : Direction), ΞΈ β 0 β (β i, ΞΈ i * ΞΈ i) = 0 β | |
| β (xβ : X) (r : β), 0 < r β | |
| β C : β, 0 < C β§ β hβ : β, 0 < hβ β§ | |
| β h : β, 0 < h β h < hβ β β U : X β Y, | |
| ContDiff β (β€ : ββ) U β HasCompactSupport U β | |
| tsupport U β Metric.ball xβ r β | |
| sobolevNorm h 1 (conjugate ΞΈ h U) β€ | |
| C * h * sobolevNorm h (-1) (conjugate ΞΈ h (normalizedOperator A Aβ U)) | |
| /-- The real-linear complex phase functional. -/ | |
| def phaseCLM (ΞΈ : Direction) : X βL[β] β := | |
| β i, ΞΈ i β’ (Complex.ofRealCLM.comp (EuclideanSpace.proj i)) | |
| lemma phaseCLM_apply (ΞΈ : Direction) (x : X) : phaseCLM ΞΈ x = phase ΞΈ x := by | |
| simp [phaseCLM, phase] | |
| lemma phaseCLM_e (ΞΈ : Direction) (i : Fin 3) : phaseCLM ΞΈ (e i) = ΞΈ i := by | |
| simp [phaseCLM, e, EuclideanSpace.proj, apply_ite] | |
| def expPhase (ΞΈ : Direction) (z : β) (x : X) : β := Complex.exp (z * phase ΞΈ x) | |
| lemma contDiff_expPhase (ΞΈ : Direction) (z : β) : | |
| ContDiff β (β€ : ββ) (expPhase ΞΈ z) := by | |
| have hp : ContDiff β (β€ : ββ) (phase ΞΈ) := by | |
| have he : (phaseCLM ΞΈ : X β β) = phase ΞΈ := funext (phaseCLM_apply ΞΈ) | |
| rw [β he] | |
| exact (phaseCLM ΞΈ).contDiff | |
| exact (contDiff_const.mul hp).cexp | |
| lemma fderiv_expPhase (ΞΈ : Direction) (z : β) (x : X) : | |
| fderiv β (expPhase ΞΈ z) x = (expPhase ΞΈ z x * z) β’ phaseCLM ΞΈ := by | |
| have hd := (((phaseCLM ΞΈ).hasFDerivAt (x := x)).const_mul z).cexp | |
| change fderiv β (fun x => Complex.exp (z * phase ΞΈ x)) x = _ | |
| simpa [expPhase, phaseCLM_apply, smul_smul] using hd.fderiv | |
| lemma contDiff_deriv {f : X β Y} (hf : ContDiff β (β€ : ββ) f) (i : Fin 3) : | |
| ContDiff β (β€ : ββ) (deriv f i) := by | |
| exact (hf.fderiv_right (by simp)).clm_apply contDiff_const | |
| lemma deriv_add {f g : X β Y} (hf : Differentiable β f) (hg : Differentiable β g) | |
| (i : Fin 3) : deriv (fun x => f x + g x) i = fun x => deriv f i x + deriv g i x := by | |
| funext x | |
| simp [deriv, fderiv_fun_add (hf x) (hg x)] | |
| lemma deriv_const_smul {f : X β Y} (hf : Differentiable β f) (a : β) (i : Fin 3) : | |
| deriv (fun x => a β’ f x) i = fun x => a β’ deriv f i x := by | |
| funext x | |
| change fderiv β (a β’ f) x (e i) = a β’ fderiv β f x (e i) | |
| rw [fderiv_const_smul (hf x)] | |
| rfl | |
| lemma deriv_expPhase_smul {f : X β Y} (hf : Differentiable β f) | |
| (ΞΈ : Direction) (z : β) (i : Fin 3) : | |
| deriv (fun x => expPhase ΞΈ z x β’ f x) i = | |
| fun x => expPhase ΞΈ z x β’ (deriv f i x + (z * ΞΈ i) β’ f x) := by | |
| funext x | |
| rw [deriv, fderiv_fun_smul ((contDiff_expPhase ΞΈ z).differentiable (by simp) x) (hf x), | |
| fderiv_expPhase] | |
| simp [deriv, phaseCLM_e, smul_add, smul_smul, mul_assoc] | |
| lemma second_deriv_expPhase_smul {f : X β Y} (hf : ContDiff β (β€ : ββ) f) | |
| (ΞΈ : Direction) (z : β) (i : Fin 3) : | |
| deriv (deriv (fun x => expPhase ΞΈ z x β’ f x) i) i = | |
| fun x => expPhase ΞΈ z x β’ (deriv (deriv f i) i x + | |
| (2 * (z * ΞΈ i)) β’ deriv f i x + ((z * ΞΈ i) ^ 2) β’ f x) := by | |
| have hdf := (contDiff_deriv hf i).differentiable (by simp) | |
| have hfd := hf.differentiable (by simp) | |
| rw [deriv_expPhase_smul hfd, | |
| deriv_expPhase_smul (f := fun x => deriv f i x + (z * ΞΈ i) β’ f x) | |
| (hdf.fun_add (hfd.fun_const_smul (z * ΞΈ i))), | |
| deriv_add hdf (hfd.fun_const_smul (z * ΞΈ i)), | |
| deriv_const_smul hfd] | |
| funext x | |
| apply congrArg (fun y : Y => expPhase ΞΈ z x β’ y) | |
| simp only [smul_add, smul_smul, pow_two] | |
| module | |
| /-- Exact second-order conjugation before using the characteristic equation. -/ | |
| lemma laplacian_expPhase_smul {f : X β Y} (hf : ContDiff β (β€ : ββ) f) | |
| (ΞΈ : Direction) (z : β) : | |
| laplacian (fun x => expPhase ΞΈ z x β’ f x) = fun x => | |
| expPhase ΞΈ z x β’ (laplacian f x + | |
| (2 * z) β’ (β i, ΞΈ i β’ deriv f i x) + | |
| (z ^ 2 * (β i, ΞΈ i * ΞΈ i)) β’ f x) := by | |
| funext x | |
| simp only [laplacian, second_deriv_expPhase_smul hf, β Finset.smul_sum, | |
| Finset.sum_add_distrib] | |
| apply congrArg (fun y : Y => expPhase ΞΈ z x β’ y) | |
| have hβ : (β i : Fin 3, (2 * (z * ΞΈ i)) β’ deriv f i x) = | |
| (2 * z) β’ β i, ΞΈ i β’ deriv f i x := by | |
| simp [Finset.smul_sum, smul_smul, mul_assoc] | |
| have hβ : (β i : Fin 3, ((z * ΞΈ i) ^ 2) β’ f x) = | |
| (z ^ 2 * (β i, ΞΈ i * ΞΈ i)) β’ f x := by | |
| rw [β Finset.sum_smul] | |
| apply congrArg (fun a : β => a β’ f x) | |
| simp only [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| rw [hβ, hβ] | |
| /-- The null phase removes the order-two parameter term, exactly as used in | |
| both the supported estimate and the formal physical recursion. -/ | |
| lemma laplacian_expPhase_smul_null {f : X β Y} (hf : ContDiff β (β€ : ββ) f) | |
| (ΞΈ : Direction) (hΞΈ : (β i, ΞΈ i * ΞΈ i) = 0) (z : β) : | |
| laplacian (fun x => expPhase ΞΈ z x β’ f x) = fun x => | |
| expPhase ΞΈ z x β’ (laplacian f x + (2 * z) β’ (β i, ΞΈ i β’ deriv f i x)) := by | |
| simpa [hΞΈ] using laplacian_expPhase_smul hf ΞΈ z | |
| /-- Full normalized conjugation identity, retaining the lower-order matrices. -/ | |
| lemma normalized_expPhase_smul {f : X β Y} (hf : ContDiff β (β€ : ββ) f) | |
| (A : Fin 3 β X β Y βL[β] Y) (Aβ : X β Y βL[β] Y) | |
| (ΞΈ : Direction) (hΞΈ : (β i, ΞΈ i * ΞΈ i) = 0) (z : β) : | |
| normalizedOperator A Aβ (fun x => expPhase ΞΈ z x β’ f x) = | |
| fun x => expPhase ΞΈ z x β’ (normalizedOperator A Aβ f x + | |
| (2 * z) β’ (β i, ΞΈ i β’ deriv f i x) + | |
| z β’ (β i, ΞΈ i β’ A i x (f x))) := by | |
| funext x | |
| simp only [normalizedOperator, laplacian_expPhase_smul_null hf ΞΈ hΞΈ, | |
| deriv_expPhase_smul (hf.differentiable (by simp)), map_smul, map_add, | |
| smul_add, smul_smul, Finset.sum_add_distrib, Finset.smul_sum, mul_assoc] | |
| abel | |
| end ElasticityCarleman | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set | |
| open scoped BigOperators SchwartzMap | |
| namespace ElasticityCGO | |
| open ElasticityAugmented | |
| open ElasticityPhysicalAlgebra (toSmooth toSmooth_apply toSmooth_physical physical) | |
| open ElasticityCarleman (phaseCLM phaseCLM_e) | |
| /-- Actual Schwartz representatives of the exponential physical fields on a | |
| bounded region. No temperate behavior of the exponential is assumed. -/ | |
| def expCut (Ο : Smooth) (hc : HasCompactSupport (Ο : X β β)) | |
| (z : Fin 3 β β) (f : S) : S := | |
| cut Ο hc (exponential (phaseCLM z)*toSmooth f) | |
| @[simp] lemma expCut_apply (Ο : Smooth) (hc : HasCompactSupport (Ο : X β β)) | |
| (z : Fin 3 β β) (f : S) (x : X) : | |
| expCut Ο hc z f x=(Ο : X β β) x*Complex.exp (phaseCLM z x)*f x := by | |
| change (Ο : X β β) x*(Complex.exp (phaseCLM z x)*f x)=_ | |
| ring | |
| lemma shifted_zero : shifted coord (0 : Fin 3 β β)=fun j => (coord j).toLinearMap := by | |
| funext j | |
| apply LinearMap.ext | |
| intro f | |
| change coord j f+(0 : β) β’ f=coord j f | |
| rw [zero_smul,add_zero] | |
| lemma phaseCLM_coords (z : Fin 3 β β) : (fun j => phaseCLM z (e j))=z := by | |
| funext j | |
| exact phaseCLM_e z j | |
| /-- The literal unshifted stress-divergence of a cut-off exponential field. -/ | |
| theorem expCut_physical {U : Set X} (hU : IsOpen U) (lam m Ο : Smooth) | |
| (hl : (lam : X β β).HasTemperateGrowth) (hm : (m : X β β).HasTemperateGrowth) | |
| (hc : HasCompactSupport (Ο : X β β)) (hΟ : EqOn (Ο : X β β) 1 U) | |
| (z : Fin 3 β β) (f : Fin 3 β S) (i : Fin 3) : | |
| EqOn (physical 0 lam m (fun j => expCut Ο hc z (f j)) i : X β β) | |
| (fun x => Complex.exp (phaseCLM z x)*physical z lam m f i x) U := by | |
| intro x hx | |
| change physical 0 lam m (fun j => cut Ο hc (exponential (phaseCLM z)*toSmooth (f j))) i x=_ | |
| rw [physical_cut_local hU 0 lam m Ο hl hm hc hΟ _ i hx,shifted_zero, | |
| physical_exponential_conjugation,phaseCLM_coords,β toSmooth_physical z lam m hl hm f i] | |
| rfl | |
| theorem expCut_solution {U : Set X} (hU : IsOpen U) (lam m Ο : Smooth) | |
| (hl : (lam : X β β).HasTemperateGrowth) (hm : (m : X β β).HasTemperateGrowth) | |
| (hc : HasCompactSupport (Ο : X β β)) (hΟ : EqOn (Ο : X β β) 1 U) | |
| (z : Fin 3 β β) (f : Fin 3 β S) | |
| (hf : β i,EqOn (physical z lam m f i : X β β) 0 U) : | |
| β i,EqOn (physical 0 lam m (fun j => expCut Ο hc z (f j)) i : X β β) 0 U := by | |
| intro i x hx | |
| rw [expCut_physical hU lam m Ο hl hm hc hΟ z f i hx] | |
| change Complex.exp (phaseCLM z x)*physical z lam m f i x=0 | |
| rw [hf i hx] | |
| exact mul_zero _ | |
| /-- The full actual divergence is the exponential times the shifted divergence. -/ | |
| theorem div_exponential (z : Fin 3 β β) (u : Fin 3 β Smooth) : | |
| div coord (fun j => exponential (phaseCLM z)*u j)= | |
| exponential (phaseCLM z)*divT (shifted coord z) u := by | |
| have hh (j) : coord j (exponential (phaseCLM z))=z j β’ exponential (phaseCLM z) := by | |
| rw [coord_exponential] | |
| exact congrArg (fun c : β => c β’ exponential (phaseCLM z)) (phaseCLM_e z j) | |
| simp only [div,divT,deriv_phase_mul coord z (exponential (phaseCLM z)) hh,Finset.mul_sum] | |
| end ElasticityCGO | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set | |
| open scoped BigOperators SchwartzMap | |
| namespace ElasticityCGO | |
| open ElasticityAugmented | |
| open ElasticityPhysicalAlgebra (physical physical_eqOn_of_eqOn divShift shiftD shiftD_apply) | |
| open ElasticityCarleman (phaseCLM) | |
| lemma phaseCLM_neg (z : Fin 3 β β) : phaseCLM (-z)=-phaseCLM z := by | |
| ext x | |
| simp only [ElasticityCarleman.phaseCLM,sum_apply,smul_apply, | |
| Pi.neg_apply,neg_apply,smul_eq_mul,neg_mul,Finset.sum_neg_distrib] | |
| lemma expCut_support (Ο : Smooth) (hc : HasCompactSupport (Ο : X β β)) | |
| (z : Fin 3 β β) (f : S) : tsupport (expCut Ο hc z f : X β β)βtsupport (f : X β β) := by | |
| have he : (expCut Ο hc z f : X β β)= | |
| (fun x => (Ο : X β β) x*Complex.exp (phaseCLM z x))*(f : X β β) := by | |
| funext x | |
| exact expCut_apply Ο hc z f x | |
| rw [he] | |
| exact tsupport_mul_subset_right | |
| /-- Factoring the transferred PHYSICAL solution gives a shifted physical | |
| solution. The compact difference is multiplied by the inverse exponential only | |
| on a compact support, never regarded as a global temperate multiplier. -/ | |
| theorem transferred_amplitude {B K : Set X} (hB : IsOpen B) | |
| (lam m Ο : Smooth) (hl : (lam : X β β).HasTemperateGrowth) | |
| (hm : (m : X β β).HasTemperateGrowth) (hc : HasCompactSupport (Ο : X β β)) | |
| (hΟ : EqOn (Ο : X β β) 1 B) (z : Fin 3 β β) (u F H : Fin 3 β S) | |
| (hF : β i x,xβB β F i x=Complex.exp (phaseCLM z x)*u i x) | |
| (hH : β i,tsupport (H i : X β β)βK) | |
| (hsol : β i,EqOn (physical 0 lam m (F+H) i : X β β) 0 B) : | |
| β v : Fin 3 β S, | |
| (β i,tsupport (v i-u i : S)βK) β§ | |
| (β i,EqOn (physical z lam m v i : X β β) 0 B) β§ | |
| (β i x,xβB β Complex.exp (phaseCLM z x)*v i x=F i x+H i x) := by | |
| let w : Fin 3 β S := fun i => expCut Ο hc (-z) (H i) | |
| let v := u+w | |
| have he : β i x,xβB β Complex.exp (phaseCLM z x)*v i x=F i x+H i x := by | |
| intro i x hx | |
| change Complex.exp (phaseCLM z x)*(u i x+w i x)=F i x+H i x | |
| dsimp [w] | |
| rw [expCut_apply,hΟ hx,Pi.one_apply,one_mul,phaseCLM_neg] | |
| change Complex.exp (phaseCLM z x)*(u i x+Complex.exp (-(phaseCLM z x))*H i x)=F i x+H i x | |
| rw [mul_add,β mul_assoc,β Complex.exp_add,add_neg_cancel,Complex.exp_zero,one_mul,hF i x hx] | |
| have hex : β i,EqOn (expCut Ο hc z (v i) : X β β) ((F+H) i) B := by | |
| intro i x hx | |
| rw [expCut_apply,hΟ hx,Pi.one_apply,one_mul] | |
| exact he i x hx | |
| refine β¨v,fun i => ?_,fun i x hx => ?_,heβ© | |
| Β· have hv : v i-u i=w i := by dsimp [v]; simp only [add_sub_cancel_left] | |
| rw [hv] | |
| exact (expCut_support Ο hc (-z) (H i)).trans (hH i) | |
| Β· have hp := physical_eqOn_of_eqOn hB 0 lam m hl hm | |
| (fun j => expCut Ο hc z (v j)) (F+H) hex i hx | |
| rw [expCut_physical hB lam m Ο hl hm hc hΟ z v i hx] at hp | |
| have hz : Complex.exp (phaseCLM z x)*physical z lam m v i x=0 := hp.trans (hsol i hx) | |
| exact (mul_eq_zero.mp hz).resolve_left (Complex.exp_ne_zero _) | |
| /-- The actual shifted divergence of the compact physical difference also has | |
| compact support; no separate scalar field is introduced. -/ | |
| lemma divShift_supported {K : Set X} (hK : IsClosed K) (z : Fin 3 β β) | |
| (u : Fin 3 β S) (hu : β i,tsupport (u i : X β β)βK) : | |
| tsupport (divShift z u : X β β)βK := by | |
| apply closure_minimal _ hK | |
| intro x hx | |
| by_contra hnot | |
| apply hx | |
| have hh (i : Fin 3) : u i x=0 := image_eq_zero_of_notMem_tsupport (fun ht => hnot (hu i ht)) | |
| have hd (i : Fin 3) : ElasticitySchwartzCarleman.d (e i) (u i) x=0 := by | |
| apply image_eq_zero_of_notMem_tsupport | |
| intro ht | |
| exact hnot (hu i ((tsupport_fderiv_apply_subset β (e i)) ht)) | |
| simp only [divShift,sum_apply,shiftD_apply,add_apply, | |
| smul_apply,hh,smul_zero,add_zero] | |
| change (β i, ElasticitySchwartzCarleman.d (e i) (u i) x)=0 | |
| simp only [hd,Finset.sum_const_zero] | |
| end ElasticityCGO | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set | |
| open scoped BigOperators SchwartzMap | |
| namespace ElasticityPhysicalEstimate | |
| open ElasticityBessel ElasticitySchwartzCarleman ElasticityNegativeOrder ElasticityPhysicalAlgebra | |
| open ElasticityAugmented (coord coeffA coeffV) | |
| open ElasticityCoeffBounds | |
| /-- The scalar component is the actual shifted divergence. -/ | |
| def physicalAug (z : Fin 3 β β) (u : Fin 3 β S) : Fin 4 β S := | |
| Fin.cons (divShift z u) u | |
| lemma physicalAug_sub (z : Fin 3 β β) (u v : Fin 3 β S) : | |
| physicalAug z (v-u)=physicalAug z v-physicalAug z u := by | |
| funext i | |
| refine Fin.cases ?_ (fun i => ?_) i | |
| Β· simp only [physicalAug,Fin.cons_zero,Pi.sub_apply,divShift,map_sub,Finset.sum_sub_distrib] | |
| Β· rfl | |
| lemma physicalAug_supported {K : Set X} (hK : IsClosed K) (z : Fin 3 β β) | |
| (u : Fin 3 β S) (hu : β i,tsupport (u i : X β β)βK) : | |
| β i,tsupport (physicalAug z u i : X β β)βK := by | |
| intro i | |
| refine Fin.cases ?_ (fun i => hu i) i | |
| exact ElasticityCGO.divShift_supported hK z u hu | |
| theorem physical_compact_comparison {B K : Set X} (hB : IsOpen B) | |
| (hK : IsClosed K) (hKB : KβB) (R : β) (hR : 1β€R) | |
| (hKR : KβMetric.closedBall 0 R) (Ξ± Ξ² : X) (hΞ± : Ξ±β 0) | |
| (lam m : Fin 2 β Smooth) | |
| (hl : β q,ExteriorConstant (lam q)) (hm : β q,ExteriorConstant (m q)) | |
| (hm0 : β q x,(m q : X β β) xβ 0) | |
| (he0 : β q x,((lam q+m q+m q : Smooth) : X β β) xβ 0) | |
| (hel : EqOn (lam 0 : X β β) (lam 1) KαΆ) | |
| (hem : EqOn (m 0 : X β β) (m 1) KαΆ) : | |
| β C hβ : β,0<C β§ 0<hβ β§ β h : β,0<h β hβ€hβ β | |
| β u v : Fin 3 β S, | |
| (β i,tsupport ((v-u) i : X β β)βK) β | |
| (β i,EqOn (physical (phase h Ξ± Ξ²) (lam 0) (m 0) u i : X β β) 0 B) β | |
| (β i,EqOn (physical (phase h Ξ± Ξ²) (lam 1) (m 1) v i : X β β) 0 B) β | |
| sobNorm h 1 (physicalAug (phase h Ξ± Ξ²) (v-u)) β€ | |
| C*sobNorm h 1 (physicalAug (phase h Ξ± Ξ²) u) := by | |
| let n := fun q => reciprocal (m q) (hm0 q) | |
| let o := fun q => reciprocal (lam q+m q+m q) (he0 q) | |
| have hn (q) : ExteriorConstant (n q) := (hm q).reciprocal (hm0 q) | |
| have ho (q) : ExteriorConstant (o q) := (((hl q).add (hm q)).add (hm q)).reciprocal (he0 q) | |
| have hni (q) : n q*m q=1 := reciprocal_mul _ _ | |
| have hoi (q) : o q*(lam q+m q+m q)=1 := reciprocal_mul _ _ | |
| have ha (q) := exterior_coeffA (hl q) (hm q) (hn q) (ho q) | |
| have hv (q) := exterior_coeffV (hl q) (hm q) (hn q) (ho q) | |
| have hc (q) := exterior_cPhys (hm q) (hn q) | |
| let a := fun q => aPhys (lam q) (m q) (n q) (o q) | |
| let w := fun q => vPhys (lam q) (m q) (n q) (o q) | |
| have hag (q k i j) : (a q k i j).HasTemperateGrowth := (ha q k i j).growth.neg | |
| have hwg (q i j) : (w q i j).HasTemperateGrowth := (hv q i j).growth.neg | |
| obtain β¨A,hA,hbaβ© := ExteriorConstant.uniform_bound | |
| (fun t : Fin 2 Γ Fin 3 Γ Fin 4 Γ Fin 4 => | |
| coeffA coord (lam t.1) (m t.1) (n t.1) (o t.1) t.2.1 t.2.2.1 t.2.2.2) | |
| (fun t => ha t.1 t.2.1 t.2.2.1 t.2.2.2) | |
| obtain β¨V,hV,hbvβ© := ExteriorConstant.uniform_bound | |
| (fun t : Fin 2 Γ Fin 4 Γ Fin 4 => | |
| coeffV coord (lam t.1) (m t.1) (n t.1) (o t.1) t.2.1 t.2.2) | |
| (fun t => hv t.1 t.2.1 t.2.2) | |
| have hba' (q k i j x) : βa q k i j xββ€A := by | |
| simpa only [a,aPhys,Pi.neg_apply,norm_neg] using hba (q,k,i,j) x | |
| have hbw' (q i j x) : βw q i j xββ€V := by | |
| simpa only [w,vPhys,Pi.neg_apply,norm_neg] using hbv (q,i,j) x | |
| let Z := β i,β((Ξ± i : β)+Complex.I*(Ξ² i : β))β | |
| have hZ : 0β€Z := Finset.sum_nonneg (fun i _ => norm_nonneg _) | |
| have hz (i : Fin 3) : β((Ξ± i : β)+Complex.I*(Ξ² i : β))ββ€Z := | |
| Finset.single_le_sum (fun j _ => norm_nonneg ((Ξ± j : β)+Complex.I*(Ξ² j : β))) (Finset.mem_univ i) | |
| obtain β¨C,hβ,hC,hhβ,hestβ© := compact_comparison_estimate R hR Ξ± Ξ² hΞ± | |
| (a 0) (a 1) (w 0) (w 1) (hag 0) (hag 1) (hwg 0) (hwg 1) | |
| A V Z hA hV hZ (hba' 0) (hba' 1) (hbw' 0) (hbw' 1) hz | |
| obtain β¨hea,hevβ© := ElasticityAugmented.normalized_coefficients_eqOn hK.isOpen_compl | |
| (lam 0) (m 0) (n 0) (o 0) (lam 1) (m 1) (n 1) (o 1) | |
| (hni 0) (hni 1) (hoi 0) (hoi 1) hel hem | |
| refine β¨C,hβ,hC,hhβ,fun h hh hsmall u v hs hu hv' => ?_β© | |
| have hs' := physicalAug_supported hK (phase h Ξ± Ξ²) (v-u) hs | |
| have hlocal (q) (f : Fin 3 β S) | |
| (hf : β i,EqOn (physical (phase h Ξ± Ξ²) (lam q) (m q) f i : X β β) 0 B) := | |
| physical_dirSystem_on hB h hh.ne' Ξ± Ξ² (lam q) (m q) (n q) (o q) | |
| (hni q) (hoi q) (hl q).growth (hm q).growth (hn q).growth (ho q).growth | |
| (fun k i j => (ha q k i j).growth) (fun i j => (hv q i j).growth) | |
| (fun i => (hc q i).growth) f hf | |
| rw [physicalAug_sub] at hs' β’ | |
| refine hest h hh hsmall _ _ (fun i => ?_) ?_ | |
| Β· intro x hx | |
| have ht := hKR (hs' i (subset_tsupport _ hx)) | |
| simpa only [Metric.mem_closedBall,dist_zero_right] using ht | |
| Β· apply compact_forcing_identity hKB h Ξ± Ξ² (a 0) (a 1) (w 0) (w 1) | |
| (hag 0) (hag 1) (hwg 0) (hwg 1) _ _ _ _ hs' (hlocal 0 u hu) (hlocal 1 v hv') | |
| Β· intro k i j x hx | |
| exact congrArg Neg.neg (hea k i j hx) | |
| Β· intro i j x hx | |
| exact congrArg Neg.neg (hev i j hx) | |
| end ElasticityPhysicalEstimate | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open Set MeasureTheory | |
| namespace Elasticity | |
| variable {Ξ© : Set X} {lβ mβ lβ mβ : X β β} | |
| lemma energy_coeff_congr_ae | |
| (hl : lβ =α΅[volume.restrict Ξ©] lβ) (hm : mβ =α΅[volume.restrict Ξ©] mβ) : | |
| energy Ξ© lβ mβ=energy Ξ© lβ mβ := by | |
| funext u v | |
| apply integral_congr_ae | |
| filter_upwards [hl,hm] with x hxl hxm | |
| rw [hxl,hxm] | |
| /-- The variational DN definition really depends only on the interior | |
| coefficients, including its choice branch. No exterior identification is presumed. -/ | |
| theorem DN_coeff_congr_ae | |
| (hl : lβ =α΅[volume.restrict Ξ©] lβ) (hm : mβ =α΅[volume.restrict Ξ©] mβ) : | |
| DN Ξ© lβ mβ=DN Ξ© lβ mβ := by | |
| have he := energy_coeff_congr_ae hl hm | |
| have hws : WeakSolution Ξ© lβ mβ=WeakSolution Ξ© lβ mβ := by | |
| funext u | |
| apply propext | |
| unfold WeakSolution | |
| rw [he] | |
| have hsol : dirichletSolution Ξ© lβ mβ=dirichletSolution Ξ© lβ mβ := by | |
| funext f | |
| unfold dirichletSolution | |
| rw [hws] | |
| change (fun (f g : BoundaryData Ξ©) => energy Ξ© lβ mβ (dirichletSolution Ξ© lβ mβ f) g.out) = | |
| (fun (f g : BoundaryData Ξ©) => energy Ξ© lβ mβ (dirichletSolution Ξ© lβ mβ f) g.out) | |
| rw [he,hsol] | |
| theorem DN_coeff_congr (hΞ© : MeasurableSet Ξ©) (hl : EqOn lβ lβ Ξ©) (hm : EqOn mβ mβ Ξ©) : | |
| DN Ξ© lβ mβ=DN Ξ© lβ mβ := by | |
| apply DN_coeff_congr_ae | |
| Β· filter_upwards [ae_restrict_mem hΞ©] with x hx | |
| exact hl hx | |
| Β· filter_upwards [ae_restrict_mem hΞ©] with x hx | |
| exact hm hx | |
| end Elasticity | |
| end | |
| end | |
| end OAI | |