| import OAI.MathematicalPhysics.Elasticity.Planar |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace ElasticityPlanar |
| open MeasureTheory TemperedDistribution Set |
| open scoped ENNReal SchwartzMap BigOperators |
| open ElasticityRegularity |
| variable {n : Type*} [Fintype n] |
| abbrev PL2 := Lp ℂ 2 (volume : Measure ℂ) |
|
|
| lemma lp_dist_add (f g : PL2) : ((f+g : PL2) : 𝓢'(ℂ,ℂ))=(f : 𝓢'(ℂ,ℂ))+(g : 𝓢'(ℂ,ℂ)) := |
| (Lp.toTemperedDistributionCLM ℂ (volume : Measure ℂ) 2).map_add f g |
| lemma lp_dist_smul (c : ℝ) (f : PL2) : ((c • f : PL2) : 𝓢'(ℂ,ℂ))=c • (f : 𝓢'(ℂ,ℂ)) := by |
| change (((c : ℂ) • f : PL2) : 𝓢'(ℂ,ℂ))=(c : ℂ) • (f : 𝓢'(ℂ,ℂ)) |
| exact (Lp.toTemperedDistributionCLM ℂ (volume : Measure ℂ) 2).map_smul (c : ℂ) f |
| lemma lp_dist_sum (f : n → PL2) : ((∑ j, f j : PL2) : 𝓢'(ℂ,ℂ))=∑ j, (f j : 𝓢'(ℂ,ℂ)) := |
| map_sum (Lp.toTemperedDistributionCLM ℂ (volume : Measure ℂ) 2) f _ |
|
|
| / |
| multiplication on distributions; it is not a formal bounded-operator model. -/ |
| theorem exists_matrix_multiplier (a : n → n → ℂ → ℂ) |
| (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hc : ∀ i j, HasCompactSupport (a i j)) : |
| ∃ M : Hilbert n →L[ℂ] Hilbert n, ∀ (f : Hilbert n) (i : n), |
| (M f i : 𝓢'(ℂ,ℂ))=∑ j, smulLeftCLM ℂ (a i j) (f j : 𝓢'(ℂ,ℂ)) := by |
| choose L hL using fun i j => exists_bounded_nat_multiplier 0 (ha i j) (hc i j) |
| let e := PiLp.continuousLinearEquiv 2 ℂ (fun _ : n => PL2) |
| let M' : (n → PL2) →L[ℂ] (n → PL2) := |
| ContinuousLinearMap.pi (fun i => ∑ j, (L i j).comp (ContinuousLinearMap.proj j)) |
| refine ⟨e.symm.toContinuousLinearMap.comp (M'.comp e.toContinuousLinearMap),fun f i => ?_⟩ |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearEquiv.coe_coe,e, |
| PiLp.continuousLinearEquiv_apply,PiLp.continuousLinearEquiv_symm_apply,WithLp.ofLp_toLp, |
| M',ContinuousLinearMap.pi_apply,sum_apply,ContinuousLinearMap.proj_apply] |
| rw [lp_dist_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simpa only [Nat.cast_zero,sobolevInjection,neg_zero,besselPotential_zero,ContinuousLinearMap.id_comp, |
| ContinuousLinearMap.comp_apply,ContinuousLinearMap.id_apply,Lp.toTemperedDistributionCLM_apply] using hL i j (f j) |
|
|
| theorem exists_planar_distribution_inverse {S Ω : Set ℂ} (hS : IsCompact S) |
| (hΩ : Ω ⊆ S) (a : n → n → ℂ → ℂ) |
| (ha : ∀ i j, (a i j).HasTemperateGrowth) : |
| ∃ T : Hilbert n →L[ℂ] Hilbert n, ∀ f : Hilbert n, ∀ i, |
| LocalEqual Ω (ElasticityPlanarDistribution.dbar (T f i : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (a i j) (T f j : 𝓢'(ℂ,ℂ))) (f i : 𝓢'(ℂ,ℂ)) := by |
| obtain ⟨C,hC,T,hT,heq⟩ := exists_planar_weak_inverse hS a (fun i j => (ha i j).1) |
| exact ⟨T,fun f => weak_to_local_equation Ω S hΩ a ha (T f) f (heq f)⟩ |
|
|
| / |
| the coefficient homotopy s*a. This supplies the parameter ingredient for frame |
| construction without invoking holomorphic bundle triviality. -/ |
| theorem local_homotopy_inverse {S Ω : Set ℂ} (hS : IsCompact S) (hΩ : Ω ⊆ S) |
| (a : n → n → ℂ → ℂ) (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hc : ∀ i j, HasCompactSupport (a i j)) (s₀ : ℝ) : |
| ∃ (U : Set ℝ) (T : ℝ → Hilbert n →L[ℂ] Hilbert n), |
| IsOpen U ∧ s₀ ∈ U ∧ ContDiffOn ℝ (⊤ : ℕ∞) T U ∧ |
| ∀ s ∈ U, ∀ f : Hilbert n, ∀ i, |
| LocalEqual Ω (ElasticityPlanarDistribution.dbar (T s f i : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (fun z => (s : ℂ)*a i j z) |
| (T s f j : 𝓢'(ℂ,ℂ))) (f i : 𝓢'(ℂ,ℂ)) := by |
| have hat (i j : n) : (a i j).HasTemperateGrowth := (hc i j).hasTemperateGrowth (ha i j) |
| have hscaled (c : ℂ) (i j : n) : (fun z => c*a i j z).HasTemperateGrowth := |
| (Function.HasTemperateGrowth.const c).mul (hat i j) |
| obtain ⟨M,hM⟩ := exists_matrix_multiplier a ha hc |
| obtain ⟨T₀,hT₀⟩ := exists_planar_distribution_inverse hS hΩ |
| (fun i j z => (s₀ : ℂ)*a i j z) (fun i j => (Function.HasTemperateGrowth.const _).mul (hat i j)) |
| let B : ℝ → Hilbert n →L[ℂ] Hilbert n := fun s => (s-s₀) • M |
| let T : ℝ → Hilbert n →L[ℂ] Hilbert n := fun s => T₀*Ring.inverse (1+B s*T₀) |
| let U : Set ℝ := {s | ‖B s*T₀‖<1} |
| have hB : ContDiff ℝ (⊤ : ℕ∞) B := (contDiff_id.sub contDiff_const).smul contDiff_const |
| have hopen : IsOpen U := isOpen_lt (hB.continuous.mul continuous_const).norm continuous_const |
| have hBzero : B s₀=0 := by |
| simpa only [B,sub_self] using zero_smul ℝ M |
| have hmem : s₀∈U := by |
| change ‖B s₀*T₀‖<1 |
| rw [hBzero,zero_mul,norm_zero] |
| exact zero_lt_one |
| have hsmooth : ContDiffOn ℝ (⊤ : ℕ∞) T U := fun s hs => |
| (ElasticityDualSolvability.smooth_local_weak_inverse T₀ B hB.contDiffAt hs).contDiffWithinAt |
| refine ⟨U,T,hopen,hmem,hsmooth,fun s hs f i => ?_⟩ |
| change ‖B s*T₀‖<1 at hs |
| have hu : IsUnit (1+B s*T₀) := by |
| simpa only [sub_neg_eq_add] using isUnit_one_sub_of_norm_lt_one |
| (by simpa only [norm_neg] using hs : ‖-(B s*T₀)‖<1) |
| let q := Ring.inverse (1+B s*T₀) f |
| have heq := hT₀ q i |
| have htot : q+B s (T₀ q)=f := by |
| have h := congrArg (fun L : Hilbert n →L[ℂ] Hilbert n => L f) |
| (Ring.mul_inverse_cancel (1+B s*T₀) hu) |
| simpa only [mul_apply_eq_comp,add_apply,one_apply_eq_self] using h |
| have hprod : ((B s (T₀ q)) i : 𝓢'(ℂ,ℂ))= |
| ∑ j, smulLeftCLM ℂ (fun z => (((s-s₀ : ℝ) : ℂ))*a i j z) (T₀ q j : 𝓢'(ℂ,ℂ)) := by |
| change (((s-s₀) • M (T₀ q) : Hilbert n) i : 𝓢'(ℂ,ℂ))=_ |
| simp only [PiLp.smul_apply,lp_dist_smul,hM,Finset.smul_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| ext φ |
| simp only [smul_apply,smulLeftCLM_apply_apply] |
| change (s-s₀) • ((T₀ q j : 𝓢'(ℂ,ℂ)) (SchwartzMap.smulLeftCLM ℂ (a i j) φ))=_ |
| change (((s-s₀ : ℝ) : ℂ)) • ((T₀ q j : 𝓢'(ℂ,ℂ)) (SchwartzMap.smulLeftCLM ℂ (a i j) φ))=_ |
| rw [← map_smul] |
| congr 1 |
| ext z |
| simp only [SchwartzMap.smulLeftCLM_apply_apply (hat i j), |
| SchwartzMap.smulLeftCLM_apply_apply (hscaled ((s-s₀ : ℝ) : ℂ) i j), |
| smul_eq_mul,smul_apply] |
| ring |
| intro φ hφ hφs |
| have he := heq φ hφ hφs |
| have ht := congrArg (fun v : Hilbert n => (v i : 𝓢'(ℂ,ℂ)) φ) htot |
| rw [PiLp.add_apply,lp_dist_add,hprod] at ht |
| change _= _ at he |
| change ((ElasticityPlanarDistribution.dbar (T₀ q i : 𝓢'(ℂ,ℂ)))+ |
| ∑ j, smulLeftCLM ℂ (fun z => (s : ℂ)*a i j z) (T₀ q j : 𝓢'(ℂ,ℂ))) φ=_ |
| have hc' (j : n) : smulLeftCLM ℂ (fun z => (s : ℂ)*a i j z) (T₀ q j : 𝓢'(ℂ,ℂ))= |
| smulLeftCLM ℂ (fun z => (s₀ : ℂ)*a i j z) (T₀ q j : 𝓢'(ℂ,ℂ))+ |
| smulLeftCLM ℂ (fun z => (((s-s₀ : ℝ) : ℂ))*a i j z) (T₀ q j : 𝓢'(ℂ,ℂ)) := by |
| ext ψ |
| simp only [smulLeftCLM_apply_apply,add_apply] |
| rw [← map_add] |
| congr 1 |
| ext z |
| simp only [SchwartzMap.smulLeftCLM_apply_apply (hscaled (s : ℂ) i j), |
| SchwartzMap.smulLeftCLM_apply_apply (hscaled (s₀ : ℂ) i j), |
| SchwartzMap.smulLeftCLM_apply_apply (hscaled ((s-s₀ : ℝ) : ℂ) i j), |
| add_apply,smul_eq_mul] |
| rw [Complex.ofReal_sub] |
| ring |
| simp only [hc',Finset.sum_add_distrib,add_apply] at he ht ⊢ |
| linear_combination he+ht |
| end ElasticityPlanar |
| namespace ElasticityPlanar |
| open MeasureTheory TemperedDistribution Set |
| open scoped ENNReal SchwartzMap BigOperators LineDeriv Manifold |
| open ElasticityRegularity |
| variable {n : Type*} [Fintype n] |
|
|
| def entryInjection (i : n) : Hilbert n →L[ℂ] 𝓢'(ℂ,ℂ) := |
| (Lp.toTemperedDistributionCLM ℂ (volume : Measure ℂ) 2).comp |
| ((ContinuousLinearMap.proj i).comp (PiLp.continuousLinearEquiv 2 ℂ (fun _ : n => PL2)).toContinuousLinearMap) |
| omit [Fintype n] in |
| lemma entryInjection_apply (i : n) (f : Hilbert n) : entryInjection i f=(f i : 𝓢'(ℂ,ℂ)) := rfl |
|
|
| def planarOperator (a : n → n → ℂ → ℂ) (i : n) : Hilbert n →L[ℂ] 𝓢'(ℂ,ℂ) := |
| ((LineDeriv.lineDerivOpCLM ℂ 𝓢'(ℂ,ℂ) (1 : ℂ))+ |
| Complex.I • (LineDeriv.lineDerivOpCLM ℂ 𝓢'(ℂ,ℂ) Complex.I)).comp (entryInjection i)+ |
| ∑ j, (smulLeftCLM ℂ (a i j)).comp (entryInjection j) |
| lemma planarOperator_apply (a : n → n → ℂ → ℂ) (i : n) (f : Hilbert n) : |
| planarOperator a i f=ElasticityPlanarDistribution.dbar (f i : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (a i j) (f j : 𝓢'(ℂ,ℂ)) := by |
| simp only [planarOperator,ContinuousLinearMap.comp_apply,add_apply,smul_apply,sum_apply, |
| entryInjection_apply,LineDeriv.lineDerivOpCLM_apply,ElasticityPlanarDistribution.dbar] |
|
|
| / |
| The patching uses a proved smooth convex selection theorem from Mathlib; |
| it adds no global frame or invertibility assumption to the PDE. -/ |
| theorem global_homotopy_inverse {S Ω : Set ℂ} (hS : IsCompact S) (hΩ : Ω ⊆ S) |
| (a : n → n → ℂ → ℂ) (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hc : ∀ i j, HasCompactSupport (a i j)) : |
| ∃ T : ℝ → Hilbert n →L[ℂ] Hilbert n, |
| ContDiff ℝ (⊤ : ℕ∞) T ∧ ∀ s, ∀ f : Hilbert n, ∀ i, |
| LocalEqual Ω (ElasticityPlanarDistribution.dbar (T s f i : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (fun z => (s : ℂ)*a i j z) (T s f j : 𝓢'(ℂ,ℂ))) |
| (f i : 𝓢'(ℂ,ℂ)) := by |
| let P : ℝ → Set (Hilbert n →L[ℂ] Hilbert n) := fun s => {T | ∀ f i, |
| LocalEqual Ω (planarOperator (fun i j z => (s : ℂ)*a i j z) i (T f)) (f i : 𝓢'(ℂ,ℂ))} |
| have hconv : ∀ s, Convex ℝ (P s) := by |
| intro s T₁ hT₁ T₂ hT₂ b c _ _ hbc f i φ hφ hs |
| have h₁ := hT₁ f i φ hφ hs |
| have h₂ := hT₂ f i φ hφ hs |
| change (planarOperator (fun i j z => (s : ℂ)*a i j z) i |
| ((b : ℂ) • (T₁ f)+(c : ℂ) • (T₂ f))) φ=_ |
| simp only [map_add,map_smul,add_apply,smul_apply,h₁,h₂,smul_eq_mul] |
| have hh : (b : ℂ)+(c : ℂ)=1 := by exact_mod_cast hbc |
| rw [← add_mul,hh,one_mul] |
| have hlocal : ∀ s : ℝ, ∃ U ∈ nhds s, ∃ T : ℝ → Hilbert n →L[ℂ] Hilbert n, |
| ContMDiffOn 𝓘(ℝ,ℝ) 𝓘(ℝ,Hilbert n →L[ℂ] Hilbert n) (⊤ : ℕ∞) T U ∧ |
| ∀ t ∈ U, T t∈P t := by |
| intro s |
| obtain ⟨U,T,hU,hs,hT,heq⟩ := local_homotopy_inverse hS hΩ a ha hc s |
| refine ⟨U,hU.mem_nhds hs,T,hT.contMDiffOn,fun t ht f i => ?_⟩ |
| simp only [planarOperator_apply] |
| exact heq t ht f i |
| obtain ⟨T,hT⟩ := exists_contMDiffMap_forall_mem_convex_of_local 𝓘(ℝ,ℝ) hconv hlocal |
| refine ⟨T,T.contMDiff.contDiff,fun s f i => ?_⟩ |
| simpa only [planarOperator_apply] using hT s f i |
| end ElasticityPlanar |
| section |
| open MeasureTheory TemperedDistribution Set |
| open scoped ENNReal SchwartzMap BigOperators Manifold |
| namespace ElasticityRegularity |
| variable {P E F G : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] |
| [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedSpace ℂ E] [IsScalarTower ℝ ℂ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedSpace ℂ F] [IsScalarTower ℝ ℂ F] |
| [NormedAddCommGroup G] [NormedSpace ℝ G] [NormedSpace ℂ G] [IsScalarTower ℝ ℂ G] |
| lemma complex_clm_apply_smooth {f : P → E →L[ℂ] F} {g : P → E} |
| (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hg : ContDiff ℝ (⊤ : ℕ∞) g) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun p => f p (g p)) := |
| ((ContinuousLinearMap.restrictScalarsL ℂ E F ℝ ℝ).contDiff.comp hf).clm_apply hg |
| omit [NormedSpace ℝ E] [IsScalarTower ℝ ℂ E] in |
| lemma complex_clm_comp_smooth {f : P → F →L[ℂ] G} {g : P → E →L[ℂ] F} |
| (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hg : ContDiff ℝ (⊤ : ℕ∞) g) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun p => (f p).comp (g p)) := by |
| let C := ContinuousLinearMap.compL ℂ E F G |
| exact complex_clm_apply_smooth ((C.restrictScalars ℝ).contDiff.comp hf) hg |
| end ElasticityRegularity |
| namespace ElasticityPlanar |
| open ElasticityRegularity |
| variable {n : Type*} [Fintype n] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
| theorem exists_smooth_matrix_multiplier {K : Set ℂ} (hK : IsCompact K) |
| (a : n → n → P × ℂ → ℂ) (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hs : ∀ i j p z, z∉K → a i j (p,z)=0) : |
| ∃ M : P → Hilbert n →L[ℂ] Hilbert n, |
| ContDiff ℝ (⊤ : ℕ∞) M ∧ ∀ p (f : Hilbert n) i, |
| (M p f i : 𝓢'(ℂ,ℂ))=∑ j, smulLeftCLM ℂ (fun z => a i j (p,z)) (f j : 𝓢'(ℂ,ℂ)) := by |
| choose L hL hLe using fun i j => exists_smooth_lp_multiplier hK (a i j) (ha i j) (hs i j) |
| let e := PiLp.continuousLinearEquiv 2 ℂ (fun _ : n => PL2) |
| let M' : P → (n → PL2) →L[ℂ] (n → PL2) := fun p => |
| ContinuousLinearMap.pi (fun i => ∑ j, (L i j p).comp (ContinuousLinearMap.proj j)) |
| have hM' : ContDiff ℝ (⊤ : ℕ∞) M' := by |
| apply (ContinuousLinearMap.piEquivL ℂ (n → PL2) (fun _ : n => PL2)).toContinuousLinearMap.restrictScalars ℝ |>.contDiff.comp |
| apply contDiff_pi.mpr |
| intro i |
| exact ContDiff.sum (fun j _ => complex_clm_comp_smooth (hL i j) contDiff_const) |
| refine ⟨fun p => e.symm.toContinuousLinearMap.comp ((M' p).comp e.toContinuousLinearMap), |
| complex_clm_comp_smooth contDiff_const (complex_clm_comp_smooth hM' contDiff_const),fun p f i => ?_⟩ |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearEquiv.coe_coe,e, |
| PiLp.continuousLinearEquiv_apply,PiLp.continuousLinearEquiv_symm_apply,WithLp.ofLp_toLp, |
| M',ContinuousLinearMap.pi_apply,sum_apply,ContinuousLinearMap.proj_apply] |
| rw [lp_dist_sum] |
| exact Finset.sum_congr rfl (fun j _ => hLe i j p (f j)) |
|
|
| / |
| not merely scalar multiples of one coefficient. -/ |
| theorem local_variable_inverse {S Ω K : Set ℂ} (hS : IsCompact S) (hΩ : Ω ⊆ S) |
| (hK : IsCompact K) (a : n → n → P × ℂ → ℂ) |
| (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hs : ∀ i j p z, z∉K → a i j (p,z)=0) (p₀ : P) : |
| ∃ (U : Set P) (T : P → Hilbert n →L[ℂ] Hilbert n), |
| IsOpen U ∧ p₀∈U ∧ ContDiffOn ℝ (⊤ : ℕ∞) T U ∧ |
| ∀ p∈U, ∀ (f : Hilbert n) i, |
| LocalEqual Ω (planarOperator (fun i j z => a i j (p,z)) i (T p f)) (f i : 𝓢'(ℂ,ℂ)) := by |
| have hat (p : P) (i j : n) : (fun z => a i j (p,z)).HasTemperateGrowth := by |
| have hc : HasCompactSupport (fun z => a i j (p,z)) := by |
| apply hK.of_isClosed_subset (isClosed_tsupport _) |
| apply closure_minimal _ hK.isClosed |
| intro z hz |
| contrapose! hz |
| simpa only [Function.mem_support,not_not] using hs i j p z hz |
| exact hc.hasTemperateGrowth ((ha i j).comp (contDiff_const.prodMk contDiff_id)) |
| obtain ⟨M,hM,hMe⟩ := exists_smooth_matrix_multiplier hK a ha hs |
| obtain ⟨T₀,hT₀⟩ := exists_planar_distribution_inverse hS hΩ |
| (fun i j z => a i j (p₀,z)) (hat p₀) |
| let B : P → Hilbert n →L[ℂ] Hilbert n := fun p => M p-M p₀ |
| let T : P → Hilbert n →L[ℂ] Hilbert n := fun p => T₀*Ring.inverse (1+B p*T₀) |
| let U : Set P := {p | ‖B p*T₀‖<1} |
| have hB : ContDiff ℝ (⊤ : ℕ∞) B := hM.sub contDiff_const |
| have hopen : IsOpen U := isOpen_lt (hB.continuous.mul continuous_const).norm continuous_const |
| have hmem : p₀∈U := by simp only [U,B,mem_ofPred_eq,sub_self,zero_mul,norm_zero,zero_lt_one] |
| have hsmooth : ContDiffOn ℝ (⊤ : ℕ∞) T U := fun p hp => |
| (ElasticityDualSolvability.smooth_local_weak_inverse T₀ B hB.contDiffAt hp).contDiffWithinAt |
| refine ⟨U,T,hopen,hmem,hsmooth,fun p hp f i => ?_⟩ |
| change ‖B p*T₀‖<1 at hp |
| have hu : IsUnit (1+B p*T₀) := by |
| simpa only [sub_neg_eq_add] using isUnit_one_sub_of_norm_lt_one |
| (by simpa only [norm_neg] using hp : ‖-(B p*T₀)‖<1) |
| let q := Ring.inverse (1+B p*T₀) f |
| have htot : q+B p (T₀ q)=f := by |
| have h := congrArg (fun L : Hilbert n →L[ℂ] Hilbert n => L f) |
| (Ring.mul_inverse_cancel (1+B p*T₀) hu) |
| simpa only [mul_apply_eq_comp,add_apply,one_apply_eq_self] using h |
| have hprod : ((B p (T₀ q)) i : 𝓢'(ℂ,ℂ))= |
| (∑ j, smulLeftCLM ℂ (fun z => a i j (p,z)) (T₀ q j : 𝓢'(ℂ,ℂ)))- |
| (∑ j, smulLeftCLM ℂ (fun z => a i j (p₀,z)) (T₀ q j : 𝓢'(ℂ,ℂ))) := by |
| change (((M p (T₀ q)-M p₀ (T₀ q) : Hilbert n)) i : 𝓢'(ℂ,ℂ))=_ |
| rw [PiLp.sub_apply] |
| change (Lp.toTemperedDistributionCLM ℂ volume 2) (_-_) = _ |
| rw [map_sub] |
| exact congrArg₂ (·-·) (hMe p (T₀ q) i) (hMe p₀ (T₀ q) i) |
| intro φ hφ hφs |
| have he := hT₀ q i φ hφ hφs |
| have ht := congrArg (fun v : Hilbert n => (v i : 𝓢'(ℂ,ℂ)) φ) htot |
| rw [PiLp.add_apply,lp_dist_add,hprod] at ht |
| simp only [planarOperator_apply] |
| change (ElasticityPlanarDistribution.dbar (T₀ q i : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (fun z => a i j (p,z)) (T₀ q j : 𝓢'(ℂ,ℂ))) φ=_ |
| simp only [add_apply,sub_apply] at he ht ⊢ |
| linear_combination he+ht |
| end ElasticityPlanar |
|
|
| end |
| namespace ElasticityPlanar |
| open MeasureTheory TemperedDistribution Set |
| open scoped ENNReal SchwartzMap BigOperators Manifold |
| open ElasticityRegularity |
| variable {n : Type*} [Fintype n] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
| / |
| matrix coefficients over any finite-dimensional real parameter space. -/ |
| theorem global_variable_inverse {S Ω K : Set ℂ} (hS : IsCompact S) (hΩ : Ω ⊆ S) |
| (hK : IsCompact K) (a : n → n → P × ℂ → ℂ) |
| (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hs : ∀ i j p z, z∉K → a i j (p,z)=0) : |
| ∃ T : P → Hilbert n →L[ℂ] Hilbert n, |
| ContDiff ℝ (⊤ : ℕ∞) T ∧ ∀ p, ∀ f : Hilbert n, ∀ i, |
| LocalEqual Ω (planarOperator (fun i j z => a i j (p,z)) i (T p f)) (f i : 𝓢'(ℂ,ℂ)) := by |
| let Q : P → Set (Hilbert n →L[ℂ] Hilbert n) := fun p => {T | ∀ f i, |
| LocalEqual Ω (planarOperator (fun i j z => a i j (p,z)) i (T f)) (f i : 𝓢'(ℂ,ℂ))} |
| have hconv : ∀ p, Convex ℝ (Q p) := by |
| intro p T₁ hT₁ T₂ hT₂ b c _ _ hbc f i φ hφ hφs |
| have h₁ := hT₁ f i φ hφ hφs |
| have h₂ := hT₂ f i φ hφ hφs |
| change (planarOperator (fun i j z => a i j (p,z)) i |
| ((b : ℂ) • (T₁ f)+(c : ℂ) • (T₂ f))) φ=_ |
| simp only [map_add,map_smul,add_apply,smul_apply,h₁,h₂,smul_eq_mul] |
| have hh : (b : ℂ)+(c : ℂ)=1 := by exact_mod_cast hbc |
| rw [← add_mul,hh,one_mul] |
| have hlocal : ∀ p : P, ∃ U ∈ nhds p, ∃ T : P → Hilbert n →L[ℂ] Hilbert n, |
| ContMDiffOn 𝓘(ℝ,P) 𝓘(ℝ,Hilbert n →L[ℂ] Hilbert n) (⊤ : ℕ∞) T U ∧ |
| ∀ t ∈ U, T t∈Q t := by |
| intro p |
| obtain ⟨U,T,hU,hp,hT,heq⟩ := local_variable_inverse hS hΩ hK a ha hs p |
| exact ⟨U,hU.mem_nhds hp,T,hT.contMDiffOn,heq⟩ |
| obtain ⟨T,hT⟩ := exists_contMDiffMap_forall_mem_convex_of_local 𝓘(ℝ,P) hconv hlocal |
| exact ⟨T,T.contMDiff.contDiff,hT⟩ |
| end ElasticityPlanar |
| namespace ElasticityRegularity |
| open MeasureTheory TemperedDistribution |
| open scoped SchwartzMap LineDeriv Laplacian ENNReal |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
|
|
| / |
| constant does not depend on any conjugation parameter or on the unknown. -/ |
| theorem quantitative_laplacian_gain (s : ℝ) : |
| ∃ C : ℝ, 0<C ∧ ∀ f g : Lp ℂ 2 (volume : Measure E), |
| Δ (sobolevInjection s f)=sobolevInjection (s-1) g → |
| ∃ q : Lp ℂ 2 (volume : Measure E), |
| sobolevInjection (s+1) q=sobolevInjection s f ∧ |
| ‖q‖ ≤ C*(‖f‖+‖g‖) := by |
| let H := Lp ℂ 2 (volume : Measure E) |
| let D : 𝓢'(E,ℂ) →L[ℂ] 𝓢'(E,ℂ) := LineDeriv.laplacianCLM ℂ E _ |
| let T : H × H →L[ℂ] 𝓢'(E,ℂ) := (sobolevInjection s).comp (ContinuousLinearMap.fst ℂ H H) |
| let A : H × H →L[ℂ] 𝓢'(E,ℂ) := D.comp T- |
| (sobolevInjection (s-1)).comp (ContinuousLinearMap.snd ℂ H H) |
| let G : Submodule ℂ (H × H) := A.ker |
| have hclosed : IsClosed (G : Set (H × H)) := A.isClosed_ker |
| let : CompleteSpace G := hclosed.completeSpace_coe |
| have he (p : G) : Δ (sobolevInjection s p.1.1)=sobolevInjection (s-1) p.1.2 := by |
| have hp := p.2 |
| change A p.1=0 at hp |
| apply sub_eq_zero.mp |
| simpa only [A,D,T,sub_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.coe_fst',ContinuousLinearMap.coe_snd',laplacianCLM_apply] using hp |
| obtain ⟨L,hL⟩ := exists_continuous_lift (sobolevInjection (E := E) (s+1)) |
| (sobolevInjection_injective (s+1)) (T.comp G.subtypeL) (fun p => by |
| apply (memSobolev_iff_range (s+1) _).mp |
| change MemSobolev (s+1) 2 (sobolevInjection s p.1.1) |
| have hΔ : MemSobolev (s-1) 2 (Δ (sobolevInjection s p.1.1)) := by |
| rw [he] |
| exact sobolevInjection_mem _ _ |
| have h := laplacian_gain ((sobolevInjection_mem s p.1.1).mono (by linarith : s-1 ≤ s)) hΔ |
| rw [show s-1+2=s+1 by ring] at h |
| exact h) |
| refine ⟨‖L‖+1,by positivity,fun f g hfg => ?_⟩ |
| have hG : (f,g) ∈ G := by |
| change A (f,g)=0 |
| simpa only [A,D,T,sub_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.coe_fst',ContinuousLinearMap.coe_snd',laplacianCLM_apply] using |
| (sub_eq_zero.mpr hfg) |
| let p : G := ⟨(f,g),hG⟩ |
| refine ⟨L p,hL p,?_⟩ |
| have hp : ‖p‖ ≤ ‖f‖+‖g‖ := by |
| change max ‖f‖ ‖g‖ ≤ ‖f‖+‖g‖ |
| exact max_le (le_add_of_nonneg_right (norm_nonneg _)) (le_add_of_nonneg_left (norm_nonneg _)) |
| calc |
| ‖L p‖ ≤ ‖L‖*‖p‖ := L.le_opNorm p |
| _ ≤ (‖L‖+1)*(‖f‖+‖g‖) := by gcongr; linarith |
|
|
|
|
| / |
| orthogonal projection only off its graph. On the graph it is the unique actual |
| Sobolev representative. This is used for strong parameter regularity. -/ |
| theorem bounded_laplacian_graph_gain (s : ℝ) : |
| ∃ L : (Lp ℂ 2 (volume : Measure E) × Lp ℂ 2 (volume : Measure E)) →L[ℂ] |
| Lp ℂ 2 (volume : Measure E), |
| ∀ f g, Δ (sobolevInjection s f)=sobolevInjection (s-1) g → |
| sobolevInjection (s+1) (L (f,g))=sobolevInjection s f := by |
| let H := Lp ℂ 2 (volume : Measure E) |
| let X := WithLp 2 (H × H) |
| let e : X ≃L[ℂ] H × H := WithLp.prodContinuousLinearEquiv 2 ℂ H H |
| let D : 𝓢'(E,ℂ) →L[ℂ] 𝓢'(E,ℂ) := LineDeriv.laplacianCLM ℂ E _ |
| let T : X →L[ℂ] 𝓢'(E,ℂ) := (sobolevInjection s).comp |
| ((ContinuousLinearMap.fst ℂ H H).comp e.toContinuousLinearMap) |
| let A : X →L[ℂ] 𝓢'(E,ℂ) := D.comp T- |
| (sobolevInjection (s-1)).comp ((ContinuousLinearMap.snd ℂ H H).comp e.toContinuousLinearMap) |
| let G : Submodule ℂ X := A.ker |
| have hclosed : IsClosed (G : Set X) := A.isClosed_ker |
| let : CompleteSpace G := hclosed.completeSpace_coe |
| have he (p : G) : Δ (sobolevInjection s (e p.1).1)=sobolevInjection (s-1) (e p.1).2 := by |
| have hp := p.2 |
| change A p.1=0 at hp |
| apply sub_eq_zero.mp |
| simpa only [A,D,T,sub_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.coe_fst',ContinuousLinearMap.coe_snd',laplacianCLM_apply, |
| ContinuousLinearEquiv.coe_coe] using hp |
| obtain ⟨L,hL⟩ := exists_continuous_lift (sobolevInjection (E := E) (s+1)) |
| (sobolevInjection_injective (s+1)) (T.comp G.subtypeL) (fun p => by |
| apply (memSobolev_iff_range (s+1) _).mp |
| change MemSobolev (s+1) 2 (sobolevInjection s (e p.1).1) |
| have hΔ : MemSobolev (s-1) 2 (Δ (sobolevInjection s (e p.1).1)) := by |
| rw [he] |
| exact sobolevInjection_mem _ _ |
| have h := laplacian_gain ((sobolevInjection_mem s (e p.1).1).mono (by linarith : s-1 ≤ s)) hΔ |
| rw [show s-1+2=s+1 by ring] at h |
| exact h) |
| refine ⟨(L.comp G.orthogonalProjectionOnto).comp e.symm.toContinuousLinearMap,fun f g hfg => ?_⟩ |
| have hG : e.symm (f,g) ∈ G := by |
| change A (e.symm (f,g))=0 |
| simpa only [A,D,T,sub_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.coe_fst',ContinuousLinearMap.coe_snd',laplacianCLM_apply, |
| ContinuousLinearEquiv.coe_coe,ContinuousLinearEquiv.apply_symm_apply] using |
| (sub_eq_zero.mpr hfg) |
| let p : G := ⟨e.symm (f,g),hG⟩ |
| have hp : G.orthogonalProjectionOnto (e.symm (f,g))=p := |
| G.orthogonalProjectionOnto_mem_subspace_eq_self p |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearEquiv.coe_coe,hp,hL] |
| change sobolevInjection s (e p.1).1=sobolevInjection s f |
| simp only [p,ContinuousLinearEquiv.apply_symm_apply] |
|
|
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| theorem smooth_laplacian_gain (s : ℝ) |
| (f g : P → Lp ℂ 2 (volume : Measure E)) |
| (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| (heq : ∀ p, Δ (sobolevInjection s (f p))=sobolevInjection (s-1) (g p)) : |
| ∃ q : P → Lp ℂ 2 (volume : Measure E), ContDiff ℝ (⊤ : ℕ∞) q ∧ |
| ∀ p, sobolevInjection (s+1) (q p)=sobolevInjection s (f p) := by |
| obtain ⟨L,hL⟩ := bounded_laplacian_graph_gain (E := E) s |
| exact ⟨fun p => L (f p,g p),(L.restrictScalars ℝ).contDiff.comp (hf.prodMk hg), |
| fun p => hL (f p) (g p) (heq p)⟩ |
| end ElasticityRegularity |
| namespace ElasticityRegularity |
| open MeasureTheory TemperedDistribution |
| open scoped SchwartzMap LineDeriv Laplacian BigOperators |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| / |
| representative tied to the given distribution family. -/ |
| def SmoothSobolev (s : ℝ) (u : P → 𝓢'(E,ℂ)) : Prop := |
| ∃ f : P → Lp ℂ 2 (volume : Measure E), ContDiff ℝ (⊤ : ℕ∞) f ∧ |
| ∀ p, sobolevInjection s (f p)=u p |
|
|
| def SmoothLocalSobolev (Ω : Set E) (s : ℝ) (u : P → 𝓢'(E,ℂ)) : Prop := |
| ∀ g : E → ℂ, ContDiff ℝ (⊤ : ℕ∞) g → HasCompactSupport g → tsupport g ⊆ Ω → |
| SmoothSobolev s (fun p => smulLeftCLM ℂ g (u p)) |
|
|
| namespace SmoothSobolev |
| variable {s t : ℝ} {u v : P → 𝓢'(E,ℂ)} |
| lemma add (hu : SmoothSobolev s u) (hv : SmoothSobolev s v) : |
| SmoothSobolev s (fun p => u p+v p) := by |
| obtain ⟨f,hf,he⟩ := hu |
| obtain ⟨g,hg,hg'⟩ := hv |
| exact ⟨fun p => f p+g p,hf.add hg,fun p => by rw [map_add,he,hg']⟩ |
| lemma sub (hu : SmoothSobolev s u) (hv : SmoothSobolev s v) : |
| SmoothSobolev s (fun p => u p-v p) := by |
| obtain ⟨f,hf,he⟩ := hu |
| obtain ⟨g,hg,hg'⟩ := hv |
| exact ⟨fun p => f p-g p,hf.sub hg,fun p => by rw [map_sub,he,hg']⟩ |
| lemma smul (hu : SmoothSobolev s u) (c : P → ℂ) (hc : ContDiff ℝ (⊤ : ℕ∞) c) : |
| SmoothSobolev s (fun p => c p • u p) := by |
| obtain ⟨f,hf,he⟩ := hu |
| exact ⟨fun p => c p • f p,hc.smul hf,fun p => by rw [map_smul,he]⟩ |
| lemma zero : SmoothSobolev s (fun _ : P => (0 : 𝓢'(E,ℂ))) := |
| ⟨fun _ => 0,contDiff_const,fun _ => map_zero _⟩ |
| lemma sum {ι : Type*} (S : Finset ι) (u : ι → P → 𝓢'(E,ℂ)) |
| (hu : ∀ i ∈ S, SmoothSobolev s (u i)) : |
| SmoothSobolev s (fun p => ∑ i ∈ S, u i p) := by |
| classical |
| induction S using Finset.induction_on with |
| | empty => simpa only [Finset.sum_empty] using (zero (s := s) (P := P) (E := E)) |
| | @insert i S hi ih => |
| simp only [Finset.sum_insert hi] |
| exact (hu i (Finset.mem_insert_self _ _)).add |
| (ih (fun j hj => hu j (Finset.mem_insert_of_mem hj))) |
| lemma mono (hu : SmoothSobolev s u) (hst : t ≤ s) : SmoothSobolev t u := by |
| obtain ⟨L,hL⟩ := exists_bounded_sobolev_inclusion (E := E) hst |
| obtain ⟨f,hf,he⟩ := hu |
| exact ⟨fun p => L (f p),(L.restrictScalars ℝ).contDiff.comp hf,fun p => (hL _).trans (he p)⟩ |
| lemma derivative (hu : SmoothSobolev s u) (a : E) : |
| SmoothSobolev (s-1) (fun p => ∂_{a} (u p)) := by |
| obtain ⟨L,hL⟩ := exists_bounded_sobolev_derivative (E := E) s a |
| obtain ⟨f,hf,he⟩ := hu |
| exact ⟨fun p => L (f p),(L.restrictScalars ℝ).contDiff.comp hf,fun p => by rw [hL,he]⟩ |
| lemma laplacian_gain (hu : SmoothSobolev s u) |
| (hΔ : SmoothSobolev (s-1) (fun p => Δ (u p))) : SmoothSobolev (s+1) u := by |
| obtain ⟨f,hf,he⟩ := hu |
| obtain ⟨g,hg,hg'⟩ := hΔ |
| obtain ⟨q,hq,hq'⟩ := smooth_laplacian_gain s f g hf hg (fun p => by rw [he,hg']) |
| exact ⟨q,hq,fun p => (hq' p).trans (he p)⟩ |
| end SmoothSobolev |
|
|
| namespace SmoothLocalSobolev |
| variable {Ω : Set E} {s t : ℝ} {u v : P → 𝓢'(E,ℂ)} |
| lemma add (hu : SmoothLocalSobolev Ω s u) (hv : SmoothLocalSobolev Ω s v) : |
| SmoothLocalSobolev Ω s (fun p => u p+v p) := by |
| intro g hg hc hs |
| simpa only [map_add] using (hu g hg hc hs).add (hv g hg hc hs) |
| lemma sub (hu : SmoothLocalSobolev Ω s u) (hv : SmoothLocalSobolev Ω s v) : |
| SmoothLocalSobolev Ω s (fun p => u p-v p) := by |
| intro g hg hc hs |
| simpa only [map_sub] using (hu g hg hc hs).sub (hv g hg hc hs) |
| lemma smul (hu : SmoothLocalSobolev Ω s u) (c : P → ℂ) (hc : ContDiff ℝ (⊤ : ℕ∞) c) : |
| SmoothLocalSobolev Ω s (fun p => c p • u p) := by |
| intro g hg hcg hs |
| simpa only [map_smul] using (hu g hg hcg hs).smul c hc |
| lemma sum {ι : Type*} (S : Finset ι) (u : ι → P → 𝓢'(E,ℂ)) |
| (hu : ∀ i ∈ S, SmoothLocalSobolev Ω s (u i)) : |
| SmoothLocalSobolev Ω s (fun p => ∑ i ∈ S, u i p) := by |
| intro g hg hc hs |
| simpa only [map_sum] using SmoothSobolev.sum S |
| (fun i p => smulLeftCLM ℂ g (u i p)) (fun i hi => hu i hi g hg hc hs) |
| lemma mono (hu : SmoothLocalSobolev Ω s u) (hst : t ≤ s) : SmoothLocalSobolev Ω t u := |
| fun g hg hc hs => (hu g hg hc hs).mono hst |
| lemma coeff (hu : SmoothLocalSobolev Ω s u) {a : E → ℂ} (ha : a.HasTemperateGrowth) : |
| SmoothLocalSobolev Ω s (fun p => smulLeftCLM ℂ a (u p)) := by |
| intro g hg hc hs |
| simp only [smulLeftCLM_smulLeftCLM_apply ha (hc.hasTemperateGrowth hg),mul_comm a g] |
| exact hu (g*a) (hg.mul ha.1) hc.mul_right (tsupport_mul_subset_left.trans hs) |
| lemma product_derivative (hu : SmoothLocalSobolev Ω s u) {g : E → ℂ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (hc : HasCompactSupport g) (hs : tsupport g ⊆ Ω) (a : E) : |
| SmoothSobolev (s-1) (fun p => smulLeftCLM ℂ g (∂_{a} (u p))) := by |
| have hd := smooth_derivative hg a |
| have hdc := compact_derivative hc a |
| have hds := (derivative_support_subset g a).trans hs |
| have h := ((hu g hg hc hs).derivative a).sub |
| ((hu _ hd hdc hds).mono (by linarith : s-1 ≤ s)) |
| simpa only [distribution_leibniz (hc.hasTemperateGrowth hg) a (hdc.hasTemperateGrowth hd), |
| add_sub_cancel_left] using h |
| lemma derivative (hu : SmoothLocalSobolev Ω s u) (a : E) : |
| SmoothLocalSobolev Ω (s-1) (fun p => ∂_{a} (u p)) := |
| fun _ hg hc hs => hu.product_derivative hg hc hs a |
| lemma congr (hu : SmoothLocalSobolev Ω s u) (he : ∀ p, LocalEqual Ω (v p) (u p)) : |
| SmoothLocalSobolev Ω s v := by |
| intro g hg hc hs |
| have h : (fun p => smulLeftCLM ℂ g (v p))=(fun p => smulLeftCLM ℂ g (u p)) := |
| funext (fun p => (he p).cutoff hg hc hs) |
| rw [h] |
| exact hu g hg hc hs |
|
|
| / |
| family; the proof uses fixed bounded Laplacian graph operators. -/ |
| lemma laplacian_gain (hu : SmoothLocalSobolev Ω s u) |
| (hΔ : SmoothLocalSobolev Ω (s-1) (fun p => Δ (u p))) : |
| SmoothLocalSobolev Ω (s+1) u := by |
| let b := stdOrthonormalBasis ℝ E |
| intro g hg hc hs |
| have hbase := hu g hg hc hs |
| apply SmoothSobolev.laplacian_gain hbase |
| simp only [laplacian_product b hg hc] |
| apply (hΔ g hg hc hs).add |
| apply SmoothSobolev.sum Finset.univ |
| intro i _ |
| have hgd := smooth_derivative hg (b i) |
| have hcd := compact_derivative hc (b i) |
| have hsd := (derivative_support_subset g (b i)).trans hs |
| exact ((hu _ (smooth_derivative hgd (b i)) (compact_derivative hcd (b i)) |
| ((derivative_support_subset _ (b i)).trans hsd)).mono (by linarith)).add |
| ((hu.product_derivative hgd hcd hsd (b i)).smul (fun _ => 2) contDiff_const) |
| end SmoothLocalSobolev |
| end ElasticityRegularity |
| namespace ElasticityRegularity |
| open MeasureTheory TemperedDistribution Set |
| open scoped SchwartzMap LineDeriv Laplacian BigOperators ENNReal |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
|
|
| omit [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E] [FiniteDimensional ℝ P] in |
| lemma smooth_spatial_derivative {a : P × E → ℂ} (ha : ContDiff ℝ (⊤ : ℕ∞) a) (v : E) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun q : P × E => fderiv ℝ (fun x => a (q.1,x)) q.2 v) := by |
| have he : (fun q : P × E => fderiv ℝ (fun x => a (q.1,x)) q.2 v)= |
| (fun q : P × E => fderiv ℝ a q (0,v)) := by |
| funext q |
| have hg : HasFDerivAt (fun x : E => (q.1,x)) (ContinuousLinearMap.inr ℝ P E) q.2 := |
| (hasFDerivAt_const q.1 q.2).prodMk (hasFDerivAt_id q.2) |
| have hh := (ha.differentiable (by simp) (q.1,q.2)).hasFDerivAt.comp q.2 hg |
| change fderiv ℝ (a ∘ Prod.mk q.1) q.2 v=_ |
| rw [hh.fderiv] |
| rfl |
| rw [he] |
| exact (ha.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).clm_apply contDiff_const |
|
|
| omit [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E] [FiniteDimensional ℝ P] in |
| omit [InnerProductSpace ℝ E] [NormedAddCommGroup P] [NormedSpace ℝ P] in |
| lemma compact_slice {S : Set E} (hS : IsCompact S) (a : P × E → ℂ) |
| (hs : ∀ p x, x∉S → a (p,x)=0) (p : P) : HasCompactSupport (fun x => a (p,x)) := by |
| apply hS.of_isClosed_subset (isClosed_tsupport _) |
| exact closure_minimal (fun x hx => by contrapose! hx; simpa only [Function.mem_support,not_not] using hs p x hx) hS.isClosed |
|
|
| omit [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E] [FiniteDimensional ℝ P] in |
| omit [NormedAddCommGroup P] [NormedSpace ℝ P] in |
| lemma spatial_derivative_outside {S : Set E} (hS : IsClosed S) (a : P × E → ℂ) |
| (hs : ∀ p x, x∉S → a (p,x)=0) (v : E) : |
| ∀ p x, x∉S → fderiv ℝ (fun y => a (p,y)) x v=0 := by |
| intro p x hx |
| apply image_eq_zero_of_notMem_tsupport (f := fun y => fderiv ℝ (fun z => a (p,z)) y v) |
| intro hh |
| have ht : tsupport (fun y => a (p,y)) ⊆ S := |
| closure_minimal (fun y hy => by contrapose! hy; simpa only [Function.mem_support,not_not] using hs p y hy) hS |
| exact hx (ht (derivative_support_subset (fun y => a (p,y)) v hh)) |
|
|
| omit [FiniteDimensional ℝ P] in |
| lemma SmoothSobolev.coordinate_gain {s : ℝ} {u : P → 𝓢'(E,ℂ)} |
| (hu : SmoothSobolev s u) |
| (hd : ∀ v : E, SmoothSobolev s (fun p => ∂_{v} (u p))) : |
| SmoothSobolev (s+1) u := by |
| apply hu.laplacian_gain |
| let b := stdOrthonormalBasis ℝ E |
| have h := SmoothSobolev.sum Finset.univ (fun i p => ∂_{b i} (∂_{b i} (u p))) |
| (fun i _ => (hd (b i)).derivative (b i)) |
| simpa only [laplacian_eq_sum b] using h |
|
|
| lemma SmoothSobolev.variable_zero {S : Set E} (hS : IsCompact S) |
| (a : P × E → ℂ) (ha : ContDiff ℝ (⊤ : ℕ∞) a) |
| (hs : ∀ p x, x∉S → a (p,x)=0) {u : P → 𝓢'(E,ℂ)} |
| (hu : SmoothSobolev 0 u) : |
| SmoothSobolev 0 (fun p => smulLeftCLM ℂ (fun x => a (p,x)) (u p)) := by |
| let : CompactSpace S := isCompact_iff_compactSpace.mp hS |
| obtain ⟨b,hb,hbe⟩ := ElasticityCompact.exists_smooth_linf_family hS.measurableSet |
| (volume : Measure E) a ha hs |
| obtain ⟨v,hv,he⟩ := hu |
| simp only [sobolevInjection,neg_zero,besselPotential_zero,ContinuousLinearMap.id_comp, |
| Lp.toTemperedDistributionCLM_apply] at he |
| let B := (ContinuousLinearMap.mul ℝ ℂ).holderL (volume : Measure E) ∞ 2 2 |
| refine ⟨fun p => B (b p) (v p),(B.contDiff.comp hb).clm_apply hv,fun p => ?_⟩ |
| simp only [sobolevInjection,neg_zero,besselPotential_zero,ContinuousLinearMap.id_comp, |
| Lp.toTemperedDistributionCLM_apply] |
| have ha' : ContDiff ℝ (⊤ : ℕ∞) (fun x => a (p,x)) := |
| ha.comp (contDiff_const.prodMk contDiff_id) |
| have hc := compact_slice hS a hs p |
| have hm := compact_bounded_multiplier ha' hc |
| have hprod : B (b p) (v p)=(hm.toLp (fun x => a (p,x))) • v p := by |
| apply Lp.ext |
| filter_upwards [(ContinuousLinearMap.mul ℝ ℂ).coeFn_holder (r := 2) (b p) (v p), |
| Lp.coeFn_lpSMul (r := 2) (hm.toLp _) (v p),hm.coeFn_toLp,hbe p] with x h₁ h₂ h₃ h₄ |
| change ((ContinuousLinearMap.mul ℝ ℂ).holder 2 (b p) (v p)) x=_ |
| rw [h₁,h₂] |
| simp only [Pi.smul_apply',h₃,h₄] |
| rfl |
| rw [hprod,Lp.toTemperedDistribution_smul_eq (hc.hasTemperateGrowth ha') hm,he] |
|
|
| / |
| parameter topology, for each actual nonnegative integral order. -/ |
| theorem SmoothSobolev.variable_nat {S : Set E} (hS : IsCompact S) |
| (N : ℕ) (a : P × E → ℂ) (ha : ContDiff ℝ (⊤ : ℕ∞) a) |
| (hs : ∀ p x, x∉S → a (p,x)=0) {u : P → 𝓢'(E,ℂ)} |
| (hu : SmoothSobolev N u) : |
| SmoothSobolev N (fun p => smulLeftCLM ℂ (fun x => a (p,x)) (u p)) := by |
| induction N generalizing a u with |
| | zero => |
| rw [Nat.cast_zero] at hu ⊢ |
| exact SmoothSobolev.variable_zero hS a ha hs hu |
| | succ N ih => |
| rw [Nat.cast_add,Nat.cast_one] at hu ⊢ |
| have hu' := hu.mono (by norm_num : (N : ℝ) ≤ N+1) |
| apply (ih a ha hs hu').coordinate_gain |
| intro v |
| have hd : SmoothSobolev (N : ℝ) (fun p => ∂_{v} (u p)) := by |
| simpa only [add_sub_cancel_right] using hu.derivative v |
| have hsum := (ih _ (smooth_spatial_derivative ha v) |
| (spatial_derivative_outside hS.isClosed a hs v) hu').add (ih a ha hs hd) |
| convert hsum using 1 |
| funext p |
| have ha' : ContDiff ℝ (⊤ : ℕ∞) (fun x => a (p,x)) := |
| ha.comp (contDiff_const.prodMk contDiff_id) |
| have hc := compact_slice hS a hs p |
| exact distribution_leibniz (hc.hasTemperateGrowth ha') v |
| ((compact_derivative hc v).hasTemperateGrowth (smooth_derivative ha' v)) (u p) |
| end ElasticityRegularity |
| namespace ElasticityPlanarDistribution |
| open MeasureTheory TemperedDistribution Complex |
| open scoped SchwartzMap LineDeriv Laplacian BigOperators |
| open ElasticityRegularity |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] |
| variable {n : Type*} [Fintype n] |
| lemma SmoothLocalSobolev.dhol {Ω : Set ℂ} {s : ℝ} {u : P → Dist} |
| (h : ElasticityRegularity.SmoothLocalSobolev Ω s u) : |
| ElasticityRegularity.SmoothLocalSobolev Ω (s-1) (fun p => dhol (u p)) := |
| (h.derivative 1).sub ((h.derivative I).smul (fun _ => I) contDiff_const) |
|
|
| / |
| theorem smooth_local_gain {Ω : Set ℂ} {s : ℝ} |
| (a : n → n → ℂ → ℂ) (ha : ∀ i j, (a i j).HasTemperateGrowth) |
| (c : P → ℂ) (hc : ContDiff ℝ (⊤ : ℕ∞) c) |
| (u f : P → n → Dist) |
| (heq : ∀ p i, LocalEqual Ω (dbar (u p i)) |
| (f p i+c p • ∑ j, smulLeftCLM ℂ (a i j) (u p j))) |
| (hu : ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω s (fun p => u p i)) |
| (hf : ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω s (fun p => f p i)) : |
| ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω (s+1) (fun p => u p i) := by |
| intro i |
| apply (hu i).laplacian_gain |
| have H := SmoothLocalSobolev.dhol ((hf i).add |
| ((ElasticityRegularity.SmoothLocalSobolev.sum Finset.univ |
| (fun j p => smulLeftCLM ℂ (a i j) (u p j)) |
| (fun j _ => (hu j).coeff (ha i j))).smul c hc)) |
| apply H.congr |
| intro p |
| simpa only [dhol_dbar] using LocalEqual.dhol (heq p i) |
|
|
| theorem smooth_local_all_orders {Ω : Set ℂ} |
| (a : n → n → ℂ → ℂ) (ha : ∀ i j, (a i j).HasTemperateGrowth) |
| (c : P → ℂ) (hc : ContDiff ℝ (⊤ : ℕ∞) c) |
| (u f : P → n → Dist) |
| (heq : ∀ p i, LocalEqual Ω (dbar (u p i)) |
| (f p i+c p • ∑ j, smulLeftCLM ℂ (a i j) (u p j))) |
| (hu : ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω 0 (fun p => u p i)) |
| (hf : ∀ N : ℕ, ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω N (fun p => f p i)) : |
| ∀ N : ℕ, ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω N (fun p => u p i) := by |
| intro N |
| induction N with |
| | zero => simpa only [Nat.cast_zero] using hu |
| | succ N hN => |
| rw [Nat.cast_add,Nat.cast_one] |
| exact smooth_local_gain a ha c hc u f heq hN (hf N) |
| end ElasticityPlanarDistribution |
| namespace ElasticityRegularity |
| open MeasureTheory TemperedDistribution FourierTransform |
| open scoped SchwartzMap ENNReal |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
|
|
| / |
| from the actual Fourier representative and the closed graph theorem. -/ |
| theorem exists_bounded_continuous_embedding {s : ℝ} (hs : Module.finrank ℝ E < 2*s) : |
| ∃ L : Lp ℂ 2 (volume : Measure E) →L[ℂ] BoundedContinuousFunction E ℂ, |
| ∀ f, sobolevInjection s f= |
| (((L f).memLp_top.toLp _ : Lp ℂ ∞ (volume : Measure E)) : 𝓢'(E,ℂ)) := by |
| let J := Lp.toTemperedDistributionCLM ℂ (volume : Measure E) 1 |
| have hJ : Function.Injective J := |
| LinearMap.ker_eq_bot.mp (Lp.ker_toTemperedDistributionCLM_eq_bot (F := ℂ)) |
| obtain ⟨T,hT⟩ := exists_continuous_lift J hJ |
| ((fourierCLM ℂ 𝓢'(E,ℂ)).comp (sobolevInjection s)) (fun f => by |
| obtain ⟨v,hv⟩ := (sobolevInjection_mem s f).fourier_memL1 hs |
| exact ⟨v,hv.symm⟩) |
| let R : Lp ℂ 1 (volume : Measure E) →L[ℂ] BoundedContinuousFunction E ℂ := |
| (BoundedContinuousFunction.compContinuousCLM ℂ ℂ (-ContinuousMap.id E)).comp |
| (Real.Lp.fourierTransformCLM E ℂ) |
| refine ⟨R.comp T,fun f => ?_⟩ |
| change sobolevInjection s f= |
| (((Real.Lp.fourierTransformInv (T f)).memLp_top.toLp _ : Lp ℂ ∞ (volume : Measure E)) : 𝓢'(E,ℂ)) |
| rw [l1_inverse_fourier_distribution] |
| have h := hT f |
| change (T f : 𝓢'(E,ℂ))=𝓕 (sobolevInjection s f) at h |
| rw [h,fourierInv_fourier_eq] |
|
|
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] |
| lemma SmoothSobolev.continuous_representative {s : ℝ} {u : P → 𝓢'(E,ℂ)} |
| (hu : SmoothSobolev s u) (hs : Module.finrank ℝ E < 2*s) : |
| ∃ g : P → BoundedContinuousFunction E ℂ, ContDiff ℝ (⊤ : ℕ∞) g ∧ |
| ∀ p, u p=(((g p).memLp_top.toLp _ : Lp ℂ ∞ (volume : Measure E)) : 𝓢'(E,ℂ)) := by |
| obtain ⟨f,hf,he⟩ := hu |
| obtain ⟨L,hL⟩ := exists_bounded_continuous_embedding hs |
| exact ⟨fun p => L (f p),(L.restrictScalars ℝ).contDiff.comp hf,fun p => (he p).symm.trans (hL _)⟩ |
|
|
| lemma SmoothSobolev.joint_continuous_representative {s : ℝ} {u : P → 𝓢'(E,ℂ)} |
| (hu : SmoothSobolev s u) (hs : Module.finrank ℝ E < 2*s) : |
| ∃ g : P → BoundedContinuousFunction E ℂ, |
| ContDiff ℝ (⊤ : ℕ∞) g ∧ Continuous (fun q : P × E => g q.1 q.2) ∧ |
| ∀ p, u p=(((g p).memLp_top.toLp _ : Lp ℂ ∞ (volume : Measure E)) : 𝓢'(E,ℂ)) := by |
| obtain ⟨g,hg,he⟩ := hu.continuous_representative hs |
| exact ⟨g,hg,(hg.continuous.comp continuous_fst).eval continuous_snd,he⟩ |
| end ElasticityRegularity |
| namespace ElasticityRegularity |
| open MeasureTheory TemperedDistribution |
| open scoped SchwartzMap ENNReal LineDeriv Topology |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| def bcfToLinfty : BoundedContinuousFunction E ℂ →L[ℂ] Lp ℂ ∞ (volume : Measure E) := |
| LinearMap.mkContinuous |
| { toFun := fun g => g.memLp_top.toLp _ |
| map_add' := fun f g => by exact f.memLp_top.toLp_add g.memLp_top |
| map_smul' := fun c f => by exact f.memLp_top.toLp_const_smul c } 1 (fun g => by |
| change ‖(g.memLp_top.toLp _ : Lp ℂ ∞ (volume : Measure E))‖ ≤ 1*‖g‖ |
| rw [one_mul,Lp.norm_toLp,eLpNorm_exponent_top g.memLp_top.aestronglyMeasurable] |
| exact (ENNReal.toReal_mono (by simp) |
| (eLpNormEssSup_le_of_ae_bound (Filter.Eventually.of_forall g.norm_coe_le_norm))).trans_eq |
| (ENNReal.toReal_ofReal (norm_nonneg g))) |
| def bcfToDist : BoundedContinuousFunction E ℂ →L[ℂ] 𝓢'(E,ℂ) := |
| (Lp.toTemperedDistributionCLM ℂ (volume : Measure E) ∞).comp bcfToLinfty |
| lemma bcfToDist_apply (g : BoundedContinuousFunction E ℂ) : |
| bcfToDist g=(((g.memLp_top.toLp _ : Lp ℂ ∞ (volume : Measure E))) : 𝓢'(E,ℂ)) := rfl |
| lemma bcfToDist_injective : Function.Injective (bcfToDist (E := E)) := by |
| intro f g h |
| have hh : (f.memLp_top.toLp _ : Lp ℂ ∞ (volume : Measure E))=g.memLp_top.toLp _ := |
| LinearMap.ker_eq_bot.mp (Lp.ker_toTemperedDistributionCLM_eq_bot (F := ℂ)) h |
| have ha : (f : E → ℂ)=ᵐ[volume] (g : E → ℂ) := |
| f.memLp_top.coeFn_toLp.symm.trans (hh ▸ g.memLp_top.coeFn_toLp) |
| exact DFunLike.coe_injective ((f.continuous.ae_eq_iff_eq volume g.continuous).mp ha) |
| lemma bcf_smooth_of_all_orders (g : BoundedContinuousFunction E ℂ) |
| (hg : ∀ n : ℕ, MemSobolev n 2 (bcfToDist g)) : |
| ContDiff ℝ (⊤ : ℕ∞) (g : E → ℂ) := by |
| obtain ⟨h,hh,he⟩ := all_orders_smooth_representative hg |
| have : g=h := bcfToDist_injective he |
| rwa [this] |
|
|
| / |
| representatives. A compact smooth multiplier makes every term Schwartz. -/ |
| lemma bcf_derivative (g h : BoundedContinuousFunction E ℂ) |
| (hg : ContDiff ℝ (⊤ : ℕ∞) (g : E → ℂ)) |
| (hh : ContDiff ℝ (⊤ : ℕ∞) (h : E → ℂ)) (a x : E) |
| (he : ∂_{a} (bcfToDist g)=bcfToDist h) : |
| fderiv ℝ (g : E → ℂ) x a=h x := by |
| obtain ⟨q,_,hc,hq,_,h1⟩ := exists_contDiff_tsupport_subset (x := x) (n := (⊤ : ℕ∞)) |
| (s := Set.univ) Filter.univ_mem |
| let c : E → ℂ := fun y => (q y : ℂ) |
| have hcg : ContDiff ℝ (⊤ : ℕ∞) c := Complex.ofRealCLM.contDiff.comp hq |
| have hcc : HasCompactSupport c := hc.comp_left Complex.ofReal_zero |
| have hdg := smooth_derivative hcg a |
| have hdc := compact_derivative hcc a |
| let cg : 𝓢(E,ℂ) := (hcc.mul_right : HasCompactSupport (c*(g : E → ℂ))).toSchwartzMap (hcg.mul hg) |
| let ch : 𝓢(E,ℂ) := (hcc.mul_right : HasCompactSupport (c*(h : E → ℂ))).toSchwartzMap (hcg.mul hh) |
| let cdg : 𝓢(E,ℂ) := (hdc.mul_right : HasCompactSupport ((fun y => fderiv ℝ c y a)*(g : E → ℂ))).toSchwartzMap (hdg.mul hg) |
| have hd := distribution_leibniz (hcc.hasTemperateGrowth hcg) a |
| (hdc.hasTemperateGrowth hdg) (bcfToDist g) |
| rw [he,bcfToDist_apply,bcfToDist_apply,smooth_Linfty_product hcg hcc g hg, |
| smooth_Linfty_product hcg hcc h hh,smooth_Linfty_product hdg hdc g hg] at hd |
| have hdist : ((∂_{a} cg : 𝓢(E,ℂ)) : 𝓢'(E,ℂ))=((cdg+ch : 𝓢(E,ℂ)) : 𝓢'(E,ℂ)) := by |
| simpa only [← lineDerivOp_toTemperedDistributionCLM_eq,map_add] using hd |
| have hv := congrArg (fun f : 𝓢(E,ℂ) => f x) (schwartz_dist_injective hdist) |
| change fderiv ℝ (c*(g : E → ℂ)) x a=fderiv ℝ c x a*g x+c x*h x at hv |
| rw [fderiv_mul (hcg.differentiable (by simp) x) (hg.differentiable (by simp) x)] at hv |
| have hx : c x=1 := by simp only [c,h1,Complex.ofReal_one] |
| simp only [add_apply,smul_apply,smul_eq_mul,hx,one_mul] at hv |
| linear_combination hv |
| end ElasticityRegularity |
| namespace ElasticityRegularity |
|
|
| section |
| open MeasureTheory TemperedDistribution |
| open scoped SchwartzMap ENNReal LineDeriv |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| lemma bcf_family_spatial_smooth (g : P → BoundedContinuousFunction E ℂ) |
| (hu : ∀ n : ℕ, SmoothSobolev n (fun p => bcfToDist (g p))) (p : P) : |
| ContDiff ℝ (⊤ : ℕ∞) (g p : E → ℂ) := by |
| apply bcf_smooth_of_all_orders |
| intro n |
| obtain ⟨f,_,he⟩ := hu n |
| dsimp only at he |
| rw [← he p] |
| exact sobolevInjection_mem _ _ |
|
|
| lemma bcf_parameter_derivative (g : P → BoundedContinuousFunction E ℂ) |
| (hu : ∀ n : ℕ, SmoothSobolev n (fun p => bcfToDist (g p))) (a : P) : |
| ∀ n : ℕ, SmoothSobolev n (fun p => bcfToDist (fderiv ℝ g p a)) := by |
| intro n |
| let t : ℕ := n+Module.finrank ℝ E+1 |
| have ht : Module.finrank ℝ E < 2*(t : ℝ) := by dsimp [t]; push_cast; linarith [Nat.cast_nonneg (α := ℝ) n, Nat.cast_nonneg (α := ℝ) (Module.finrank ℝ E)] |
| obtain ⟨f,hf,he⟩ := hu t |
| obtain ⟨T,hT⟩ := exists_bounded_continuous_embedding ht |
| have hge : g=fun p => T (f p) := by |
| funext p |
| apply bcfToDist_injective |
| exact (he p).symm.trans (hT _) |
| have hd (p : P) : fderiv ℝ g p a=T (fderiv ℝ f p a) := by |
| have h := (T.restrictScalars ℝ).hasFDerivAt.comp p (hf.differentiable (by simp) p).hasFDerivAt |
| change HasFDerivAt (fun p => T (f p)) _ p at h |
| rw [← hge] at h |
| exact congrArg (fun L : P →L[ℝ] BoundedContinuousFunction E ℂ => L a) h.fderiv |
| have h : SmoothSobolev (t : ℝ) (fun p => bcfToDist (fderiv ℝ g p a)) := by |
| refine ⟨fun p => fderiv ℝ f p a,?_,fun p => ?_⟩ |
| · exact (hf.fderiv_right (by simp)).clm_apply contDiff_const |
| · dsimp only |
| rw [hd] |
| exact hT _ |
| exact h.mono (by dsimp [t]; norm_cast; omega) |
|
|
| / |
| representatives in every Sobolev order. -/ |
| lemma bcf_spatial_derivative (g : P → BoundedContinuousFunction E ℂ) |
| (hu : ∀ n : ℕ, SmoothSobolev n (fun p => bcfToDist (g p))) (a : E) : |
| ∃ h : P → BoundedContinuousFunction E ℂ, |
| ContDiff ℝ (⊤ : ℕ∞) h ∧ |
| (∀ n : ℕ, SmoothSobolev n (fun p => bcfToDist (h p))) ∧ |
| ∀ p x, fderiv ℝ (g p : E → ℂ) x a=h p x := by |
| have hd (n : ℕ) : SmoothSobolev n (fun p => ∂_{a} (bcfToDist (g p))) := by |
| have h := (hu (n+1)).derivative a |
| convert h using 1; push_cast; ring |
| let t : ℕ := Module.finrank ℝ E+1 |
| obtain ⟨h,hh,he⟩ := (hd t).continuous_representative (by dsimp [t]; push_cast; linarith [Nat.cast_nonneg (α := ℝ) (Module.finrank ℝ E)]) |
| change ∀ p, ∂_{a} (bcfToDist (g p))=bcfToDist (h p) at he |
| have hs (n : ℕ) : SmoothSobolev n (fun p => bcfToDist (h p)) := by |
| simpa only [he] using hd n |
| refine ⟨h,hh,hs,fun p x => ?_⟩ |
| exact bcf_derivative (g p) (h p) (bcf_family_spatial_smooth g hu p) |
| (bcf_family_spatial_smooth h hs p) a x (he p) |
| end |
| open MeasureTheory TemperedDistribution Filter Topology |
| open scoped SchwartzMap ENNReal LineDeriv |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
|
|
| lemma bcf_joint_hasFDerivAt (g : P → BoundedContinuousFunction E ℂ) |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| (hu : ∀ n : ℕ, SmoothSobolev n (fun p => bcfToDist (g p))) (q : P × E) : |
| HasFDerivAt (fun q : P × E => g q.1 q.2) |
| (((BoundedContinuousFunction.evalCLM ℝ q.2).comp (fderiv ℝ g q.1)).coprod |
| (fderiv ℝ (g q.1 : E → ℂ) q.2)) q := by |
| let A : P → E → P →L[ℝ] ℂ := fun p x => |
| (BoundedContinuousFunction.evalCLM ℝ x).comp (fderiv ℝ g p) |
| let B : P → E → E →L[ℝ] ℂ := fun p x => fderiv ℝ (g p : E → ℂ) x |
| have hA : Continuous (fun q : P × E => A q.1 q.2) := by |
| apply continuous_clm_apply.mpr |
| intro a |
| have ht : ContDiff ℝ (⊤ : ℕ∞) (fun p => fderiv ℝ g p a) := |
| (hg.fderiv_right (by simp)).clm_apply contDiff_const |
| exact (ht.continuous.comp continuous_fst).eval continuous_snd |
| have hB : Continuous (fun q : P × E => B q.1 q.2) := by |
| apply continuous_clm_apply.mpr |
| intro a |
| obtain ⟨h,hh,_,he⟩ := bcf_spatial_derivative g hu a |
| change Continuous (fun q : P × E => fderiv ℝ (g q.1 : E → ℂ) q.2 a) |
| simp only [he] |
| exact (hh.continuous.comp continuous_fst).eval continuous_snd |
| apply (hasStrictFDerivAt_uncurry_coprod (f := fun p x => g p x) |
| (f₁ := A) (f₂ := B) ?_ ?_ hA.continuousAt hB.continuousAt).hasFDerivAt |
| · apply Filter.Eventually.of_forall |
| intro v |
| exact (BoundedContinuousFunction.evalCLM ℝ v.2).hasFDerivAt.comp v.1 |
| (hg.differentiable (by simp) v.1).hasFDerivAt |
| · apply Filter.Eventually.of_forall |
| intro v |
| exact ((bcf_family_spatial_smooth g hu v.1).differentiable (by simp) v.2).hasFDerivAt |
|
|
| / |
| including mixed parameter and spatial derivatives. -/ |
| theorem bcf_joint_smooth (g : P → BoundedContinuousFunction E ℂ) |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| (hu : ∀ n : ℕ, SmoothSobolev n (fun p => bcfToDist (g p))) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun q : P × E => g q.1 q.2) := by |
| apply contDiff_infty.mpr |
| intro n |
| induction n generalizing g with |
| | zero => |
| simp only [Nat.cast_zero,contDiff_zero] |
| exact (hg.continuous.comp continuous_fst).eval continuous_snd |
| | succ n ih => |
| rw [Nat.cast_add,Nat.cast_one,contDiff_succ_iff_fderiv_apply] |
| refine ⟨fun q => (bcf_joint_hasFDerivAt g hg hu q).differentiableAt,by simp,fun a => ?_⟩ |
| have hp : ContDiff ℝ (⊤ : ℕ∞) (fun p => fderiv ℝ g p a.1) := |
| (hg.fderiv_right (by simp)).clm_apply contDiff_const |
| have hpu := bcf_parameter_derivative g hu a.1 |
| obtain ⟨h,hh,hs,he⟩ := bcf_spatial_derivative g hu a.2 |
| have hp' := ih (fun p => fderiv ℝ g p a.1) hp hpu |
| have hs' := ih h hh hs |
| have hf (q : P × E) : |
| fderiv ℝ (fun q : P × E => g q.1 q.2) q a= |
| (fderiv ℝ g q.1 a.1) q.2+h q.1 q.2 := by |
| rw [(bcf_joint_hasFDerivAt g hg hu q).fderiv] |
| change (fderiv ℝ g q.1 a.1) q.2+fderiv ℝ (g q.1 : E → ℂ) q.2 a.2=_ |
| rw [he] |
| simp only [hf] |
| exact hp'.add hs' |
|
|
| theorem SmoothSobolev.joint_smooth_representative {u : P → 𝓢'(E,ℂ)} |
| (hu : ∀ n : ℕ, SmoothSobolev n u) : |
| ∃ g : P → BoundedContinuousFunction E ℂ, |
| ContDiff ℝ (⊤ : ℕ∞) g ∧ ContDiff ℝ (⊤ : ℕ∞) (fun q : P × E => g q.1 q.2) ∧ |
| ∀ p, u p=bcfToDist (g p) := by |
| let t : ℕ := Module.finrank ℝ E+1 |
| obtain ⟨g,hg,he⟩ := (hu t).continuous_representative |
| (by dsimp [t]; push_cast; linarith [Nat.cast_nonneg (α := ℝ) (Module.finrank ℝ E)]) |
| change ∀ p, u p=bcfToDist (g p) at he |
| have hs (n : ℕ) : SmoothSobolev n (fun p => bcfToDist (g p)) := by |
| rw [← show u=(fun p => bcfToDist (g p)) from funext he] |
| exact hu n |
| exact ⟨g,hg,bcf_joint_smooth g hg hs,he⟩ |
| end ElasticityRegularity |
| namespace ElasticityRegularity |
| open MeasureTheory TemperedDistribution |
| open scoped SchwartzMap ENNReal |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
|
|
| / |
| is an actual Schwartz function in space for every parameter. -/ |
| theorem SmoothLocalSobolev.joint_schwartz_representative {Ω Ω' : Set E} |
| (u : P → 𝓢'(E,ℂ)) (hu : ∀ N : ℕ, SmoothLocalSobolev Ω N u) |
| {g : E → ℂ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) (hc : HasCompactSupport g) |
| (hs : tsupport g ⊆ Ω) (h1 : Set.EqOn g 1 Ω') : |
| ∃ f : P → 𝓢(E,ℂ), ContDiff ℝ (⊤ : ℕ∞) (fun q : P × E => f q.1 q.2) ∧ |
| ∀ p, LocalEqual Ω' (u p) (f p : 𝓢'(E,ℂ)) := by |
| obtain ⟨v,_,hv,he⟩ := SmoothSobolev.joint_smooth_representative |
| (fun N => hu N g hg hc hs) |
| have hvs (p : P) : ContDiff ℝ (⊤ : ℕ∞) (v p : E → ℂ) := |
| hv.comp (contDiff_const.prodMk contDiff_id) |
| let f : P → 𝓢(E,ℂ) := fun p => |
| (hc.mul_right : HasCompactSupport (g*(v p : E → ℂ))).toSchwartzMap (hg.mul (hvs p)) |
| refine ⟨f,?_,fun p => ?_⟩ |
| · change ContDiff ℝ (⊤ : ℕ∞) (fun q : P × E => g q.2*v q.1 q.2) |
| exact (hg.comp contDiff_snd).mul hv |
| · have he' := smooth_Linfty_product hg hc (v p) (hvs p) |
| have hl := (LocalEqual.cutoff_one (u p) (hc.hasTemperateGrowth hg) h1).symm |
| have hl' := (LocalEqual.cutoff_one (smulLeftCLM ℂ g (u p)) (hc.hasTemperateGrowth hg) h1).symm |
| have h := hl.trans hl' |
| rw [he p] at h |
| exact h.trans (by intro φ _ _; exact congrArg (fun T : 𝓢'(E,ℂ) => T φ) he') |
| end ElasticityRegularity |
| namespace ElasticityPlanar |
| open MeasureTheory TemperedDistribution Complex |
| open scoped SchwartzMap ENNReal LineDeriv BigOperators |
| variable {n : Type*} [Fintype n] |
| open ElasticityRegularity |
|
|
| def schwartzDbar (v : 𝓢(ℂ,ℂ)) : 𝓢(ℂ,ℂ) := ∂_{(1 : ℂ)} v+I • ∂_{I} v |
| lemma dbar_schwartz (v : 𝓢(ℂ,ℂ)) : |
| ElasticityPlanarDistribution.dbar (v : 𝓢'(ℂ,ℂ))=(schwartzDbar v : 𝓢'(ℂ,ℂ)) := by |
| simp only [ElasticityPlanarDistribution.dbar,schwartzDbar, |
| TemperedDistribution.lineDerivOp_toTemperedDistributionCLM_eq] |
| rw [map_add,map_smul] |
| lemma LocalEqual.dbar {Ω : Set ℂ} {u v : 𝓢'(ℂ,ℂ)} (h : LocalEqual Ω u v) : |
| LocalEqual Ω (ElasticityPlanarDistribution.dbar u) (ElasticityPlanarDistribution.dbar v) := |
| (h.derivative 1).add ((h.derivative I).smul I) |
|
|
| lemma LocalEqual.coeff {Ω : Set ℂ} {u v : 𝓢'(ℂ,ℂ)} (h : LocalEqual Ω u v) |
| {a : ℂ → ℂ} (ha : a.HasTemperateGrowth) : |
| LocalEqual Ω (smulLeftCLM ℂ a u) (smulLeftCLM ℂ a v) := by |
| intro φ hc hs |
| change u (SchwartzMap.smulLeftCLM ℂ a φ)=v (SchwartzMap.smulLeftCLM ℂ a φ) |
| apply h |
| · simpa only [SchwartzMap.smulLeftCLM_apply ha,Pi.smul_def,smul_eq_mul,Pi.mul_def] using |
| (hc.mul_left : HasCompactSupport (a*(φ : ℂ → ℂ))) |
| · simpa only [SchwartzMap.smulLeftCLM_apply ha,Pi.smul_def,smul_eq_mul,Pi.mul_def] using |
| (tsupport_mul_subset_right (f := a) (g := (φ : ℂ → ℂ))).trans hs |
|
|
| / |
| smaller open set. The unknown is produced by the supported estimate and Hilbert |
| space duality, and the smooth solution is the same L2 solution almost everywhere. |
| No pre-existing local or global frame is used. -/ |
| theorem exists_planar_classical_solution {S Ω Ω' : Set ℂ} (hS : IsCompact S) |
| (hΩS : Ω ⊆ S) (hΩ' : IsOpen Ω') (hsub : Ω' ⊆ Ω) |
| (a : n → n → ℂ → ℂ) (ha : ∀ i j, (a i j).HasTemperateGrowth) |
| (f : n → 𝓢(ℂ,ℂ)) {g : ℂ → ℂ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| (hc : HasCompactSupport g) (hs : tsupport g ⊆ Ω) (h1 : Set.EqOn g 1 Ω') : |
| ∃ w : Hilbert n, ∃ v : n → 𝓢(ℂ,ℂ), |
| (∀ i, ∀ᵐ z ∂(volume : Measure ℂ), z ∈ Ω' → w i z=v i z) ∧ |
| ∀ i, Set.EqOn (fun z => schwartzDbar (v i) z+∑ j, a i j z*v j z) (f i) Ω' := by |
| obtain ⟨C,hC,T,hT,heq⟩ := exists_planar_weak_inverse hS a (fun i j => (ha i j).1) |
| let f' : Hilbert n := WithLp.toLp 2 (fun i => (f i).toLp 2 volume) |
| let w : Hilbert n := T f' |
| have he : ∀ i, LocalEqual Ω (ElasticityPlanarDistribution.dbar (w i : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (a i j) (w j : 𝓢'(ℂ,ℂ))) (f i : 𝓢'(ℂ,ℂ)) := by |
| intro i |
| have hh := weak_to_local_equation Ω S hΩS a ha w f' (heq f') i |
| simpa only [f',WithLp.ofLp_toLp,Lp.toTemperedDistribution_toLp_eq] using hh |
| have he' : ElasticityPlanarDistribution.Equation Ω (fun i j z => -a i j z) |
| (fun j => (w j : 𝓢'(ℂ,ℂ))) (fun j => (f j : 𝓢'(ℂ,ℂ))) := by |
| intro i φ hφ hφs |
| have hh := he i φ hφ hφs |
| simp only [add_apply,sum_apply,smulLeftCLM_apply_apply] at hh ⊢ |
| have hn (j : n) : SchwartzMap.smulLeftCLM ℂ (fun z => -a i j z) φ = |
| -SchwartzMap.smulLeftCLM ℂ (a i j) φ := by |
| ext z |
| change (SchwartzMap.smulLeftCLM ℂ (-(a i j)) φ) z = _ |
| simp only [SchwartzMap.smulLeftCLM_apply_apply ((ha i j).neg), |
| SchwartzMap.smulLeftCLM_apply_apply (ha i j),neg_apply,Pi.neg_apply,smul_eq_mul,neg_mul] |
| simp only [hn,map_neg,Finset.sum_neg_distrib] |
| linear_combination hh |
| have hall := ElasticityPlanarDistribution.local_all_orders (fun i j z => -a i j z) |
| (fun i j => (ha i j).neg) (fun j => (w j : 𝓢'(ℂ,ℂ))) (fun j => (f j : 𝓢'(ℂ,ℂ))) he' |
| (fun j => MemSobolev.local_zero (memSobolev_zero_iff.mpr ⟨w j,rfl⟩) Ω) |
| (fun N j g hg hc _ => sobolev_nat_product Complex.orthonormalBasisOneI N hg hc (f j).memSobolev) |
| have hv : ∀ i : n, ∃ v : 𝓢(ℂ,ℂ), LocalEqual Ω' (w i : 𝓢'(ℂ,ℂ)) (v : 𝓢'(ℂ,ℂ)) ∧ |
| ∀ᵐ z ∂(volume : Measure ℂ), z ∈ Ω' → w i z=v z := by |
| intro i |
| exact local_schwartz_l2_representative hΩ' (w i) (fun N => hall N i) hg hc hs h1 |
| choose v hv hev using hv |
| refine ⟨w,v,hev,fun i => ?_⟩ |
| let q : 𝓢(ℂ,ℂ) := schwartzDbar (v i)+∑ j, SchwartzMap.smulLeftCLM ℂ (a i j) (v j) |
| have hq : (q : 𝓢'(ℂ,ℂ))=ElasticityPlanarDistribution.dbar (v i : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (a i j) (v j : 𝓢'(ℂ,ℂ)) := by |
| simp only [q,map_add,map_sum,← dbar_schwartz] |
| congr 1 |
| exact Finset.sum_congr rfl (fun j _ => (distribution_schwartz_product (ha i j) (v j)).symm) |
| have hqq : LocalEqual Ω' (q : 𝓢'(ℂ,ℂ)) (f i : 𝓢'(ℂ,ℂ)) := by |
| rw [hq] |
| have hh := (LocalEqual.dbar (hv i)).add (LocalEqual.sum Finset.univ (fun j _ => LocalEqual.coeff (hv j) (ha i j))) |
| exact fun φ hφ hφs => (hh φ hφ hφs).symm.trans (he i φ hφ (hφs.trans hsub)) |
| have hpoint := hqq.schwartz_eqOn hΩ' |
| intro z hz |
| have hp := hpoint hz |
| simpa only [q,add_apply,sum_apply,SchwartzMap.smulLeftCLM_apply_apply (ha i _),smul_eq_mul] using hp |
| end ElasticityPlanar |
| section |
| open MeasureTheory TemperedDistribution Set |
| open scoped SchwartzMap ENNReal BigOperators |
| namespace ElasticityRegularity |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] |
| lemma SmoothSobolev.local_nat {N : ℕ} {u : P → 𝓢'(E,ℂ)} |
| (hu : SmoothSobolev N u) (Ω : Set E) : SmoothLocalSobolev Ω N u := by |
| intro g hg hc _ |
| obtain ⟨u,hu,he⟩ := hu |
| obtain ⟨L,hL⟩ := exists_bounded_nat_multiplier N hg hc |
| exact ⟨fun p => L (u p),(L.restrictScalars ℝ).contDiff.comp hu,fun p => by rw [hL,he]⟩ |
| lemma smoothSobolev_schwartz_const (N : ℕ) (f : 𝓢(E,ℂ)) : |
| SmoothSobolev N (fun _ : P => (f : 𝓢'(E,ℂ))) := by |
| obtain ⟨v,hv⟩ := (memSobolev_iff_range (N:ℝ) (f : 𝓢'(E,ℂ))).mp f.memSobolev |
| exact ⟨fun _ => v,contDiff_const,fun _ => hv⟩ |
| end ElasticityRegularity |
|
|
| namespace ElasticityPlanar |
| open ElasticityRegularity |
| variable {n : Type*} [Fintype n] |
| / |
| classical representatives with the exact prescribed source. This is the linear |
| PDE input to the frame homotopy, not an assumed family of invertible frames. -/ |
| theorem exists_classical_homotopy {S Ω Ω' : Set ℂ} (hS : IsCompact S) |
| (hΩS : Ω ⊆ S) (hΩ' : IsOpen Ω') (hsub : Ω' ⊆ Ω) |
| (a : n → n → ℂ → ℂ) (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hac : ∀ i j, HasCompactSupport (a i j)) (f : n → 𝓢(ℂ,ℂ)) |
| {g : ℂ → ℂ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| (hc : HasCompactSupport g) (hs : tsupport g ⊆ Ω) (h1 : Set.EqOn g 1 Ω') : |
| ∃ v : ℝ → n → 𝓢(ℂ,ℂ), |
| (∀ i, ContDiff ℝ (⊤ : ℕ∞) (fun q : ℝ × ℂ => v q.1 i q.2)) ∧ |
| ∀ s i, Set.EqOn (fun z => schwartzDbar (v s i) z+∑ j, (s:ℂ)*a i j z*v s j z) (f i) Ω' := by |
| obtain ⟨T,hT,heq⟩ := global_homotopy_inverse hS hΩS a ha hac |
| let f' : Hilbert n := WithLp.toLp 2 (fun i => (f i).toLp 2 volume) |
| let w : ℝ → Hilbert n := fun s => T s f' |
| let u : ℝ → n → 𝓢'(ℂ,ℂ) := fun s i => (w s i : 𝓢'(ℂ,ℂ)) |
| have hw : ContDiff ℝ (⊤ : ℕ∞) w := |
| ((ContinuousLinearMap.apply ℂ (Hilbert n) f').restrictScalars ℝ).contDiff.comp hT |
| have hat (i j : n) : (a i j).HasTemperateGrowth := (hac i j).hasTemperateGrowth (ha i j) |
| have hscaled (s : ℝ) (i j : n) : (fun z => (s:ℂ)*a i j z).HasTemperateGrowth := |
| Function.HasTemperateGrowth.mul (Function.HasTemperateGrowth.const (s:ℂ)) (hat i j) |
| have he (s : ℝ) (i : n) : LocalEqual Ω |
| (ElasticityPlanarDistribution.dbar (u s i)+ |
| ∑ j, smulLeftCLM ℂ (fun z => (s:ℂ)*a i j z) (u s j)) (f i : 𝓢'(ℂ,ℂ)) := by |
| simpa only [f',WithLp.ofLp_toLp,Lp.toTemperedDistribution_toLp_eq] using heq s f' i |
| have hm (s : ℝ) (i j : n) : smulLeftCLM ℂ (fun z => (s:ℂ)*a i j z) (u s j)= |
| (s:ℂ) • smulLeftCLM ℂ (a i j) (u s j) := by |
| change smulLeftCLM ℂ ((s:ℂ) • (a i j)) (u s j) = _ |
| rw [smulLeftCLM_smul (hat i j),smul_apply] |
| have he' (s : ℝ) (i : n) : LocalEqual Ω (ElasticityPlanarDistribution.dbar (u s i)) |
| ((f i : 𝓢'(ℂ,ℂ))+(-(s:ℂ)) • ∑ j, smulLeftCLM ℂ (a i j) (u s j)) := by |
| intro φ hφ hφs |
| have h := he s i φ hφ hφs |
| simp only [hm,← Finset.smul_sum,add_apply,smul_apply,smul_eq_mul,neg_mul] at h ⊢ |
| linear_combination h |
| have hu (i : n) : SmoothLocalSobolev Ω 0 (fun s => u s i) := by |
| have hzero : SmoothSobolev 0 (fun s => u s i) := by |
| let L : Hilbert n →L[ℂ] PL2 := (ContinuousLinearMap.proj i).comp |
| (PiLp.continuousLinearEquiv 2 ℂ (fun _ : n => PL2)).toContinuousLinearMap |
| refine ⟨fun s => L (w s),(L.restrictScalars ℝ).contDiff.comp hw,fun s => ?_⟩ |
| simp only [sobolevInjection,neg_zero,besselPotential_zero,ContinuousLinearMap.id_comp, |
| Lp.toTemperedDistributionCLM_apply] |
| rfl |
| simpa only [Nat.cast_zero] using |
| (SmoothSobolev.local_nat (N := 0) (u := fun s => u s i) |
| (by simpa only [Nat.cast_zero] using hzero) Ω) |
| have hall := ElasticityPlanarDistribution.smooth_local_all_orders a hat |
| (fun s : ℝ => -(s:ℂ)) (Complex.ofRealCLM.contDiff.neg) |
| u (fun _ i => (f i : 𝓢'(ℂ,ℂ))) he' hu |
| (fun N i => (smoothSobolev_schwartz_const (P := ℝ) N (f i)).local_nat Ω) |
| have hv (i : n) : ∃ v : ℝ → 𝓢(ℂ,ℂ), |
| ContDiff ℝ (⊤ : ℕ∞) (fun q : ℝ × ℂ => v q.1 q.2) ∧ |
| ∀ s, LocalEqual Ω' (u s i) (v s : 𝓢'(ℂ,ℂ)) := |
| SmoothLocalSobolev.joint_schwartz_representative (fun s => u s i) |
| (fun N => hall N i) hg hc hs h1 |
| choose v hv hv' using hv |
| refine ⟨fun s i => v i s,hv,fun s i => ?_⟩ |
| let q : 𝓢(ℂ,ℂ) := schwartzDbar (v i s)+ |
| ∑ j, SchwartzMap.smulLeftCLM ℂ (fun z => (s:ℂ)*a i j z) (v j s) |
| have hq : (q : 𝓢'(ℂ,ℂ))=ElasticityPlanarDistribution.dbar (v i s : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (fun z => (s:ℂ)*a i j z) (v j s : 𝓢'(ℂ,ℂ)) := by |
| simp only [q,map_add,map_sum,← dbar_schwartz] |
| congr 1 |
| exact Finset.sum_congr rfl (fun j _ => (distribution_schwartz_product (hscaled s i j) (v j s)).symm) |
| have hqq : LocalEqual Ω' (q : 𝓢'(ℂ,ℂ)) (f i : 𝓢'(ℂ,ℂ)) := by |
| rw [hq] |
| have hh := (LocalEqual.dbar (hv' i s)).add (LocalEqual.sum Finset.univ |
| (fun j _ => LocalEqual.coeff (hv' j s) (hscaled s i j))) |
| exact fun φ hφ hφs => (hh φ hφ hφs).symm.trans (he s i φ hφ (hφs.trans hsub)) |
| intro z hz |
| have hp := hqq.schwartz_eqOn hΩ' hz |
| simpa only [q,add_apply,sum_apply,SchwartzMap.smulLeftCLM_apply_apply (hscaled s i _),smul_eq_mul] using hp |
| end ElasticityPlanar |
|
|
| end |
| namespace ElasticityRegularity |
| open MeasureTheory TemperedDistribution Set |
| open scoped ENNReal SchwartzMap BigOperators |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
| omit [MeasurableSpace E] [BorelSpace E] in |
| lemma exists_schwartz_one_on_compact {K : Set E} (hK : IsCompact K) : |
| ∃ g : 𝓢(E,ℂ), Set.EqOn g 1 K := by |
| obtain ⟨R,hR,hKR⟩ := hK.isBounded.exists_pos_norm_le |
| let b : ContDiffBump (0 : E) := ⟨R,R+1,hR,by simp⟩ |
| have hc : HasCompactSupport (fun x : E => (b x : ℂ)) := |
| b.hasCompactSupport.comp_left (g := Complex.ofReal) (by simp) |
| have hg : ContDiff ℝ (⊤ : ℕ∞) (fun x : E => (b x : ℂ)) := |
| Complex.ofRealCLM.contDiff.comp b.contDiff |
| refine ⟨hc.toSchwartzMap hg,fun x hx => ?_⟩ |
| change (b x : ℂ)=1 |
| rw [b.one_of_mem_closedBall (by simpa only [Metric.mem_closedBall,dist_zero_right] using hKR x hx)] |
| rfl |
| / |
| families vary smoothly in every nonnegative Hilbert Sobolev norm. -/ |
| theorem compact_smooth_sobolev {K : Set E} (hK : IsCompact K) |
| (a : P × E → ℂ) (ha : ContDiff ℝ (⊤ : ℕ∞) a) |
| (hs : ∀ p x, x∉K → a (p,x)=0) : |
| ∃ f : P → 𝓢(E,ℂ), (∀ p x, f p x=a (p,x)) ∧ |
| ∀ N : ℕ, SmoothSobolev N (fun p => (f p : 𝓢'(E,ℂ))) := by |
| obtain ⟨g,hg⟩ := exists_schwartz_one_on_compact hK |
| have hat (p : P) : (fun x => a (p,x)).HasTemperateGrowth := |
| (compact_slice hK a hs p).hasTemperateGrowth (ha.comp (contDiff_const.prodMk contDiff_id)) |
| let f : P → 𝓢(E,ℂ) := fun p => SchwartzMap.smulLeftCLM ℂ (fun x => a (p,x)) g |
| refine ⟨f,fun p x => ?_,fun N => ?_⟩ |
| · change SchwartzMap.smulLeftCLM ℂ (fun x => a (p,x)) g x=_ |
| rw [SchwartzMap.smulLeftCLM_apply_apply (hat p),smul_eq_mul] |
| by_cases hx : x∈K |
| · rw [hg hx,Pi.one_apply,mul_one] |
| · rw [hs p x hx,zero_mul] |
| · have H := (smoothSobolev_schwartz_const (P := P) N g).variable_nat hK N a ha hs |
| convert H using 1 |
| funext p |
| exact (distribution_schwartz_product (hat p) g).symm |
| end ElasticityRegularity |
| section |
| open MeasureTheory TemperedDistribution Set Complex |
| open scoped SchwartzMap LineDeriv Laplacian BigOperators |
| namespace ElasticityRegularity |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
| lemma SmoothLocalSobolev.variable_nat {Ω S : Set E} (hS : IsCompact S) |
| (N : ℕ) (a : P × E → ℂ) (ha : ContDiff ℝ (⊤ : ℕ∞) a) |
| (hs : ∀ p x, x∉S → a (p,x)=0) {u : P → 𝓢'(E,ℂ)} |
| (hu : SmoothLocalSobolev Ω N u) : |
| SmoothLocalSobolev Ω N (fun p => smulLeftCLM ℂ (fun x => a (p,x)) (u p)) := by |
| intro g hg hc hgs |
| have H := (hu g hg hc hgs).variable_nat hS N a ha hs |
| convert H using 1 |
| funext p |
| have hat : (fun x => a (p,x)).HasTemperateGrowth := |
| (compact_slice hS a hs p).hasTemperateGrowth (ha.comp (contDiff_const.prodMk contDiff_id)) |
| rw [smulLeftCLM_smulLeftCLM_apply (hc.hasTemperateGrowth hg) hat, |
| smulLeftCLM_smulLeftCLM_apply hat (hc.hasTemperateGrowth hg),mul_comm g] |
| end ElasticityRegularity |
| namespace ElasticityPlanarDistribution |
| open ElasticityRegularity |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
| variable {n : Type*} [Fintype n] |
| / |
| parameter regularity at every spatial order. -/ |
| theorem smooth_variable_all_orders {Ω S : Set ℂ} (hS : IsCompact S) |
| (a : n → n → P × ℂ → ℂ) (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hs : ∀ i j p z, z∉S → a i j (p,z)=0) |
| (u f : P → n → Dist) |
| (heq : ∀ p i, LocalEqual Ω (dbar (u p i)) |
| (f p i+∑ j, smulLeftCLM ℂ (fun z => a i j (p,z)) (u p j))) |
| (hu : ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω 0 (fun p => u p i)) |
| (hf : ∀ N : ℕ, ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω N (fun p => f p i)) : |
| ∀ N : ℕ, ∀ i, ElasticityRegularity.SmoothLocalSobolev Ω N (fun p => u p i) := by |
| intro N |
| induction N with |
| | zero => simpa only [Nat.cast_zero] using hu |
| | succ N ih => |
| rw [Nat.cast_add,Nat.cast_one] |
| intro i |
| apply (ih i).laplacian_gain |
| have H := SmoothLocalSobolev.dhol ((hf N i).add |
| (ElasticityRegularity.SmoothLocalSobolev.sum Finset.univ |
| (fun j p => smulLeftCLM ℂ (fun z => a i j (p,z)) (u p j)) |
| (fun j _ => (ih j).variable_nat hS N (a i j) (ha i j) (hs i j)))) |
| apply H.congr |
| intro p |
| simpa only [dhol_dbar] using LocalEqual.dhol (heq p i) |
| end ElasticityPlanarDistribution |
|
|
| end |
| namespace ElasticityPlanar |
| open MeasureTheory TemperedDistribution Set |
| open scoped SchwartzMap ENNReal BigOperators |
| open ElasticityRegularity |
| variable {n : Type*} [Fintype n] |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] |
| / |
| supported planar coefficient and source families. -/ |
| theorem exists_classical_variable {S Ω Ω' K : Set ℂ} (hS : IsCompact S) |
| (hΩS : Ω ⊆ S) (hΩ' : IsOpen Ω') (hsub : Ω' ⊆ Ω) (hK : IsCompact K) |
| (a : n → n → P × ℂ → ℂ) (ha : ∀ i j, ContDiff ℝ (⊤ : ℕ∞) (a i j)) |
| (hac : ∀ i j p z, z∉K → a i j (p,z)=0) |
| (f : n → P × ℂ → ℂ) (hf : ∀ i, ContDiff ℝ (⊤ : ℕ∞) (f i)) |
| (hfc : ∀ i p z, z∉K → f i (p,z)=0) |
| {g : ℂ → ℂ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| (hc : HasCompactSupport g) (hs : tsupport g ⊆ Ω) (h1 : Set.EqOn g 1 Ω') : |
| ∃ v : P → n → 𝓢(ℂ,ℂ), |
| (∀ i, ContDiff ℝ (⊤ : ℕ∞) (fun q : P × ℂ => v q.1 i q.2)) ∧ |
| ∀ p i, Set.EqOn (fun z => schwartzDbar (v p i) z+∑ j, a i j (p,z)*v p j z) |
| (fun z => f i (p,z)) Ω' := by |
| choose F hFe hF using fun i => compact_smooth_sobolev hK (f i) (hf i) (hfc i) |
| have hF₀ (i : n) : ∃ w : P → PL2, ContDiff ℝ (⊤ : ℕ∞) w ∧ |
| ∀ p, (w p : 𝓢'(ℂ,ℂ))=(F i p : 𝓢'(ℂ,ℂ)) := by |
| obtain ⟨w,hw,he⟩ := hF i 0 |
| simp only [Nat.cast_zero,sobolevInjection,neg_zero,besselPotential_zero, |
| ContinuousLinearMap.id_comp,Lp.toTemperedDistributionCLM_apply] at he |
| exact ⟨w,hw,he⟩ |
| choose W hW hWe using hF₀ |
| let rhs : P → Hilbert n := fun p => WithLp.toLp 2 (fun i => W i p) |
| have hrhs : ContDiff ℝ (⊤ : ℕ∞) rhs := |
| ((PiLp.continuousLinearEquiv 2 ℂ (fun _ : n => PL2)).symm.toContinuousLinearMap.restrictScalars ℝ).contDiff.comp |
| (contDiff_pi.mpr hW) |
| obtain ⟨T,hT,heq⟩ := global_variable_inverse hS hΩS hK a ha hac |
| let w : P → Hilbert n := fun p => T p (rhs p) |
| let u : P → n → 𝓢'(ℂ,ℂ) := fun p i => (w p i : 𝓢'(ℂ,ℂ)) |
| have hw : ContDiff ℝ (⊤ : ℕ∞) w := complex_clm_apply_smooth hT hrhs |
| have hat (p : P) (i j : n) : (fun z => a i j (p,z)).HasTemperateGrowth := |
| (compact_slice hK (a i j) (hac i j) p).hasTemperateGrowth |
| ((ha i j).comp (contDiff_const.prodMk contDiff_id)) |
| have he (p : P) (i : n) : LocalEqual Ω |
| (ElasticityPlanarDistribution.dbar (u p i)+ |
| ∑ j, smulLeftCLM ℂ (fun z => a i j (p,z)) (u p j)) (F i p : 𝓢'(ℂ,ℂ)) := by |
| simpa only [planarOperator_apply,rhs,WithLp.ofLp_toLp,hWe] using heq p (rhs p) i |
| have he' (p : P) (i : n) : LocalEqual Ω (ElasticityPlanarDistribution.dbar (u p i)) |
| ((F i p : 𝓢'(ℂ,ℂ))+∑ j, smulLeftCLM ℂ (fun z => -(a i j (p,z))) (u p j)) := by |
| intro φ hφ hφs |
| have h := he p i φ hφ hφs |
| have hn (j : n) : smulLeftCLM ℂ (fun z => -(a i j (p,z))) (u p j)= |
| -smulLeftCLM ℂ (fun z => a i j (p,z)) (u p j) := by |
| change smulLeftCLM ℂ (-(fun z => a i j (p,z))) (u p j)=_ |
| rw [smulLeftCLM_neg (hat p i j),neg_apply] |
| simp only [hn,Finset.sum_neg_distrib,add_apply,neg_apply] at h ⊢ |
| linear_combination h |
| have hu (i : n) : SmoothLocalSobolev Ω 0 (fun p => u p i) := by |
| have hz : SmoothSobolev 0 (fun p => u p i) := by |
| let L : Hilbert n →L[ℂ] PL2 := (ContinuousLinearMap.proj i).comp |
| (PiLp.continuousLinearEquiv 2 ℂ (fun _ : n => PL2)).toContinuousLinearMap |
| refine ⟨fun p => L (w p),(L.restrictScalars ℝ).contDiff.comp hw,fun p => ?_⟩ |
| simp only [sobolevInjection,neg_zero,besselPotential_zero,ContinuousLinearMap.id_comp, |
| Lp.toTemperedDistributionCLM_apply] |
| rfl |
| simpa only [Nat.cast_zero] using (SmoothSobolev.local_nat (N := 0) (by simpa only [Nat.cast_zero] using hz) Ω) |
| have hall := ElasticityPlanarDistribution.smooth_variable_all_orders hK |
| (fun i j q => -(a i j q)) (fun i j => (ha i j).neg) |
| (fun i j p z hz => by rw [hac i j p z hz,neg_zero]) |
| u (fun p i => (F i p : 𝓢'(ℂ,ℂ))) he' hu |
| (fun N i => (hF i N).local_nat Ω) |
| have hv (i : n) : ∃ v : P → 𝓢(ℂ,ℂ), |
| ContDiff ℝ (⊤ : ℕ∞) (fun q : P × ℂ => v q.1 q.2) ∧ |
| ∀ p, LocalEqual Ω' (u p i) (v p : 𝓢'(ℂ,ℂ)) := |
| SmoothLocalSobolev.joint_schwartz_representative (fun p => u p i) |
| (fun N => hall N i) hg hc hs h1 |
| choose v hv hv' using hv |
| refine ⟨fun p i => v i p,hv,fun p i => ?_⟩ |
| let q : 𝓢(ℂ,ℂ) := schwartzDbar (v i p)+ |
| ∑ j, SchwartzMap.smulLeftCLM ℂ (fun z => a i j (p,z)) (v j p) |
| have hq : (q : 𝓢'(ℂ,ℂ))=ElasticityPlanarDistribution.dbar (v i p : 𝓢'(ℂ,ℂ))+ |
| ∑ j, smulLeftCLM ℂ (fun z => a i j (p,z)) (v j p : 𝓢'(ℂ,ℂ)) := by |
| simp only [q,map_add,map_sum,← dbar_schwartz] |
| congr 1 |
| exact Finset.sum_congr rfl (fun j _ => (distribution_schwartz_product (hat p i j) (v j p)).symm) |
| have hqq : LocalEqual Ω' (q : 𝓢'(ℂ,ℂ)) (F i p : 𝓢'(ℂ,ℂ)) := by |
| rw [hq] |
| have hh := (LocalEqual.dbar (hv' i p)).add (LocalEqual.sum Finset.univ |
| (fun j _ => LocalEqual.coeff (hv' j p) (hat p i j))) |
| exact fun φ hφ hφs => (hh φ hφ hφs).symm.trans (he p i φ hφ (hφs.trans hsub)) |
| intro z hz |
| have hp := hqq.schwartz_eqOn hΩ' hz |
| simpa only [q,add_apply,sum_apply,SchwartzMap.smulLeftCLM_apply_apply (hat p i _),smul_eq_mul,hFe] using hp |
| end ElasticityPlanar |
|
|
| end |
|
|
| end OAI |
|
|
