| import OAI.Analysis.AllenCahn.Basic |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace DeGiorgi |
| open MeasureTheory |
| open scoped ENNReal |
| open Filter Topology |
|
|
| lemma two_point_gradient_bounds {n : ℕ} {f : Space n → ℝ} |
| (hf : Differentiable ℝ f) {M L ε : ℝ} (hM : 0 ≤ M) |
| (hbound : ∀ x, |f x| ≤ M) (hL : 0 ≤ L) (hε : 0 < ε) {x y : Space n} |
| (hpos : 0 < f y - f x - L * ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2)) |
| (hm : ∀ a b : Space n, |
| f b - f a - L * ‖b - a‖ - ε * (‖a‖ ^ 2 + ‖b‖ ^ 2) ≤ |
| f y - f x - L * ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2)) : |
| let E := 2 * Real.sqrt (2 * M * ε) |
| |‖gradient f x‖ ^ 2 - L ^ 2| ≤ E * (2 * L + E) ∧ |
| |‖gradient f y‖ ^ 2 - L ^ 2| ≤ E * (2 * L + E) := by |
| have hxy : y ≠ x := by |
| rintro rfl |
| simp only [sub_self, norm_zero, mul_zero] at hpos |
| nlinarith [sq_nonneg ‖y‖] |
| have hpen : ε * (‖x‖ ^ 2 + ‖y‖ ^ 2) ≤ 2 * M := by |
| have hx := (abs_le.mp (hbound x)).1 |
| have hy := (abs_le.mp (hbound y)).2 |
| have hz := mul_nonneg hL (norm_nonneg (y - x)) |
| linarith |
| let E := 2 * Real.sqrt (2 * M * ε) |
| have hE : 0 ≤ E := by dsimp [E]; positivity |
| have hsmall : ∀ z : Space n, ε * ‖z‖ ^ 2 ≤ 2 * M → ‖(2 * ε) • z‖ ≤ E := by |
| intro z hz |
| rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity : 0 ≤ 2 * ε)] |
| have hs := Real.sq_sqrt (show 0 ≤ 2 * M * ε by positivity) |
| have hc := mul_le_mul_of_nonneg_right hz hε.le |
| dsimp [E] |
| nlinarith [Real.sqrt_nonneg (2 * M * ε), norm_nonneg z] |
| have hxsmall := hsmall x (by nlinarith [mul_nonneg hε.le (sq_nonneg ‖y‖)]) |
| have hysmall := hsmall y (by nlinarith [mul_nonneg hε.le (sq_nonneg ‖x‖)]) |
| let p : Space n := (L / ‖y - x‖) • (y - x) |
| have hp : ‖p‖ = L := by |
| dsimp [p] |
| rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (div_nonneg hL (norm_nonneg _)), |
| div_mul_cancel₀ L (norm_ne_zero_iff.mpr (sub_ne_zero.mpr hxy))] |
| have hgy := gradient_at_two_point_max_y hf L ε hxy (hm x) |
| have hnegmax : ∀ a b : Space n, |
| -f b - -f a - L * ‖b - a‖ - ε * (‖a‖ ^ 2 + ‖b‖ ^ 2) ≤ |
| -f x - -f y - L * ‖x - y‖ - ε * (‖y‖ ^ 2 + ‖x‖ ^ 2) := by |
| intro a b |
| simpa only [neg_sub_neg, norm_sub_rev, add_comm] using hm b a |
| have hgx := gradient_at_two_point_max_y hf.neg L ε (Ne.symm hxy) (hnegmax y) |
| have hng : gradient (fun z => -f z) x = -gradient f x := by |
| simp only [gradient, fderiv_fun_neg, map_neg] |
| change gradient (fun z => -f z) x = _ at hgx |
| rw [hng] at hgx |
| have hxerr : ‖gradient f x - p‖ ≤ E := by |
| have hvec : gradient f x - p = -(2 * ε) • x := by |
| rw [norm_sub_rev] at hgx |
| have hs : (L / ‖y - x‖) • (x - y) = -p := by |
| dsimp [p] |
| rw [← neg_sub y x, smul_neg] |
| rw [hs] at hgx |
| have hh := congrArg (fun z : Space n => -z) hgx |
| simp only [neg_neg] at hh |
| rw [hh] |
| module |
| rw [hvec, neg_smul, norm_neg] |
| exact hxsmall |
| have hyerr : ‖gradient f y - p‖ ≤ E := by |
| change gradient f y = p + (2 * ε) • y at hgy |
| rw [hgy, add_sub_cancel_left] |
| exact hysmall |
| exact ⟨sq_norm_error hL hE hp hxerr, sq_norm_error hL hE hp hyerr⟩ |
|
|
| lemma lipschitz_of_laplacian_monotonicity {n : ℕ} {f b h : Space n → ℝ} |
| (hf : ContDiff ℝ 2 f) {M B L κ : ℝ} (hM : 0 ≤ M) (hB : 0 ≤ B) |
| (hL : 0 ≤ L) (hκ : 0 < κ) (hbound : ∀ x, |f x| ≤ M) |
| (hb : ∀ x, |b x| ≤ B) |
| (hpde : ∀ x, Laplacian.laplacian f x = b x * ‖gradient f x‖ ^ 2 + h x) |
| (hmono : ∀ x y, f x ≤ f y → κ * (f y - f x) ≤ |
| (b y * L ^ 2 + h y) - (b x * L ^ 2 + h x)) : |
| ∀ x y, f y - f x ≤ L * ‖y - x‖ := by |
| intro a c |
| by_contra hn |
| let δ := f c - f a - L * ‖c - a‖ |
| have hδ : 0 < δ := sub_pos.mpr (lt_of_not_ge hn) |
| let E : ℝ → ℝ := fun t => 2 * Real.sqrt (2 * M * t) |
| have hcont : Continuous (fun t : ℝ => 4 * n * t + 2 * B * (E t * (2 * L + E t))) := by |
| dsimp [E] |
| fun_prop |
| have hev : ∀ᶠ t in 𝓝 (0 : ℝ), |
| 4 * n * t + 2 * B * (E t * (2 * L + E t)) < κ * δ / 2 := by |
| have hzero : (fun t : ℝ => 4 * n * t + 2 * B * (E t * (2 * L + E t))) 0 = 0 := by |
| simp [E] |
| exact (hcont.continuousAt.eventually_lt continuousAt_const (by simpa only [E, mul_zero, Real.sqrt_zero, zero_mul, add_zero] using (show 0 < κ * δ / 2 by positivity))) |
| have hcont2 : Continuous (fun t : ℝ => t * (‖a‖ ^ 2 + ‖c‖ ^ 2)) := by fun_prop |
| have hev2 : ∀ᶠ t in 𝓝 (0 : ℝ), t * (‖a‖ ^ 2 + ‖c‖ ^ 2) < δ / 2 := |
| hcont2.continuousAt.eventually_lt continuousAt_const (by simpa using half_pos hδ) |
| have hex : ∃ ε : ℝ, 0 < ε ∧ ε * (‖a‖ ^ 2 + ‖c‖ ^ 2) < δ / 2 ∧ |
| 4 * n * ε + 2 * B * (E ε * (2 * L + E ε)) < κ * δ / 2 := by |
| have hevent : ∀ᶠ t in 𝓝[>] (0 : ℝ), 0 < t ∧ |
| t * (‖a‖ ^ 2 + ‖c‖ ^ 2) < δ / 2 ∧ |
| 4 * n * t + 2 * B * (E t * (2 * L + E t)) < κ * δ / 2 := by |
| filter_upwards [self_mem_nhdsWithin, hev2.filter_mono nhdsWithin_le_nhds, |
| hev.filter_mono nhdsWithin_le_nhds] with t ht h1 h2 using ⟨ht, h1, h2⟩ |
| exact hevent.exists |
| obtain ⟨ε, hε, hseed, herr⟩ := hex |
| obtain ⟨x, y, hm⟩ := two_point_maximum hf.continuous hM hbound hL hε |
| have hval : δ / 2 < f y - f x - L * ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2) := by |
| have hh := hm a c |
| dsimp [δ] at hseed ⊢ |
| linarith |
| have hfd : δ / 2 < f y - f x := by |
| have hh := mul_nonneg hL (norm_nonneg (y - x)) |
| have hh' := mul_nonneg hε.le (add_nonneg (sq_nonneg ‖x‖) (sq_nonneg ‖y‖)) |
| linarith |
| have hxy : f x ≤ f y := by linarith |
| have hgap := hmono x y hxy |
| have hgrad := two_point_gradient_bounds (hf.differentiable (by norm_num)) hM hbound hL hε |
| (lt_trans (half_pos hδ) hval) hm |
| have hE : 0 ≤ E ε := by dsimp [E]; positivity |
| have herror (z : Space n) (hz : |‖gradient f z‖ ^ 2 - L ^ 2| ≤ E ε * (2 * L + E ε)) : |
| |b z * (‖gradient f z‖ ^ 2 - L ^ 2)| ≤ B * (E ε * (2 * L + E ε)) := by |
| rw [abs_mul] |
| exact mul_le_mul (hb z) hz (abs_nonneg _) hB |
| have hx := abs_le.mp (herror x hgrad.1) |
| have hy := abs_le.mp (herror y hgrad.2) |
| have hlap := laplacian_at_two_point_max hf L ε hm |
| rw [hpde y, hpde x] at hlap |
| have hstrict := mul_lt_mul_of_pos_left hfd hκ |
| nlinarith |
|
|
| def defectWeight {n : ℕ} (v : Space n → ℝ) (x : Space n) : ℝ := 1 - v x ^ 2 |
|
|
| lemma hasDerivAt_artanh {t : ℝ} (ht : t ∈ Set.Ioo (-1 : ℝ) 1) : |
| HasDerivAt Real.artanh (1 / (1 - t ^ 2)) t := by |
| have hm : 1 - t ≠ 0 := ne_of_gt (sub_pos.mpr ht.2) |
| have hp : 1 + t ≠ 0 := ne_of_gt (by linarith [ht.1]) |
| have hd : HasDerivAt (fun y : ℝ => (1 + y) / (1 - y)) |
| ((1 * (1 - t) - (1 + t) * (-1)) / (1 - t) ^ 2) t := |
| ((hasDerivAt_id t).const_add 1).div ((hasDerivAt_id t).const_sub 1) hm |
| have heq : 1 / 2 * (((1 * (1 - t) - (1 + t) * (-1)) / (1 - t) ^ 2) / |
| ((1 + t) / (1 - t))) = 1 / (1 - t ^ 2) := by |
| have hs : 1 - t ^ 2 = (1 - t) * (1 + t) := by ring |
| rw [hs] |
| field_simp |
| ring |
| have hh := (hd.log (div_ne_zero hp hm)).const_mul (1 / 2 : ℝ) |
| rw [heq] at hh |
| apply hh.congr_of_eventuallyEq |
| filter_upwards [isOpen_Ioo.mem_nhds ht] with y hy |
| exact Real.artanh_eq_half_log ⟨hy.1.le, hy.2.le⟩ |
|
|
| def inverseProfile {n : ℕ} (v : Space n → ℝ) (x : Space n) : ℝ := |
| Real.sqrt 2 * Real.artanh (v x) |
|
|
| def diffuseDefect {n : ℕ} (v : Space n → ℝ) (x : Space n) : ℝ := |
| 1 - ‖gradient (inverseProfile v) x‖ ^ 2 |
|
|
| lemma profile_inverseProfile {n : ℕ} {v : Space n → ℝ} |
| (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (x : Space n) : |
| profile (inverseProfile v x) = v x := by |
| have h2 : Real.sqrt 2 ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (by norm_num)) |
| simp only [profile, inverseProfile, mul_div_cancel_left₀ _ h2] |
| exact Real.tanh_artanh (hi x) |
|
|
| lemma fderiv_inverseProfile {n : ℕ} {v : Space n → ℝ} {x : Space n} |
| (hv : DifferentiableAt ℝ v x) (hi : v x ∈ Set.Ioo (-1 : ℝ) 1) : |
| fderiv ℝ (inverseProfile v) x = |
| (Real.sqrt 2 / defectWeight v x) • fderiv ℝ v x := by |
| have H := ((hasDerivAt_artanh hi).comp_hasFDerivAt x hv.hasFDerivAt).const_mul (Real.sqrt 2) |
| change fderiv ℝ (fun y => Real.sqrt 2 * Real.artanh (v y)) x = _ |
| simpa only [Function.comp_apply, smul_smul, mul_one_div, defectWeight] |
| using H.fderiv |
|
|
| lemma gradient_inverseProfile {n : ℕ} {v : Space n → ℝ} {x : Space n} |
| (hv : DifferentiableAt ℝ v x) (hi : v x ∈ Set.Ioo (-1 : ℝ) 1) : |
| gradient (inverseProfile v) x = (Real.sqrt 2 / defectWeight v x) • gradient v x := by |
| simp only [gradient, fderiv_inverseProfile hv hi, map_smul] |
|
|
| lemma inverseProfile_contDiff {n : ℕ} {v : Space n → ℝ} (hv : ContDiff ℝ 2 v) |
| (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) : ContDiff ℝ 2 (inverseProfile v) := by |
| have hm (x : Space n) : 1 - v x ≠ 0 := ne_of_gt (sub_pos.mpr (hi x).2) |
| have hp (x : Space n) : 1 + v x ≠ 0 := ne_of_gt (by linarith [(hi x).1]) |
| have hq : ContDiff ℝ 2 (fun x => (1 + v x) / (1 - v x)) := |
| (contDiff_const.add hv).div (contDiff_const.sub hv) hm |
| have hl : ContDiff ℝ 2 (fun x => (Real.sqrt 2 / 2) * Real.log ((1 + v x) / (1 - v x))) := |
| contDiff_const.mul (hq.log (fun x => div_ne_zero (hp x) (hm x))) |
| convert hl using 1 |
| funext x |
| dsimp [inverseProfile] |
| rw [Real.artanh_eq_half_log ⟨(hi x).1.le, (hi x).2.le⟩] |
| ring |
|
|
| lemma gradient_norm_sq {n : ℕ} (f : Space n → ℝ) (x : Space n) : |
| ‖gradient f x‖ ^ 2 = ∑ i : Fin n, (coordDeriv f i x) ^ 2 := by |
| have h := (basis n).sum_inner_mul_inner (gradient f x) (gradient f x) |
| rw [real_inner_self_eq_norm_sq] at h |
| simpa only [coordDeriv, real_inner_comm, inner_gradient_left, ← pow_two] using h.symm |
|
|
| lemma coordDeriv_mul {n : ℕ} {f g : Space n → ℝ} |
| (hf : Differentiable ℝ f) (hg : Differentiable ℝ g) (i : Fin n) (x : Space n) : |
| coordDeriv (fun y => f y * g y) i x = |
| f x * coordDeriv g i x + g x * coordDeriv f i x := by |
| simp [coordDeriv, fderiv_fun_mul (hf x) (hg x)] |
|
|
| lemma weight_pos {t : ℝ} (ht : t ∈ Set.Ioo (-1 : ℝ) 1) : 0 < 1 - t ^ 2 := by |
| nlinarith [mul_pos (sub_pos.mpr ht.2) (show 0 < 1 + t by linarith [ht.1])] |
|
|
| lemma coordDeriv_inverseProfile_coefficient {n : ℕ} {v : Space n → ℝ} |
| (hv : Differentiable ℝ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) |
| (i : Fin n) (x : Space n) : |
| coordDeriv (fun y => Real.sqrt 2 / defectWeight v y) i x = |
| (2 * Real.sqrt 2 * v x / (defectWeight v x) ^ 2) * coordDeriv v i x := by |
| have hs : HasDerivAt (fun t : ℝ => Real.sqrt 2 / (1 - t ^ 2)) |
| (2 * Real.sqrt 2 * v x / (1 - v x ^ 2) ^ 2) (v x) := by |
| convert (hasDerivAt_const (v x) (Real.sqrt 2)).div |
| ((hasDerivAt_const (v x) (1 : ℝ)).sub ((hasDerivAt_id (v x)).pow 2)) |
| (ne_of_gt (weight_pos (hi x))) using 1 <;> first | rfl | (dsimp; ring) |
| have hd := hs.comp_hasFDerivAt x (hv x).hasFDerivAt |
| dsimp [coordDeriv, defectWeight] |
| simpa only [Function.comp_def, smul_apply, smul_eq_mul] using |
| congrArg (fun L : Space n →L[ℝ] ℝ => L (basis n i)) hd.fderiv |
|
|
| lemma laplacian_inverseProfile {n : ℕ} {v : Space n → ℝ} |
| (hv : ContDiff ℝ 2 v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (x : Space n) : |
| Laplacian.laplacian (inverseProfile v) x = |
| Real.sqrt 2 / defectWeight v x * Laplacian.laplacian v x + |
| (2 * Real.sqrt 2 * v x / defectWeight v x ^ 2) * ‖gradient v x‖ ^ 2 := by |
| have hd := hv.differentiable (by norm_num) |
| have hc : Differentiable ℝ (fun y => Real.sqrt 2 / defectWeight v y) := by |
| have H : ContDiff ℝ 2 (fun y => Real.sqrt 2 / (1 - v y ^ 2)) := |
| contDiff_const.div (contDiff_const.sub (hv.pow 2)) (fun y => ne_of_gt (weight_pos (hi y))) |
| exact H.differentiable (by norm_num) |
| have hfirst (i : Fin n) : coordDeriv (inverseProfile v) i = |
| fun y => (Real.sqrt 2 / defectWeight v y) * coordDeriv v i y := by |
| funext y |
| simp [coordDeriv, fderiv_inverseProfile (hd y) (hi y)] |
| rw [laplacian_eq_sum_coordDeriv (inverseProfile_contDiff hv hi)] |
| simp_rw [hfirst] |
| simp_rw [coordDeriv_mul hc ((coordDeriv_contDiff hv _).differentiable (by norm_num)), |
| coordDeriv_inverseProfile_coefficient hd hi] |
| rw [laplacian_eq_sum_coordDeriv hv, gradient_norm_sq, Finset.sum_add_distrib, |
| ← Finset.mul_sum] |
| congr 1 |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro i _ |
| ring |
|
|
| lemma laplacian_regularized_inverse {n : ℕ} {v : Space n → ℝ} |
| (hv : ContDiff ℝ 2 v) (hb : ∀ x, v x ∈ Set.Icc (-1 : ℝ) 1) |
| (hAC : AllenCahn v) {r : ℝ} (hr : 0 < r) (hr1 : r < 1) (x : Space n) : |
| let t := r * v x |
| Laplacian.laplacian (inverseProfile (fun y => r * v y)) x = |
| Real.sqrt 2 * t * ‖gradient (inverseProfile (fun y => r * v y)) x‖ ^ 2 + |
| (-Real.sqrt 2 * t + Real.sqrt 2 * (1 - r ^ 2) / r ^ 2 * (t ^ 3 / (1 - t ^ 2))) := by |
| have hreg : ContDiff ℝ 2 (fun y => r * v y) := contDiff_const.mul hv |
| have hi (y : Space n) : r * v y ∈ Set.Ioo (-1 : ℝ) 1 := by |
| have H := mul_le_mul_of_nonneg_left (hb y).1 hr.le |
| have H' := mul_le_mul_of_nonneg_left (hb y).2 hr.le |
| constructor <;> nlinarith |
| have hq : 1 - (r * v x) ^ 2 ≠ 0 := ne_of_gt (weight_pos (hi x)) |
| dsimp only |
| rw [laplacian_inverseProfile hreg hi, laplacian_fun_const_mul hv, |
| hAC, gradient_inverseProfile (hreg.differentiable (by norm_num) x) (hi x), |
| norm_smul, Real.norm_eq_abs, mul_pow, sq_abs, |
| div_pow, Real.sq_sqrt (by norm_num)] |
| have hg : gradient (fun y => r * v y) x = r • gradient v x := by |
| simp [gradient, fderiv_const_mul (hv.differentiable (by norm_num) x)] |
| rw [hg, norm_smul, Real.norm_eq_abs, mul_pow, sq_abs] |
| dsimp [defectWeight] |
| have hqq : 1 - r ^ 2 * v x ^ 2 ≠ 0 := by simpa only [mul_pow] using hq |
| field_simp [ne_of_gt hr, hq, hqq] |
| ring |
|
|
| lemma cube_div_weight_monotone : |
| MonotoneOn (fun t : ℝ => t ^ 3 / (1 - t ^ 2)) (Set.Ioo (-1 : ℝ) 1) := by |
| have hd (t : ℝ) (ht : t ∈ Set.Ioo (-1 : ℝ) 1) : |
| HasDerivAt (fun t : ℝ => t ^ 3 / (1 - t ^ 2)) |
| (t ^ 2 * (3 - t ^ 2) / (1 - t ^ 2) ^ 2) t := by |
| convert ((hasDerivAt_id t).pow 3).div |
| ((hasDerivAt_const t (1 : ℝ)).sub ((hasDerivAt_id t).pow 2)) |
| (ne_of_gt (weight_pos ht)) using 1 <;> first | rfl | (dsimp; ring) |
| apply monotoneOn_of_deriv_nonneg (convex_Ioo (-1 : ℝ) 1) |
| (fun t ht => (hd t ht).continuousAt.continuousWithinAt) |
| · intro t ht |
| exact (hd t (by simpa only [interior_Ioo] using ht)).differentiableAt.differentiableWithinAt |
| · intro t ht |
| have hi : t ∈ Set.Ioo (-1 : ℝ) 1 := by simpa only [interior_Ioo] using ht |
| rw [(hd t hi).deriv] |
| exact div_nonneg (mul_nonneg (sq_nonneg _) (by linarith [weight_pos hi])) (sq_nonneg _) |
|
|
| lemma inverseProfile_scalar_quantitative {r s t : ℝ} (hr : 0 < r) (hr1 : r < 1) |
| (hs : s ∈ Set.Icc (-r) r) (ht : t ∈ Set.Icc (-r) r) (hst : s ≤ t) : |
| (1 - r ^ 2) * (Real.sqrt 2 * Real.artanh t - Real.sqrt 2 * Real.artanh s) ≤ |
| Real.sqrt 2 * (t - s) := by |
| have hir : r ∈ Set.Ioo (-1 : ℝ) 1 := ⟨by linarith, hr1⟩ |
| have hqr := weight_pos hir |
| have hi (z : ℝ) (hz : z ∈ Set.Icc (-r) r) : z ∈ Set.Ioo (-1 : ℝ) 1 := |
| ⟨by linarith [hz.1], by linarith [hz.2]⟩ |
| have hd (z : ℝ) (hz : z ∈ Set.Icc (-r) r) : |
| HasDerivAt (fun t => Real.sqrt 2 * Real.artanh t) (Real.sqrt 2 / (1 - z ^ 2)) z := by |
| simpa only [mul_one_div] using (hasDerivAt_artanh (hi z hz)).const_mul (Real.sqrt 2) |
| have hbound (z : ℝ) (hz : z ∈ Set.Icc (-r) r) : |
| deriv (fun t => Real.sqrt 2 * Real.artanh t) z ≤ Real.sqrt 2 / (1 - r ^ 2) := by |
| rw [(hd z hz).deriv] |
| have hsq : z ^ 2 ≤ r ^ 2 := by |
| nlinarith [mul_nonneg (sub_nonneg.mpr hz.2) (show 0 ≤ z + r by linarith [hz.1])] |
| exact div_le_div_of_nonneg_left (Real.sqrt_nonneg _) hqr (by linarith) |
| have H := (convex_Icc (-r) r).image_sub_le_mul_sub_of_deriv_le |
| (fun z hz => (hd z hz).continuousAt.continuousWithinAt) |
| (fun z hz => (hd z (interior_subset hz)).differentiableAt.differentiableWithinAt) |
| (fun z hz => hbound z (interior_subset hz)) s hs t ht hst |
| have H' := mul_le_mul_of_nonneg_left H hqr.le |
| calc |
| _ ≤ (1 - r ^ 2) * (Real.sqrt 2 / (1 - r ^ 2) * (t - s)) := H' |
| _ = _ := by field_simp |
|
|
| lemma inverseProfile_scalar_bound {r t : ℝ} (hr : 0 < r) (hr1 : r < 1) |
| (ht : t ∈ Set.Icc (-r) r) : |
| |Real.sqrt 2 * Real.artanh t| ≤ Real.sqrt 2 * |
| max |Real.artanh (-r)| |Real.artanh r| := by |
| have hm : -r ∈ Set.Ioo (-1 : ℝ) 1 := ⟨by linarith, by linarith⟩ |
| have hp : r ∈ Set.Ioo (-1 : ℝ) 1 := ⟨by linarith, hr1⟩ |
| have hi : t ∈ Set.Ioo (-1 : ℝ) 1 := ⟨by linarith [ht.1], by linarith [ht.2]⟩ |
| rw [abs_mul, abs_of_nonneg (Real.sqrt_nonneg _)] |
| apply mul_le_mul_of_nonneg_left _ (Real.sqrt_nonneg _) |
| apply abs_le.mpr |
| constructor |
| · have H := Real.strictMonoOn_artanh.monotoneOn hm hi ht.1 |
| have H' := neg_abs_le (Real.artanh (-r)) |
| have H'' := le_max_left |Real.artanh (-r)| |Real.artanh r| |
| linarith |
| · exact (Real.strictMonoOn_artanh.monotoneOn hi hp ht.2).trans |
| ((le_abs_self _).trans (le_max_right _ _)) |
|
|
| end DeGiorgi |
| end |
|
|
| end OAI |
|
|
