| import OAI.Analysis.AllenCahn.DefectLimits |
| import OAI.Analysis.AllenCahn.SchwartzResolvent |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace DeGiorgi |
| open Filter Set Topology |
| open scoped NNReal |
| open scoped SchwartzMap Laplacian ContDiff |
| open FourierTransform |
| open scoped ContDiff SchwartzMap Polynomial |
| open Filter Topology |
|
|
| lemma boundedAbove_quadratic_maximum {n : ℕ} {f : Space n → ℝ} |
| (hf : Continuous f) {M ε : ℝ} (hb : ∀ x, f x ≤ M) (hε : 0 < ε) : |
| ∃ x : Space n, ∀ y, f y-ε*‖y‖^2 ≤ f x-ε*‖x‖^2 := by |
| let H : Space n → ℝ := fun x => f x-ε*‖x‖^2 |
| have hc : Continuous H := by fun_prop |
| let R := Real.sqrt ((M-f 0)/ε+1) |
| have hR := Real.sqrt_nonneg ((M-f 0)/ε+1) |
| have hR2 : R^2 = (M-f 0)/ε+1 := Real.sq_sqrt (by have := hb 0; positivity) |
| have hh : ∀ᶠ x in cocompact (Space n), H x ≤ H 0 := by |
| filter_upwards [(isCompact_closedBall (0 : Space n) R).compl_mem_cocompact] with x hx |
| have hx' : R < ‖x‖ := by |
| simpa only [Set.mem_compl_iff,Metric.mem_closedBall,dist_zero_right,not_le] using hx |
| have hsq : (M-f 0)/ε+1 < ‖x‖^2 := by nlinarith [norm_nonneg x] |
| have hmul := mul_lt_mul_of_pos_left hsq hε |
| have he : ε*((M-f 0)/ε+1)=M-f 0+ε := by field_simp |
| rw [he] at hmul |
| dsimp [H] |
| simp only [norm_zero,zero_pow two_ne_zero,mul_zero,sub_zero] |
| linarith [hb x] |
| exact hc.exists_forall_ge' 0 hh |
|
|
| lemma boundedAbove_maximum_principle {n : ℕ} {f : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) {M : ℝ} (hb : ∀ x, f x ≤ M) |
| (hpde : ∀ x, 0 < f x → f x ≤ Laplacian.laplacian f x) : ∀ x, f x ≤ 0 := by |
| intro x₀ |
| by_contra hbad |
| have hpos : 0 < f x₀ := lt_of_not_ge hbad |
| have hn : ∀ᶠ t : ℝ in 𝓝 0, |
| 2*n*t < f x₀/2 ∧ t*‖x₀‖^2 < f x₀/2 := by |
| apply Filter.Eventually.and |
| · exact (isOpen_lt (continuous_const.mul continuous_id) continuous_const).mem_nhds |
| (by simpa using half_pos hpos) |
| · exact (isOpen_lt (continuous_id.mul continuous_const) continuous_const).mem_nhds |
| (by simpa using half_pos hpos) |
| obtain ⟨ε,hε,he,hgap⟩ := (frequently_gt_nhds (0 : ℝ)).and_eventually hn |>.exists |
| obtain ⟨x,hm⟩ := boundedAbove_quadratic_maximum hf.continuous hb hε |
| have hfx : f x₀/2 < f x := by |
| have hh := hm x₀ |
| nlinarith [mul_nonneg hε.le (sq_nonneg ‖x‖)] |
| have hp := hpde x (lt_trans (half_pos hpos) hfx) |
| have hnorm : ContDiff ℝ 2 (fun z : Space n => ‖z‖^2) := contDiff_id.norm_sq ℝ |
| have hF := hf.sub ((contDiff_const : ContDiff ℝ 2 (fun _ : Space n => ε)).mul hnorm) |
| have hm' : IsLocalMax (fun z : Space n => f z-ε*‖z‖^2) x := .of_forall hm |
| have hl := laplacian_nonpos_of_local_max hF hm' |
| rw [laplacian_fun_sub hf (contDiff_const.mul hnorm),laplacian_fun_const_mul hnorm, |
| laplacian_norm_sq] at hl |
| linarith |
|
|
| lemma boundedAbove_elliptic_comparison {n : ℕ} {u F P : Space n → ℝ} |
| (hu : ContDiff ℝ 2 u) (hF : ContDiff ℝ 2 F) {M : ℝ} |
| (hb : ∀ x, u x-F x ≤ M) (hP : ∀ x, 1 ≤ P x) |
| (he : ∀ x, -Laplacian.laplacian u x+P x*u x ≤ -Laplacian.laplacian F x+P x*F x) : |
| ∀ x, u x ≤ F x := by |
| have hh := boundedAbove_maximum_principle (hu.sub hF) hb (fun x hx => ?_) |
| · intro x |
| exact sub_nonpos.mp (hh x) |
| · rw [laplacian_fun_sub hu hF] |
| have hp := mul_le_mul_of_nonneg_right (hP x) hx.le |
| nlinarith [he x] |
|
|
| lemma polynomial_profile_iteratedDeriv (p : Polynomial ℝ) (k : ℕ) : |
| ∃ q : Polynomial ℝ, iteratedDeriv k (fun s => p.eval (profile s)) = fun s => q.eval (profile s) := by |
| induction k with |
| | zero => exact ⟨p,rfl⟩ |
| | succ k ih => |
| obtain ⟨q,hq⟩ := ih |
| refine ⟨q.derivative*(Polynomial.C ((Real.sqrt 2)⁻¹)*(1-Polynomial.X^2)), ?_⟩ |
| rw [iteratedDeriv_succ,hq] |
| funext s |
| have HH := (q.hasDerivAt (profile s)).comp s (profile_hasDerivAt s) |
| change deriv ((fun y => q.eval y) ∘ profile) s = _ |
| rw [HH.deriv] |
| simp only [Polynomial.eval_mul,Polynomial.eval_C,Polynomial.eval_sub, |
| Polynomial.eval_one,Polynomial.eval_pow,Polynomial.eval_X,profileWeight,div_eq_mul_inv] |
| ring |
|
|
| lemma profile_temperate : profile.HasTemperateGrowth := by |
| refine ⟨profile_contDiff,fun k => ?_⟩ |
| obtain ⟨q,hq⟩ := polynomial_profile_iteratedDeriv Polynomial.X k |
| have he : iteratedDeriv k profile = fun s => q.eval (profile s) := by simpa using hq |
| obtain ⟨z,hz,hm⟩ := isCompact_Icc.exists_isMaxOn |
| (show (Set.Icc (-1 : ℝ) 1).Nonempty from ⟨0,by norm_num⟩) q.continuous.abs.continuousOn |
| refine ⟨0,|q.eval z|,fun x => ?_⟩ |
| rw [norm_iteratedFDeriv_eq_norm_iteratedDeriv,he,Real.norm_eq_abs,pow_zero,mul_one] |
| apply hm |
| exact ⟨(Real.neg_one_lt_tanh _).le,(Real.tanh_lt_one _).le⟩ |
|
|
| lemma profileWeight_temperate : profileWeight.HasTemperateGrowth := |
| (Function.HasTemperateGrowth.const (1 : ℝ)).sub (profile_temperate.pow 2) |
|
|
| lemma profileWeight_le_one (s : ℝ) : profileWeight s ≤ 1 := by |
| dsimp [profileWeight] |
| nlinarith [sq_nonneg (profile s)] |
|
|
| def realResolvent {n : ℕ} (f : 𝓢(Space n,ℝ)) : 𝓢(Space n,ℝ) := |
| Classical.choose (EllipticResolvent.exists_real_schwartz_resolvent f) |
|
|
| lemma realResolvent_equation {n : ℕ} (f : 𝓢(Space n,ℝ)) (x : Space n) : |
| 2*realResolvent f x-Laplacian.laplacian (realResolvent f : Space n → ℝ) x=f x := |
| Classical.choose_spec (EllipticResolvent.exists_real_schwartz_resolvent f) x |
|
|
| lemma schwartz_bounded {n : ℕ} (f : 𝓢(Space n,ℝ)) : |
| ∃ M : ℝ, 0 ≤ M ∧ ∀ x, |f x| ≤ M := |
| ⟨SchwartzMap.seminorm ℝ 0 0 f,apply_nonneg _ _,SchwartzMap.norm_le_seminorm ℝ f⟩ |
|
|
| lemma realResolvent_nonneg {n : ℕ} {f : 𝓢(Space n,ℝ)} (hf : ∀ x, 0 ≤ f x) : |
| ∀ x, 0 ≤ realResolvent f x := by |
| obtain ⟨M,hM,hb⟩ := schwartz_bounded (realResolvent f) |
| apply boundedAbove_elliptic_comparison (u := fun _ => 0) (F := (realResolvent f : Space n → ℝ)) |
| contDiff_const ((realResolvent f).smooth 2) (M := M) (P := fun _ => 2) |
| · intro x |
| linarith [(abs_le.mp (hb x)).1] |
| · intro x; norm_num |
| · intro x |
| simpa only [InnerProductSpace.laplacian_const,Pi.zero_apply,neg_zero,mul_zero,add_zero] |
| using (show (0 : ℝ) ≤ -Laplacian.laplacian (realResolvent f : Space n → ℝ) x+2*realResolvent f x by |
| linarith [realResolvent_equation f x,hf x]) |
|
|
| lemma realResolvent_bound {n : ℕ} {f : 𝓢(Space n,ℝ)} {M : ℝ} |
| (hf : ∀ x, |f x| ≤ M) : ∀ x, |realResolvent f x| ≤ M/2 := by |
| obtain ⟨B,hB,hb⟩ := schwartz_bounded (realResolvent f) |
| have hh (e : ℝ) (he : |e|=1) : ∀ x, e*realResolvent f x ≤ M/2 := by |
| apply boundedAbove_elliptic_comparison (u := fun x => e*realResolvent f x) |
| (F := fun _ => M/2) (contDiff_const.mul ((realResolvent f).smooth 2)) contDiff_const |
| (M := B+|M/2|) (P := fun _ => 2) |
| · intro x |
| have hmul : |e*realResolvent f x| ≤ B := by rw [abs_mul,he,one_mul]; exact hb x |
| linarith [(abs_le.mp hmul).2,le_abs_self (M/2),neg_abs_le (M/2)] |
| · intro x; norm_num |
| · intro x |
| rw [laplacian_fun_const_mul ((realResolvent f).smooth 2)] |
| have heq := congrArg (fun r : ℝ => e*r) (realResolvent_equation f x) |
| have hmul : |e*f x| ≤ M := by rw [abs_mul,he,one_mul]; exact hf x |
| simp only [InnerProductSpace.laplacian_const,Pi.zero_apply,neg_zero,zero_add] |
| nlinarith [(abs_le.mp hmul).2] |
| intro x |
| have h1 := hh 1 (by norm_num) x |
| have h2 := hh (-1) (by norm_num) x |
| exact abs_le.mpr ⟨by linarith,by linarith⟩ |
|
|
| end DeGiorgi |
| end |
|
|
| noncomputable section |
| namespace DeGiorgi |
| open Filter Set Topology |
| open scoped NNReal |
| open scoped SchwartzMap Laplacian ContDiff |
| open FourierTransform |
| open scoped ContDiff SchwartzMap LineDeriv |
| open Filter Topology |
|
|
| lemma realResolvent_mono {n : ℕ} {f g : 𝓢(Space n,ℝ)} (h : ∀ x, f x ≤ g x) : |
| ∀ x, realResolvent f x ≤ realResolvent g x := by |
| obtain ⟨M,hM,hMb⟩ := schwartz_bounded (realResolvent f) |
| obtain ⟨N,hN,hNb⟩ := schwartz_bounded (realResolvent g) |
| apply boundedAbove_elliptic_comparison ((realResolvent f).smooth 2) |
| ((realResolvent g).smooth 2) (M := M+N) (P := fun _ => 2) |
| · intro x |
| linarith [(abs_le.mp (hMb x)).2,(abs_le.mp (hNb x)).1] |
| · intro x; norm_num |
| · intro x |
| linarith [realResolvent_equation f x,realResolvent_equation g x,h x] |
|
|
| lemma realResolvent_comparison {n : ℕ} {f : 𝓢(Space n,ℝ)} {F : Space n → ℝ} |
| (hF : ContDiff ℝ 2 F) (hp : ∀ x, 0 ≤ F x) |
| (he : ∀ x, f x ≤ 2*F x-Laplacian.laplacian F x) : |
| ∀ x, realResolvent f x ≤ F x := by |
| obtain ⟨M,hM,hb⟩ := schwartz_bounded (realResolvent f) |
| apply boundedAbove_elliptic_comparison ((realResolvent f).smooth 2) hF |
| (M := M) (P := fun _ => 2) |
| · intro x; linarith [(abs_le.mp (hb x)).2,hp x] |
| · intro x; norm_num |
| · intro x; linarith [realResolvent_equation f x,he x] |
|
|
| lemma realResolvent_isometry {n : ℕ} (f : 𝓢(Space n,ℝ)) |
| (J : Space n ≃ₗᵢ[ℝ] Space n) (hJ : ∀ x, f (J x)=f x) : |
| ∀ x, realResolvent f (J x)=realResolvent f x := by |
| let u := realResolvent f |
| have hu : ContDiff ℝ 2 (fun x => u (J x)) := (u.smooth 2).comp J.contDiff |
| obtain ⟨M,hM,hb⟩ := schwartz_bounded u |
| have hEq (x) : 2*u (J x)-Laplacian.laplacian (fun x => u (J x)) x=f x := by |
| rw [PoissonSupport.DeGiorgi.laplacian_comp_isometry (u.smooth 2)] |
| exact (realResolvent_equation f (J x)).trans (hJ x) |
| have h₁ : ∀ x, u (J x) ≤ u x := by |
| apply boundedAbove_elliptic_comparison hu (u.smooth 2) (M := 2*M) (P := fun _ => 2) |
| · intro x; linarith [(abs_le.mp (hb x)).1,(abs_le.mp (hb (J x))).2] |
| · intro x; norm_num |
| · intro x; linarith [hEq x,realResolvent_equation f x] |
| have h₂ : ∀ x, u x ≤ u (J x) := by |
| apply boundedAbove_elliptic_comparison (u.smooth 2) hu (M := 2*M) (P := fun _ => 2) |
| · intro x; linarith [(abs_le.mp (hb x)).2,(abs_le.mp (hb (J x))).1] |
| · intro x; norm_num |
| · intro x; linarith [hEq x,realResolvent_equation f x] |
| exact fun x => le_antisymm (h₁ x) (h₂ x) |
|
|
| lemma schwartz_coordinateJet {n : ℕ} (f : 𝓢(Space n,ℝ)) (l : List (Fin n)) : |
| ∃ g : 𝓢(Space n,ℝ), (g : Space n → ℝ)=coordinateJet f l := by |
| induction l with |
| | nil => exact ⟨f,rfl⟩ |
| | cons i l ih => |
| obtain ⟨g,hg⟩ := ih |
| refine ⟨∂_{basis n i} g, ?_⟩ |
| funext x |
| rw [SchwartzMap.lineDerivOp_apply_eq_fderiv,hg] |
| rfl |
|
|
| lemma schwartz_jets_bounded {n : ℕ} (f : 𝓢(Space n,ℝ)) (l : List (Fin n)) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ x, |coordinateJet f l x| ≤ C := by |
| obtain ⟨g,hg⟩ := schwartz_coordinateJet f l |
| simpa only [hg] using schwartz_bounded g |
|
|
| lemma JetControl.reindex {n : ℕ} {α β : Type*} {S : Set α} {T : Set β} |
| {w f : α → Space n → ℝ} {k : ℕ} (h : JetControl S w f k) (g : β → α) |
| (hg : ∀ b ∈ T, g b ∈ S) : |
| JetControl T (fun b => w (g b)) (fun b => f (g b)) k := by |
| intro l hl |
| obtain ⟨C,hC,hb⟩ := h l hl |
| exact ⟨C,hC,fun b hT x => hb (g b) (hg b hT) x⟩ |
|
|
| def resolventIterate {n : ℕ} (V : Space n → ℝ) (f : 𝓢(Space n,ℝ)) : ℕ → 𝓢(Space n,ℝ) |
| | 0 => 0 |
| | k+1 => realResolvent (f+SchwartzMap.smulLeftCLM ℝ V (resolventIterate V f k)) |
|
|
| lemma resolventIterate_equation {n : ℕ} {V : Space n → ℝ} (hV : V.HasTemperateGrowth) |
| (f : 𝓢(Space n,ℝ)) (k : ℕ) (x : Space n) : |
| 2*resolventIterate V f (k+1) x-Laplacian.laplacian (resolventIterate V f (k+1) : Space n → ℝ) x = |
| f x+V x*resolventIterate V f k x := by |
| simpa only [resolventIterate,add_apply,SchwartzMap.smulLeftCLM_apply_apply hV,smul_eq_mul] |
| using realResolvent_equation (f+SchwartzMap.smulLeftCLM ℝ V (resolventIterate V f k)) x |
|
|
| lemma resolventIterate_nonneg {n : ℕ} {V : Space n → ℝ} (hV : V.HasTemperateGrowth) |
| (hV0 : ∀ x, 0 ≤ V x) {f : 𝓢(Space n,ℝ)} (hf : ∀ x, 0 ≤ f x) : |
| ∀ k x, 0 ≤ resolventIterate V f k x := by |
| intro k |
| induction k with |
| | zero => simp [resolventIterate] |
| | succ k ih => |
| apply realResolvent_nonneg |
| intro x |
| simpa only [add_apply,SchwartzMap.smulLeftCLM_apply_apply hV,smul_eq_mul] |
| using add_nonneg (hf x) (mul_nonneg (hV0 x) (ih x)) |
|
|
| lemma resolventIterate_comparison {n : ℕ} {V F : Space n → ℝ} |
| (hV : V.HasTemperateGrowth) (hV0 : ∀ x, 0 ≤ V x) |
| (hF : ContDiff ℝ 2 F) (hF0 : ∀ x, 0 ≤ F x) {f : 𝓢(Space n,ℝ)} |
| (he : ∀ x, f x+V x*F x ≤ 2*F x-Laplacian.laplacian F x) : |
| ∀ k x, resolventIterate V f k x ≤ F x := by |
| intro k |
| induction k with |
| | zero => simpa [resolventIterate] using hF0 |
| | succ k ih => |
| apply realResolvent_comparison hF hF0 |
| intro x |
| simp only [add_apply,SchwartzMap.smulLeftCLM_apply_apply hV,smul_eq_mul] |
| exact (add_le_add le_rfl (mul_le_mul_of_nonneg_left (ih x) (hV0 x))).trans (he x) |
|
|
| lemma resolventIterate_mono_source {n : ℕ} {V : Space n → ℝ} |
| (hV : V.HasTemperateGrowth) (hV0 : ∀ x, 0 ≤ V x) {f g : 𝓢(Space n,ℝ)} |
| (hfg : ∀ x, f x ≤ g x) : ∀ k x, resolventIterate V f k x ≤ resolventIterate V g k x := by |
| intro k |
| induction k with |
| | zero => simp only [resolventIterate,le_refl,implies_true] |
| | succ k ih => |
| apply realResolvent_mono |
| intro x |
| simp only [add_apply,SchwartzMap.smulLeftCLM_apply_apply hV,smul_eq_mul] |
| exact add_le_add (hfg x) (mul_le_mul_of_nonneg_left (ih x) (hV0 x)) |
|
|
| lemma resolventIterate_mono_index {n : ℕ} {V : Space n → ℝ} |
| (hV : V.HasTemperateGrowth) (hV0 : ∀ x, 0 ≤ V x) {f : 𝓢(Space n,ℝ)} |
| (hf : ∀ x, 0 ≤ f x) (x : Space n) : Monotone (fun k => resolventIterate V f k x) := by |
| apply monotone_nat_of_le_succ |
| have H : ∀ k x, resolventIterate V f k x ≤ resolventIterate V f (k+1) x := by |
| intro k |
| induction k with |
| | zero => simpa only [resolventIterate,zero_apply] using resolventIterate_nonneg hV hV0 hf 1 |
| | succ k ih => |
| apply realResolvent_mono |
| intro x |
| simp only [add_apply,SchwartzMap.smulLeftCLM_apply_apply hV,smul_eq_mul] |
| exact add_le_add le_rfl (mul_le_mul_of_nonneg_left (ih x) (hV0 x)) |
| exact fun k => H k x |
|
|
| lemma resolventIterate_isometry {n : ℕ} {V : Space n → ℝ} (hV : V.HasTemperateGrowth) |
| (J : Space n ≃ₗᵢ[ℝ] Space n) {f : 𝓢(Space n,ℝ)} |
| (hJV : ∀ x, V (J x)=V x) (hJf : ∀ x, f (J x)=f x) : |
| ∀ k x, resolventIterate V f k (J x)=resolventIterate V f k x := by |
| intro k |
| induction k with |
| | zero => simp [resolventIterate] |
| | succ k ih => |
| apply realResolvent_isometry _ J |
| intro x |
| simp only [add_apply,SchwartzMap.smulLeftCLM_apply_apply hV,smul_eq_mul,hJV,hJf,ih] |
|
|
| end DeGiorgi |
| end |
|
|
| end OAI |
|
|
