| import OAI.Analysis.AllenCahn.JetProducts |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace RegularitySupport.DeGiorgi |
| open Filter Set Topology |
| open scoped NNReal |
| open scoped SchwartzMap Laplacian ContDiff |
| open FourierTransform |
| open Filter Topology |
| open scoped ContDiff |
| open MeasureTheory |
| open scoped ENNReal |
|
|
| abbrev Space (n : ℕ) := EuclideanSpace ℝ (Fin n) |
|
|
| def potential (t : ℝ) : ℝ := (1 - t ^ 2) ^ 2 / 4 |
|
|
| def profile (s : ℝ) : ℝ := Real.tanh (s / Real.sqrt 2) |
|
|
| def surfaceTension : ℝ := 2 * Real.sqrt 2 / 3 |
|
|
| def AllenCahn {n : ℕ} (v : Space n → ℝ) : Prop := |
| ∀ x, Laplacian.laplacian v x = v x ^ 3 - v x |
|
|
| def SecondVariation {n : ℕ} (v φ : Space n → ℝ) : ℝ := |
| ∫ x, (‖gradient φ x‖ ^ 2 + (3 * v x ^ 2 - 1) * φ x ^ 2) |
|
|
| def Stable {n : ℕ} (v : Space n → ℝ) : Prop := |
| ∀ φ : Space n → ℝ, ContDiff ℝ 1 φ → HasCompactSupport φ → |
| 0 ≤ SecondVariation v φ |
|
|
| def Energy {n : ℕ} (v : Space n → ℝ) (Ω : Set (Space n)) : ℝ := |
| ∫ x in Ω, (‖gradient v x‖ ^ 2 / 2 + potential (v x)) |
|
|
| def unitBallVolume (m : ℕ) : ℝ := |
| volume.real (Metric.ball (0 : Space m) 1) |
|
|
| def density {n : ℕ} (v : Space n → ℝ) (R : ℝ) (y : Space n) : ℝ := |
| Energy v (Metric.ball y R) / (surfaceTension * unitBallVolume (n - 1) * R ^ (n - 1)) |
|
|
| def densityAtInfinity {n : ℕ} (v : Space n → ℝ) : ℝ≥0∞ := |
| ⨆ R : { R : ℝ // 0 < R }, ENNReal.ofReal (density v R.val 0) |
|
|
| def Classified {n : ℕ} (v : Space n → ℝ) : Prop := |
| (∀ x, v x = 1) ∨ (∀ x, v x = -1) ∨ |
| ∃ (a : Space n) (b : ℝ), ‖a‖ = 1 ∧ ∀ x, v x = profile (inner ℝ a x - b) |
|
|
| def StableRigiditySeven : Prop := |
| ∀ v : Space 7 → ℝ, ContDiff ℝ 2 v → |
| (∀ x, v x ∈ Set.Icc (-1 : ℝ) 1) → AllenCahn v → Stable v → Classified v |
|
|
| def MonotoneRigidityEight : Prop := |
| ∀ u : Space 8 → ℝ, ContDiff ℝ 2 u → |
| (∀ x, u x ∈ Set.Ioo (-1 : ℝ) 1) → AllenCahn u → |
| (∀ x, 0 < fderiv ℝ u x (EuclideanSpace.single (7 : Fin 8) 1)) → |
| ∃ (e : Space 8) (c : ℝ), ‖e‖ = 1 ∧ 0 < e 7 ∧ |
| ∀ x, u x = profile (inner ℝ e x - c) |
|
|
| def FiniteDensityRigidity : Prop := |
| ∀ (n : ℕ), 4 ≤ n → n ≤ 7 → |
| ∀ v : Space n → ℝ, ContDiff ℝ 2 v → |
| (∀ x, v x ∈ Set.Icc (-1 : ℝ) 1) → AllenCahn v → Stable v → |
| densityAtInfinity v < ⊤ → Classified v |
|
|
| end RegularitySupport.DeGiorgi |
| end |
|
|
| noncomputable section |
| namespace RegularitySupport.DeGiorgi |
| open Filter Set Topology |
| open scoped NNReal |
| open scoped SchwartzMap Laplacian ContDiff |
| open FourierTransform |
| open Filter Topology |
| open scoped ContDiff |
| open MeasureTheory |
| open scoped ENNReal |
|
|
| lemma second_deriv_nonneg_of_local_min {f : ℝ → ℝ} {x : ℝ} |
| (hf : ContinuousAt f x) (hm : IsLocalMin f x) : 0 ≤ deriv (deriv f) x := by |
| by_contra h |
| have hn : deriv (deriv f) x < 0 := lt_of_not_ge h |
| have hmax := isLocalMax_of_deriv_deriv_neg hn hm.deriv_eq_zero hf |
| have he : f =ᶠ[𝓝 x] fun _ => f x := by |
| filter_upwards [hm, hmax] with y hy hz using le_antisymm hz hy |
| have hz := he.deriv.deriv_eq |
| have hz0 : deriv (deriv f) x = 0 := by |
| calc deriv (deriv f) x = deriv (deriv (fun _ : ℝ => f x)) x := hz |
| _ = 0 := by simp |
| linarith |
|
|
| private def basis (n : ℕ) := EuclideanSpace.basisFun (Fin n) ℝ |
|
|
| def coordDeriv {n : ℕ} (f : Space n → ℝ) (i : Fin n) (x : Space n) : ℝ := |
| fderiv ℝ f x (basis n i) |
|
|
| lemma coordDeriv_contDiff {n : ℕ} {f : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) (i : Fin n) : ContDiff ℝ 1 (coordDeriv f i) := by |
| exact (hf.fderiv_right (m := 1) (by norm_num)).clm_apply contDiff_const |
|
|
| lemma laplacian_eq_sum_coordDeriv {n : ℕ} {f : Space n → ℝ} (hf : ContDiff ℝ 2 f) |
| (x : Space n) : |
| Laplacian.laplacian f x = ∑ i : Fin n, coordDeriv (coordDeriv f i) i x := by |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis f (basis n)] |
| apply Finset.sum_congr rfl |
| intro i hi |
| rw [iteratedFDeriv_two_apply] |
| change _ = fderiv ℝ (fun y => fderiv ℝ f y (basis n i)) x (basis n i) |
| simp [fderiv_clm_apply |
| ((hf.fderiv_right (m := 1) (by norm_num)).differentiable (by norm_num) x) |
| (differentiableAt_const (c := basis n i))] |
|
|
| lemma deriv_line {n : ℕ} {f : Space n → ℝ} (hf : Differentiable ℝ f) |
| (x e : Space n) (t : ℝ) : |
| deriv (fun s : ℝ => f (x + s • e)) t = fderiv ℝ f (x + t • e) e := by |
| have hd : HasDerivAt (fun s : ℝ => x + s • e) e t := by |
| simpa using (hasDerivAt_const t x).fun_add ((hasDerivAt_id t).smul_const e) |
| exact ((hf _).hasFDerivAt.comp_hasDerivAt t hd).deriv |
|
|
| lemma laplacian_nonneg_of_local_min {n : ℕ} {f : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) {x : Space n} (hm : IsLocalMin f x) : |
| 0 ≤ Laplacian.laplacian f x := by |
| rw [laplacian_eq_sum_coordDeriv hf] |
| apply Finset.sum_nonneg |
| intro i _ |
| let g : ℝ → ℝ := fun s => f (x + s • basis n i) |
| have hg : ContinuousAt g 0 := hf.continuous.continuousAt.comp |
| (continuous_const.add (continuous_id.smul continuous_const)).continuousAt |
| have hmin : IsLocalMin g 0 := by |
| have ht : Tendsto (fun s : ℝ => x + s • basis n i) (𝓝 0) (𝓝 x) := by |
| have hc : Continuous (fun s : ℝ => x + s • basis n i) := |
| continuous_const.add (continuous_id.smul continuous_const) |
| simpa only [ContinuousAt, zero_smul, add_zero] using hc.continuousAt (x := 0) |
| change ∀ᶠ s in 𝓝 (0 : ℝ), g 0 ≤ g s |
| simpa [g] using ht.eventually hm |
| have hder : deriv g = fun s => coordDeriv f i (x + s • basis n i) := by |
| funext s |
| exact deriv_line (hf.differentiable (by norm_num)) x (basis n i) s |
| have hh := second_deriv_nonneg_of_local_min hg hmin |
| rw [hder, deriv_line ((coordDeriv_contDiff hf i).differentiable (by norm_num))] at hh |
| simpa [coordDeriv] using hh |
|
|
| lemma laplacian_nonpos_of_local_max {n : ℕ} {f : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) {x : Space n} (hm : IsLocalMax f x) : |
| Laplacian.laplacian f x ≤ 0 := by |
| have h := laplacian_nonneg_of_local_min hf.neg hm.neg |
| change 0 ≤ Laplacian.laplacian (-f) x at h |
| rw [InnerProductSpace.laplacian_neg] at h |
| simpa using h |
|
|
| lemma coordDeriv_translate {n : ℕ} {f : Space n → ℝ} |
| (hf : Differentiable ℝ f) (a : Space n) (i : Fin n) (x : Space n) : |
| coordDeriv (fun z => f (a + z)) i x = coordDeriv f i (a + x) := by |
| dsimp [coordDeriv] |
| have hd : HasFDerivAt (fun z => f (a + z)) (fderiv ℝ f (a + x)) x := by |
| simpa only [Function.comp_def, zero_add, ContinuousLinearMap.comp_id, id_eq] using (hf (a + x)).hasFDerivAt.comp x |
| ((hasFDerivAt_const a x).fun_add (hasFDerivAt_id x)) |
| rw [hd.fderiv] |
|
|
| lemma laplacian_translate {n : ℕ} {f : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) (a x : Space n) : |
| Laplacian.laplacian (fun z => f (a + z)) x = Laplacian.laplacian f (a + x) := by |
| have hs : ContDiff ℝ 2 (fun z => f (a + z)) := |
| hf.comp (contDiff_const.add contDiff_id) |
| rw [laplacian_eq_sum_coordDeriv hs, |
| laplacian_eq_sum_coordDeriv hf] |
| apply Finset.sum_congr rfl |
| intro i _ |
| have hfun : coordDeriv (fun z => f (a + z)) i = fun z => coordDeriv f i (a + z) := |
| funext (coordDeriv_translate (hf.differentiable (by norm_num)) a i) |
| rw [hfun, coordDeriv_translate ((coordDeriv_contDiff hf i).differentiable (by norm_num))] |
|
|
| lemma laplacian_norm_sq {n : ℕ} (x : Space n) : |
| Laplacian.laplacian (fun z : Space n => ‖z‖ ^ 2) x = 2 * n := by |
| have hs : ContDiff ℝ 2 (fun z : Space n => ‖z‖ ^ 2) := contDiff_id.norm_sq ℝ |
| rw [laplacian_eq_sum_coordDeriv hs] |
| have hfirst (i : Fin n) : coordDeriv (fun z : Space n => ‖z‖ ^ 2) i = |
| fun z => 2 * inner ℝ z (basis n i) := by |
| funext z |
| simp [coordDeriv] |
| simp_rw [hfirst] |
| have hsecond (i : Fin n) : coordDeriv (fun z => 2 * inner ℝ z (basis n i)) i x = 2 := by |
| dsimp [coordDeriv] |
| have hd : HasFDerivAt (fun z : Space n => 2 * inner ℝ z (basis n i)) |
| ((2 : ℝ) • innerSL ℝ (basis n i)) x := by |
| simpa [real_inner_comm] using |
| ((innerSL ℝ (basis n i)).hasFDerivAt (x := x)).const_mul 2 |
| rw [hd.fderiv] |
| simp [basis] |
| simp_rw [hsecond] |
| simp [mul_comm] |
|
|
| lemma hasFDerivAt_norm_nonzero {n : ℕ} {x : Space n} (hx : x ≠ 0) : |
| HasFDerivAt (fun z : Space n => ‖z‖) (‖x‖⁻¹ • innerSL ℝ x) x := by |
| have h := (hasStrictFDerivAt_norm_sq x).hasFDerivAt.sqrt |
| (pow_ne_zero 2 (norm_ne_zero_iff.mpr hx)) |
| simp only [Real.sqrt_sq (norm_nonneg _)] at h |
| have he : (1 / (2 * ‖x‖) : ℝ) * 2 = ‖x‖⁻¹ := by field_simp |
| rw [← Nat.cast_smul_eq_nsmul ℝ 2, smul_smul, Nat.cast_ofNat, he] at h |
| exact h |
|
|
| lemma laplacian_fun_sub {n : ℕ} {f g : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) (hg : ContDiff ℝ 2 g) (x : Space n) : |
| Laplacian.laplacian (fun z => f z - g z) x = |
| Laplacian.laplacian f x - Laplacian.laplacian g x := by |
| change Laplacian.laplacian (f - g) x = _ |
| exact hf.contDiffAt.laplacian_sub hg.contDiffAt |
|
|
| lemma laplacian_fun_add {n : ℕ} {f g : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) (hg : ContDiff ℝ 2 g) (x : Space n) : |
| Laplacian.laplacian (fun z => f z + g z) x = |
| Laplacian.laplacian f x + Laplacian.laplacian g x := by |
| change Laplacian.laplacian (f + g) x = _ |
| exact hf.contDiffAt.laplacian_add hg.contDiffAt |
|
|
| lemma laplacian_fun_const_mul {n : ℕ} {f : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) (c : ℝ) (x : Space n) : |
| Laplacian.laplacian (fun z => c * f z) x = c * Laplacian.laplacian f x := by |
| change Laplacian.laplacian (c • f) x = _ |
| exact InnerProductSpace.laplacian_smul c hf.contDiffAt |
|
|
| lemma laplacian_comp_isometry {n : ℕ} {f : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) (J : Space n ≃ₗᵢ[ℝ] Space n) (x : Space n) : |
| Laplacian.laplacian (fun z => f (J z)) x = Laplacian.laplacian f (J x) := by |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis _ (basis n), |
| InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis _ ((basis n).map J)] |
| apply Finset.sum_congr rfl |
| intro i _ |
| change iteratedFDeriv ℝ 2 (f ∘ J.toContinuousLinearMap) x _ = _ |
| rw [J.toContinuousLinearMap.iteratedFDeriv_comp_right hf x (by norm_num)] |
| simp only [ContinuousMultilinearMap.compContinuousLinearMap_apply, |
| OrthonormalBasis.map_apply] |
| congr 1 |
| ext j |
| fin_cases j <;> simp |
|
|
| def reflect {n : ℕ} (e : Space n) : Space n ≃ₗᵢ[ℝ] Space n := |
| (Submodule.span ℝ {e})ᗮ.reflection |
|
|
| lemma reflect_apply {n : ℕ} {e : Space n} (he : ‖e‖ = 1) (z : Space n) : |
| reflect e z = z - (2 * inner ℝ e z) • e := by |
| simp only [reflect, Submodule.reflection_orthogonal_apply, |
| Submodule.reflection_singleton_apply, he] |
| norm_num only [RCLike.ofReal_real_eq_id, id_eq, one_pow, div_one] |
| rw [neg_sub, ← smul_assoc] |
| simp only [two_smul, two_mul] |
|
|
| def poissonPenalty (A t : ℝ) : ℝ := A * (1 - (max (1 - t) 0) ^ 2) |
|
|
| lemma poissonPenalty_of_le (A : ℝ) {t : ℝ} (ht : t ≤ 1) : |
| poissonPenalty A t = A * (2 * t - t ^ 2) := by |
| rw [poissonPenalty, max_eq_left (by linarith)] |
| ring |
|
|
| lemma poissonPenalty_of_ge (A : ℝ) {t : ℝ} (ht : 1 ≤ t) : |
| poissonPenalty A t = A := by |
| simp [poissonPenalty, max_eq_right (show 1 - t ≤ 0 by linarith)] |
|
|
| lemma poissonPenalty_nonneg {A t : ℝ} (hA : 0 ≤ A) (ht : 0 ≤ t) : |
| 0 ≤ poissonPenalty A t := by |
| by_cases h : t ≤ 1 |
| · rw [poissonPenalty_of_le A h] |
| apply mul_nonneg hA |
| nlinarith |
| · rw [poissonPenalty_of_ge A (le_of_not_ge h)] |
| exact hA |
|
|
| lemma poissonPenalty_le_linear {A t : ℝ} (hA : 0 ≤ A) (ht : 0 ≤ t) : |
| poissonPenalty A t ≤ 2 * A * t := by |
| by_cases h : t ≤ 1 |
| · rw [poissonPenalty_of_le A h] |
| nlinarith [mul_nonneg hA (sq_nonneg t)] |
| · rw [poissonPenalty_of_ge A (le_of_not_ge h)] |
| nlinarith |
|
|
| lemma poisson_maximum {n : ℕ} {f : Space n → ℝ} (hf : Continuous f) |
| {M A ε : ℝ} (hM : 0 ≤ M) (hbound : ∀ x, |f x| ≤ M) |
| (hA : 0 ≤ A) (hε : 0 < ε) : |
| ∃ x y : Space n, ∀ a b : Space n, |
| f b - f a - poissonPenalty A ‖b - a‖ - ε * (‖a‖ ^ 2 + ‖b‖ ^ 2) ≤ |
| f y - f x - poissonPenalty A ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2) := by |
| let H : Space n × Space n → ℝ := fun z => |
| f z.2 - f z.1 - poissonPenalty A ‖z.2 - z.1‖ - ε * (‖z.1‖ ^ 2 + ‖z.2‖ ^ 2) |
| have hc : Continuous H := by dsimp [H, poissonPenalty]; fun_prop |
| let R := Real.sqrt (2 * M / ε + 1) |
| have hR : 0 ≤ R := Real.sqrt_nonneg _ |
| have hR2 : R ^ 2 = 2 * M / ε + 1 := Real.sq_sqrt (by positivity) |
| have hevent : ∀ᶠ z in cocompact (Space n × Space n), H z ≤ H (0, 0) := by |
| filter_upwards [((isCompact_closedBall (0 : Space n) R).prod |
| (isCompact_closedBall (0 : Space n) R)).compl_mem_cocompact] with z hz |
| have hz' : R < ‖z.1‖ ∨ R < ‖z.2‖ := by |
| simpa only [Set.mem_compl_iff, Set.mem_prod, Metric.mem_closedBall, dist_zero_right, |
| not_and_or, not_le] using hz |
| have hsq : R ^ 2 < ‖z.1‖ ^ 2 + ‖z.2‖ ^ 2 := by |
| rcases hz' with hz' | hz' |
| · nlinarith [sq_nonneg ‖z.2‖, norm_nonneg z.1] |
| · nlinarith [sq_nonneg ‖z.1‖, norm_nonneg z.2] |
| have heq : ε * (2 * M / ε + 1) = 2 * M + ε := by field_simp |
| have hh := mul_lt_mul_of_pos_left hsq hε |
| have hb1 := (abs_le.mp (hbound z.1)).1 |
| have hb2 := (abs_le.mp (hbound z.2)).2 |
| have hcost := poissonPenalty_nonneg hA (norm_nonneg (z.2 - z.1)) |
| dsimp [H] |
| simp only [sub_self, norm_zero, poissonPenalty, sub_zero, max_eq_left zero_le_one, |
| one_pow, mul_zero, zero_pow two_ne_zero, add_zero] |
| rw [hR2, heq] at hh |
| dsimp [poissonPenalty] at hcost |
| linarith |
| obtain ⟨⟨x, y⟩, hmax⟩ := hc.exists_forall_ge' (0, 0) hevent |
| exact ⟨x, y, fun a b => hmax (a, b)⟩ |
|
|
| lemma coordDeriv_affine {n : ℕ} (a : Space n) (c : ℝ) (i : Fin n) (x : Space n) : |
| coordDeriv (fun z => c + inner ℝ a z) i x = inner ℝ a (basis n i) := by |
| have hd : HasFDerivAt (fun z => c + inner ℝ a z) (innerSL ℝ a) x := |
| (innerSL ℝ a).hasFDerivAt.const_add c |
| simp [coordDeriv, hd.fderiv] |
|
|
| lemma laplacian_affine {n : ℕ} (a : Space n) (c : ℝ) (x : Space n) : |
| Laplacian.laplacian (fun z => c + inner ℝ a z) x = 0 := by |
| have hc : ContDiff ℝ 2 (fun z : Space n => c + inner ℝ a z) := contDiff_const.add ((innerSL ℝ a).contDiff) |
| rw [laplacian_eq_sum_coordDeriv hc] |
| have he (i : Fin n) : coordDeriv (fun z : Space n => c + inner ℝ a z) i = |
| fun _ => inner ℝ a (basis n i) := funext (coordDeriv_affine a c i) |
| simp_rw [he] |
| simp [coordDeriv] |
|
|
| lemma laplacian_affine_sq {n : ℕ} (a : Space n) (c : ℝ) (x : Space n) : |
| Laplacian.laplacian (fun z => (c + inner ℝ a z) ^ 2) x = 2 * ‖a‖ ^ 2 := by |
| have hc : ContDiff ℝ 2 (fun z : Space n => (c + inner ℝ a z) ^ 2) := |
| (contDiff_const.add ((innerSL ℝ a).contDiff)).pow 2 |
| rw [laplacian_eq_sum_coordDeriv hc] |
| have hfirst (i : Fin n) : coordDeriv (fun z : Space n => (c + inner ℝ a z) ^ 2) i = |
| fun z => 2 * (c + inner ℝ a z) * inner ℝ a (basis n i) := by |
| funext z |
| have hd := ((innerSL ℝ a).hasFDerivAt (x := z)).const_add c |
| have hd2 := hd.pow 2 |
| dsimp only [coordDeriv] |
| change (fderiv ℝ (fun z => (c + (innerSL ℝ a) z) ^ 2) z) _ = _ |
| rw [hd2.fderiv] |
| simp only [smul_apply, smul_eq_mul, Nat.cast_ofNat, Nat.reduceSub, pow_one, innerSL_apply_apply, nsmul_eq_mul] |
| simp_rw [hfirst] |
| have hsecond (i : Fin n) : coordDeriv |
| (fun z => 2 * (c + inner ℝ a z) * inner ℝ a (basis n i)) i x = |
| 2 * (inner ℝ a (basis n i)) ^ 2 := by |
| have hd := ((((innerSL ℝ a).hasFDerivAt (x := x)).const_add c).const_mul 2).mul_const |
| (inner ℝ a (basis n i)) |
| dsimp only [coordDeriv] |
| change (fderiv ℝ (fun z => 2 * (c + (innerSL ℝ a) z) * inner ℝ a ((basis n) i)) x) _ = _ |
| rw [hd.fderiv] |
| simp [pow_two, mul_left_comm] |
| simp_rw [hsecond] |
| rw [← Finset.mul_sum] |
| congr 1 |
| have hb := (basis n).sum_inner_mul_inner a a |
| simpa only [real_inner_comm, ← pow_two, real_inner_self_eq_norm_sq] using hb |
|
|
| end RegularitySupport.DeGiorgi |
| end |
|
|
| end OAI |
|
|
