| import Mathlib |
| import OAI.Analysis.Conductivity.Sobolev.SobolevSmoothTests |
| import OAI.Analysis.Conductivity.Variational.L2TranslationAverage |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace ScalarConductivity |
|
|
| section |
| open Set MeasureTheory Filter Topology |
| open scoped Convolution |
|
|
| abbrev SpatialBump := ContDiffBump (0:R3) |
|
|
| def bumpProbability (φ : SpatialBump) : Measure R3 := |
| volume.withDensity (fun x => ENNReal.ofReal (φ.normed volume x)) |
|
|
| instance bumpProbability_isProbability (φ : SpatialBump) : IsProbabilityMeasure (bumpProbability φ) where |
| measure_univ := by |
| rw [bumpProbability,withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ, |
| ←ofReal_integral_eq_lintegral_ofReal φ.integrable_normed (ae_of_all _ φ.nonneg_normed),φ.integral_normed] |
| simp |
|
|
| lemma bumpProbability_integral (φ : SpatialBump) (f : R3 → ℝ) : |
| (∫ y, f y ∂bumpProbability φ)=∫ y, φ.normed volume y*f y := by |
| rw [bumpProbability,integral_withDensity_eq_integral_toReal_smul |
| φ.continuous_normed.measurable.ennreal_ofReal (ae_of_all _ (fun _ => ENNReal.ofReal_lt_top))] |
| simp only [ENNReal.toReal_ofReal (φ.nonneg_normed _),smul_eq_mul] |
|
|
| lemma bumpProbability_ball (φ : SpatialBump) : |
| ∀ᵐ y ∂bumpProbability φ, ‖y‖<φ.rOut := by |
| rw [bumpProbability,ae_withDensity_iff φ.continuous_normed.measurable.ennreal_ofReal] |
| filter_upwards with y hy |
| have hne : φ.normed volume y≠0 := fun h => hy (by rw [h]; simp) |
| have hs : y∈Function.support (φ.normed volume) := hne |
| rw [φ.support_normed_eq] at hs |
| simpa using hs |
|
|
| def mollifyReal (φ : SpatialBump) (f : R3 → ℝ) : R3 → ℝ := |
| (φ.normed volume) ⋆[ContinuousLinearMap.lsmul ℝ ℝ,volume] f |
|
|
| lemma mollifyReal_smooth (φ : SpatialBump) {f : R3 → ℝ} (hf : LocallyIntegrable f) : |
| ContDiff ℝ (↑(⊤ : ℕ∞)) (mollifyReal φ f) := |
| φ.hasCompactSupport_normed.contDiff_convolution_left (ContinuousLinearMap.lsmul ℝ ℝ) |
| φ.contDiff_normed hf |
|
|
| lemma mollifyReal_eq_average (φ : SpatialBump) (f : R3 → ℝ) (x : R3) : |
| mollifyReal φ f x=∫ y, f (x-y) ∂bumpProbability φ := by |
| rw [bumpProbability_integral] |
| rfl |
|
|
| lemma mollifyReal_sub (φ : SpatialBump) (f : WholeL2) (x : R3) : |
| mollifyReal φ f x-f x=∫ y, (f (x-y)-f x) ∂bumpProbability φ := by |
| rw [bumpProbability_integral] |
| simp_rw [mul_sub] |
| have hi : Integrable (fun y => φ.normed volume y*f (x-y)) := |
| φ.hasCompactSupport_normed.convolutionExists_left (ContinuousLinearMap.lsmul ℝ ℝ) |
| φ.continuous_normed ((Lp.memLp f).locallyIntegrable (by norm_num)) x |
| rw [integral_sub hi (φ.integrable_normed.mul_const _),integral_mul_const,φ.integral_normed,one_mul] |
| rfl |
|
|
| lemma mollifyReal_memLp (φ : SpatialBump) (f : WholeL2) : MemLp (mollifyReal φ f) 2 volume := by |
| obtain ⟨hm,_⟩ := memLp_probability_average (whole_translation_memLp (μ := bumpProbability φ) f) |
| exact MemLp.ae_eq (ae_of_all _ (fun x => (mollifyReal_eq_average φ f x).symm)) hm |
|
|
| theorem mollifyReal_approx (f : WholeL2) {ε : ℝ} (hε : 0<ε) : |
| ∃ δ : ℝ, 0<δ ∧ ∀ φ : SpatialBump, φ.rOut≤δ → |
| (∫ x, (mollifyReal φ f x-f x)^2) ≤ ε := by |
| obtain ⟨δ,hδ,hd⟩ := small_translation_radius f hε |
| refine ⟨δ,hδ,fun φ hφ => ?_⟩ |
| obtain ⟨_,he⟩ := translation_average_sq_le (μ := bumpProbability φ) f |
| (show ∀ᵐ y ∂bumpProbability φ, ‖translateL2 y f-f‖^2≤ε from by |
| filter_upwards [bumpProbability_ball φ] with y hy |
| exact (hd y (hy.trans_le hφ)).le) |
| simpa only [mollifyReal_sub] using he |
|
|
| def WeakL2Direction (f g : R3 → ℝ) (v : R3) : Prop := |
| ∀ ψ : R3 → ℝ, ContDiff ℝ (↑(⊤ : ℕ∞)) ψ → HasCompactSupport ψ → |
| (∫ x, f x*fderiv ℝ ψ x v) = -(∫ x, g x*ψ x) |
|
|
| lemma mollifyReal_fderiv_eq {f : R3 → ℝ} (hf : LocallyIntegrable f) |
| (φ : SpatialBump) (x v : R3) : |
| fderiv ℝ (mollifyReal φ f) x v= |
| ∫ y, fderiv ℝ (φ.normed volume) (x-y) v*f y := by |
| let L : (R3 →L[ℝ] ℝ) →L[ℝ] ℝ →L[ℝ] (R3 →L[ℝ] ℝ) := ContinuousLinearMap.precompL R3 (ContinuousLinearMap.lsmul ℝ ℝ) |
| have hc : HasCompactSupport (fderiv ℝ (φ.normed volume)) := |
| φ.hasCompactSupport_normed.fderiv ℝ |
| have hκ : ContDiff ℝ (↑(⊤ : ℕ∞)) (φ.normed volume) := φ.contDiff_normed |
| have hd : Continuous (fderiv ℝ (φ.normed volume)) := |
| hκ.continuous_fderiv (by simp) |
| have hi : Integrable (fun y => L (fderiv ℝ (φ.normed volume) (x-y)) (f y)) := |
| (hc.convolutionExists_left L hd hf x).integrable_swap |
| have hder := φ.hasCompactSupport_normed.hasFDerivAt_convolution_left |
| (ContinuousLinearMap.lsmul ℝ ℝ) (hκ.of_le (by simp)) hf x |
| change fderiv ℝ ((φ.normed volume) ⋆[ContinuousLinearMap.lsmul ℝ ℝ,volume] f) x v=_ |
| rw [hder.fderiv,convolution_eq_swap,ContinuousLinearMap.integral_apply hi] |
| rfl |
|
|
| lemma mollifyReal_direction {f g : R3 → ℝ} (hf : MemLp f 2 volume) |
| (_ : MemLp g 2 volume) (v : R3) (hw : WeakL2Direction f g v) |
| (φ : SpatialBump) (x : R3) : |
| fderiv ℝ (mollifyReal φ f) x v=mollifyReal φ g x := by |
| let κ := φ.normed volume |
| have hκ : ContDiff ℝ (↑(⊤ : ℕ∞)) κ := φ.contDiff_normed |
| have hκc : HasCompactSupport κ := φ.hasCompactSupport_normed |
| have hψ : ContDiff ℝ (↑(⊤ : ℕ∞)) (fun y : R3 => κ (x-y)) := |
| hκ.comp (contDiff_const.sub contDiff_id) |
| have hψc : HasCompactSupport (fun y : R3 => κ (x-y)) := |
| hκc.comp_homeomorph (Homeomorph.subLeft x) |
| have hdψ (y : R3) : fderiv ℝ (fun z : R3 => κ (x-z)) y v= |
| -(fderiv ℝ κ (x-y) v) := by |
| have hh := ((hκ.differentiable (by simp)) (x-y)).hasFDerivAt.comp y |
| ((hasFDerivAt_const x y).sub (hasFDerivAt_id y)) |
| change fderiv ℝ (κ ∘ (fun z : R3 => x-z)) y v=_ |
| rw [hh.fderiv] |
| simp |
| have he := hw _ hψ hψc |
| simp_rw [hdψ,mul_neg,integral_neg] at he |
| have he' : (∫ y, fderiv ℝ κ (x-y) v*f y)=∫ y, g y*κ (x-y) := by |
| simpa only [mul_comm,neg_inj] using he |
| rw [mollifyReal_fderiv_eq (hf.locallyIntegrable (by norm_num)),he'] |
| unfold mollifyReal |
| rw [convolution_eq_swap] |
| congr 1 |
| ext y |
| simp [κ,mul_comm] |
|
|
| lemma mollifyReal_zero_outside {f : R3 → ℝ} {R : ℝ} |
| (hf : ∀ᵐ y, R<‖y‖ → f y=0) (φ : SpatialBump) {x : R3} |
| (hx : R+φ.rOut<‖x‖) : mollifyReal φ f x=0 := by |
| unfold mollifyReal |
| rw [convolution_eq_swap] |
| apply integral_eq_zero_of_ae |
| filter_upwards [hf] with y hy |
| change φ.normed volume (x-y)*f y=0 |
| by_cases hf' : f y=0 |
| · rw [hf',mul_zero] |
| · have hR : ‖y‖≤R := le_of_not_gt (fun h => hf' (hy h)) |
| have hn : φ.rOut<‖x-y‖ := by |
| have ht : ‖x‖≤‖x-y‖+‖y‖ := by simpa using norm_add_le (x-y) y |
| linarith |
| have hκ : φ.normed volume (x-y)=0 := by |
| apply Function.notMem_support.mp |
| rw [φ.support_normed_eq,Metric.mem_ball,dist_zero_right] |
| exact not_lt.mpr hn.le |
| rw [hκ,zero_mul] |
|
|
| lemma mollifyReal_support {f : R3 → ℝ} {R : ℝ} |
| (hf : ∀ᵐ y, R<‖y‖ → f y=0) (φ : SpatialBump) : |
| tsupport (mollifyReal φ f)⊆Metric.closedBall 0 (R+φ.rOut) := by |
| apply closure_minimal _ Metric.isClosed_closedBall |
| intro x hx |
| rw [Metric.mem_closedBall,dist_zero_right] |
| exact le_of_not_gt (fun hn => hx (mollifyReal_zero_outside hf φ hn)) |
|
|
| lemma mollifyReal_compact {f : R3 → ℝ} {R : ℝ} |
| (hf : ∀ᵐ y, R<‖y‖ → f y=0) (φ : SpatialBump) : |
| HasCompactSupport (mollifyReal φ f) := |
| (isCompact_closedBall (0:R3) (R+φ.rOut)).of_isClosed_subset (isClosed_tsupport _) |
| (mollifyReal_support hf φ) |
|
|
| end |
|
|
| open Set MeasureTheory Filter Topology |
|
|
| def dyadicBump (n : ℕ) : SpatialBump where |
| rIn := (1/2:ℝ)^(n+1) |
| rOut := (1/2:ℝ)^n |
| rIn_pos := by positivity |
| rIn_lt_rOut := by |
| rw [pow_succ] |
| have h : 0<(1/2:ℝ)^n := by positivity |
| linarith |
|
|
| lemma dyadicBump_radius : Tendsto (fun n => (dyadicBump n).rOut) atTop (𝓝 0) := |
| tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num) (by norm_num) |
|
|
| def mollifyL2 (φ : SpatialBump) (f : WholeL2) : WholeL2 := |
| (mollifyReal_memLp φ f).toLp _ |
|
|
| lemma mollifyL2_ae (φ : SpatialBump) (f : WholeL2) : |
| (mollifyL2 φ f : R3 → ℝ) =ᵐ[volume] mollifyReal φ f := |
| (mollifyReal_memLp φ f).coeFn_toLp |
|
|
| lemma mollifyL2_norm_sq (φ : SpatialBump) (f : WholeL2) : |
| ‖mollifyL2 φ f-f‖^2=∫ x, (mollifyReal φ f x-f x)^2 := by |
| rw [wholeL2_norm_sq] |
| apply integral_congr_ae |
| filter_upwards [Lp.coeFn_sub (mollifyL2 φ f) f,mollifyL2_ae φ f] with x hx hy |
| simp only [hx,Pi.sub_apply,hy] |
|
|
| lemma mollifyL2_tendsto (f : WholeL2) : |
| Tendsto (fun n => mollifyL2 (dyadicBump n) f) atTop (𝓝 f) := by |
| apply Metric.tendsto_atTop.mpr |
| intro ε hε |
| obtain ⟨δ,hδ,hd⟩ := mollifyReal_approx f (show 0<ε^2/2 by positivity) |
| have he : ∀ᶠ n in atTop, (dyadicBump n).rOut<δ := |
| dyadicBump_radius.eventually (gt_mem_nhds hδ) |
| obtain ⟨N,hN⟩ := eventually_atTop.mp he |
| refine ⟨N,fun n hn => ?_⟩ |
| have hh : ‖mollifyL2 (dyadicBump n) f-f‖^2≤ε^2/2 := by |
| rw [mollifyL2_norm_sq] |
| exact hd _ (hN n hn).le |
| rw [dist_eq_norm] |
| nlinarith [norm_nonneg (mollifyL2 (dyadicBump n) f-f)] |
|
|
| abbrev WholeJetSpace := Lp JetFiber 2 (volume : Measure R3) |
|
|
| def jetCoordinateL (i : Fin 4) : ℝ →L[ℝ] JetFiber := |
| (ContinuousLinearMap.id ℝ ℝ).smulRight (EuclideanSpace.single i 1) |
|
|
| lemma jetCoordinateL_apply (i : Fin 4) (r : ℝ) (j : Fin 4) : |
| jetCoordinateL i r j=if j=i then r else 0 := by |
| simp [jetCoordinateL,eq_comm] |
|
|
| def wholeJet (F : Fin 4 → WholeL2) : WholeJetSpace := |
| ∑ i, (jetCoordinateL i).compLpL 2 volume (F i) |
|
|
| lemma wholeJet_ae (F : Fin 4 → WholeL2) : |
| ∀ᵐ x, ∀ i, wholeJet F x i=F i x := by |
| have hc : ∀ᵐ x, ∀ i, ((jetCoordinateL i).compLpL 2 volume (F i)) x=jetCoordinateL i (F i x) := |
| ae_all_iff.mpr (fun i => (jetCoordinateL i).coeFn_compLp (F i)) |
| filter_upwards [hc,Lp.coeFn_finsetSum Finset.univ |
| (fun i => (jetCoordinateL i).compLpL 2 volume (F i))] with x hx hy |
| intro j |
| change (∑ i, (jetCoordinateL i).compLpL 2 volume (F i)) x j=F j x |
| rw [hy] |
| simp only [Finset.sum_apply,hx] |
| change (∑ i, jetCoordinateL i (F i x) j)=F j x |
| simp only [jetCoordinateL_apply] |
| simp |
|
|
| lemma wholeJet_continuous : Continuous wholeJet := by |
| unfold wholeJet |
| apply continuous_finsetSum |
| intro i _ |
| exact ((jetCoordinateL i).compLpL 2 volume).continuous.comp (continuous_apply i) |
|
|
| def ballJet (F : Fin 4 → WholeL2) : JetSpace := |
| LpToLpRestrictCLM R3 JetFiber ℝ volume 2 ball (wholeJet F) |
|
|
| lemma ballJet_ae (F : Fin 4 → WholeL2) : |
| ∀ᵐ x ∂ballMeasure, ∀ i, ballJet F x i=F i x := by |
| filter_upwards [LpToLpRestrictCLM_coeFn ℝ ball (wholeJet F), |
| (wholeJet_ae F).filter_mono (ae_mono Measure.restrict_le_self)] with x hx hy |
| intro i |
| exact congrArg (fun z : JetFiber => z i) hx |>.trans (hy i) |
|
|
| lemma ballJet_continuous : Continuous ballJet := |
| (LpToLpRestrictCLM R3 JetFiber ℝ volume 2 ball).continuous.comp wholeJet_continuous |
|
|
| lemma ballJet_mollify_tendsto (F : Fin 4 → WholeL2) : |
| Tendsto (fun n => ballJet (fun i => mollifyL2 (dyadicBump n) (F i))) atTop (𝓝 (ballJet F)) := |
| ballJet_continuous.continuousAt.tendsto.comp |
| (tendsto_pi_nhds.mpr (fun i => mollifyL2_tendsto (F i))) |
|
|
| lemma mollifiedJet_eq (F : Fin 4 → WholeL2) |
| (hw : ∀ i : Fin 3, WeakL2Direction (F 0) (F i.succ) (EuclideanSpace.single i 1)) |
| (φ : SpatialBump) : |
| ballJet (fun i => mollifyL2 φ (F i))= |
| (smoothH1 (mollifyReal φ (F 0)) |
| (mollifyReal_smooth φ ((Lp.memLp (F 0)).locallyIntegrable (by norm_num)))).val := by |
| apply Lp.ext |
| have hma : ∀ᵐ x ∂ballMeasure, ∀ i : Fin 4, |
| mollifyL2 φ (F i) x=mollifyReal φ (F i) x := |
| (ae_all_iff.mpr (fun i => mollifyL2_ae φ (F i))).filter_mono (ae_mono Measure.restrict_le_self) |
| filter_upwards [ballJet_ae (fun i => mollifyL2 φ (F i)),hma, |
| (smoothJet_memLp (mollifyReal_smooth φ |
| ((Lp.memLp (F 0)).locallyIntegrable (by norm_num)))).coeFn_toLp] with x hx hy hz |
| change _ = (smoothJet_memLp (mollifyReal_smooth φ |
| ((Lp.memLp (F 0)).locallyIntegrable (by norm_num)))).toLp _ x |
| rw [hz] |
| ext i |
| rw [hx i,hy i] |
| refine Fin.cases ?_ (fun j => ?_) i |
| · rfl |
| · change mollifyReal φ (F j.succ) x=gradient (mollifyReal φ (F 0)) x j |
| have hd := mollifyReal_direction (Lp.memLp (F 0)) (Lp.memLp (F j.succ)) |
| (EuclideanSpace.single j 1) (hw j) φ x |
| have he : inner ℝ (EuclideanSpace.single j 1) (gradient (mollifyReal φ (F 0)) x)= |
| fderiv ℝ (mollifyReal φ (F 0)) x (EuclideanSpace.single j 1) := by |
| simp only [inner_gradient_right,RCLike.conj_to_real] |
| simpa only [EuclideanSpace.inner_single_left,RCLike.conj_to_real,one_mul] |
| using (he.trans hd).symm |
|
|
| theorem compact_weakJet_mem_zeroTrace (F : Fin 4 → WholeL2) |
| (hw : ∀ i : Fin 3, WeakL2Direction (F 0) (F i.succ) (EuclideanSpace.single i 1)) |
| {R : ℝ} (hR : R<3) (hs : ∀ᵐ x, R<‖x‖ → F 0 x=0) : |
| ballJet F∈zeroTraceAmbient := by |
| apply (Submodule.isClosed_topologicalClosure (Submodule.span ℝ compactSmoothJets)).mem_of_tendsto |
| (ballJet_mollify_tendsto F) |
| have he : ∀ᶠ n in atTop, (dyadicBump n).rOut<3-R := |
| dyadicBump_radius.eventually (gt_mem_nhds (by linarith)) |
| filter_upwards [he] with n hn |
| rw [mollifiedJet_eq F hw] |
| apply Submodule.le_topologicalClosure |
| apply Submodule.subset_span |
| refine ⟨mollifyReal (dyadicBump n) (F 0), |
| mollifyReal_smooth _ ((Lp.memLp (F 0)).locallyIntegrable (by norm_num)), |
| mollifyReal_compact hs _,?_,smoothJet_memLp (mollifyReal_smooth _ |
| ((Lp.memLp (F 0)).locallyIntegrable (by norm_num))),rfl⟩ |
| intro x hx |
| have hb := mollifyReal_support hs (dyadicBump n) hx |
| change ‖x-0‖<3 |
| rw [sub_zero] |
| have hh : ‖x‖≤R+(dyadicBump n).rOut := by simpa using hb |
| linarith |
|
|
| lemma zeroTraceAmbient_le_H1Space : zeroTraceAmbient≤H1Space := by |
| apply Submodule.topologicalClosure_mono |
| apply Submodule.span_mono |
| rintro z ⟨f,hf,hc,hs,hm,hz⟩ |
| exact ⟨f,hf,hm,hz⟩ |
|
|
| theorem compact_weak_H1 (F : Fin 4 → WholeL2) |
| (hw : ∀ i : Fin 3, WeakL2Direction (F 0) (F i.succ) (EuclideanSpace.single i 1)) |
| {R : ℝ} (hR : R<3) (hs : ∀ᵐ x, R<‖x‖ → F 0 x=0) : |
| ∃ u : H1, u∈H10 ∧ |
| (∀ᵐ x ∂ballMeasure, weakValue u x=F 0 x ∧ ∀ i : Fin 3, weakGradient u x i=F i.succ x) := by |
| have hz := compact_weakJet_mem_zeroTrace F hw hR hs |
| let u : H1 := ⟨ballJet F,zeroTraceAmbient_le_H1Space hz⟩ |
| refine ⟨u,hz,?_⟩ |
| filter_upwards [ballJet_ae F] with x hx |
| exact ⟨hx 0,fun i => hx i.succ⟩ |
|
|
| end ScalarConductivity |
|
|
| end |
|
|
| end OAI |
|
|
