math / data /lean /OAI /Analysis /AllenCahn /NormalizedJets.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
17.1 kB
import OAI.Analysis.AllenCahn.HessianControl
namespace OAI
noncomputable section
namespace DeGiorgi
open scoped ContDiff
def defectRoot {n : β„•} (v : Space n β†’ ℝ) (x : Space n) : ℝ :=
Real.exp ((1 / 2 : ℝ) * Real.log (diffuseDefect v x))
lemma defectRoot_pos {n : β„•} (v : Space n β†’ ℝ) (x : Space n) : 0 < defectRoot v x :=
Real.exp_pos _
lemma defectRoot_sq {n : β„•} {v : Space n β†’ ℝ} {x : Space n}
(hp : 0 < diffuseDefect v x) : defectRoot v x ^ 2 = diffuseDefect v x := by
rw [defectRoot, pow_two, ← Real.exp_add]
convert Real.exp_log hp using 1; congr 1; ring
lemma defectRoot_eq_sqrt {n : β„•} {v : Space n β†’ ℝ} {x : Space n}
(hp : 0 < diffuseDefect v x) : defectRoot v x = Real.sqrt (diffuseDefect v x) := by
nlinarith [defectRoot_pos v x, Real.sqrt_nonneg (diffuseDefect v x),
Real.sq_sqrt hp.le, defectRoot_sq hp]
lemma defectRoot_smooth {n : β„•} {v : Space n β†’ ℝ}
(hv : ContDiff ℝ ∞ v) (hi : βˆ€ x, v x ∈ Set.Ioo (-1 : ℝ) 1)
(hp : βˆ€ x, 0 < diffuseDefect v x) : ContDiff ℝ ∞ (defectRoot v) :=
(contDiff_const.mul ((diffuseDefect_smooth hv hi).log (fun x => (hp x).ne'))).exp
lemma defectRoot_gradient {n : β„•} {v : Space n β†’ ℝ}
(hv : ContDiff ℝ ∞ v) (hi : βˆ€ x, v x ∈ Set.Ioo (-1 : ℝ) 1)
(hp : βˆ€ x, 0 < diffuseDefect v x) (x : Space n) :
gradient (defectRoot v) x = ((1 / 2 : ℝ) * defectRoot v x) β€’
gradient (fun y => Real.log (diffuseDefect v y)) x := by
have hh := ((diffuseDefect_smooth hv hi).log fun x => (hp x).ne').differentiable (by simp)
change gradient (fun y => Real.exp ((1/2 : ℝ) * Real.log (diffuseDefect v y))) x = _
simp only [gradient, defectRoot,
fderiv_exp ((differentiable_const (1/2 : ℝ)).fun_mul hh x),
fderiv_const_mul (hh x), map_smul, smul_smul]
congr 1
ring
lemma defectRoot_drift {n : β„•} {v : Space n β†’ ℝ}
(hv : ContDiff ℝ ∞ v) (hi : βˆ€ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
(hp : βˆ€ x, 0 < diffuseDefect v x) (x : Space n) :
Laplacian.laplacian (defectRoot v) x - fderiv ℝ (defectRoot v) x (diffuseDrift v x) =
defectRoot v x * ((1 / 2 : ℝ) * (defectSource v x / diffuseDefect v x) -
(1 / 4 : ℝ) * β€–gradient (fun y => Real.log (diffuseDefect v y)) xβ€– ^ 2) := by
let h := fun y => Real.log (diffuseDefect v y)
have hh : ContDiff ℝ ∞ h := (diffuseDefect_smooth hv hi).log (fun y => (hp y).ne')
have hd := hh.differentiable (by simp)
have hL := (positive_defect_log_bounds hv hi hAC hp).1 x
have hg : gradient (fun y => (1 / 2 : ℝ) * h y) x = (1 / 2 : ℝ) β€’ gradient h x := by
simp only [gradient, fderiv_const_mul (hd x), map_smul]
change Laplacian.laplacian (fun y => Real.exp ((1 / 2 : ℝ) * h y)) x - _ = _
rw [laplacian_exp (contDiff_const.mul (smooth_C2 hh)), laplacian_fun_const_mul (smooth_C2 hh),
hg, norm_smul, Real.norm_eq_abs, abs_of_pos (by norm_num : (0 : ℝ) < 1/2)]
change _ - fderiv ℝ (fun y => Real.exp ((1 / 2 : ℝ) * h y)) x (diffuseDrift v x) = _
rw [fderiv_exp ((differentiable_const (1/2 : ℝ)).fun_mul hd x),
fderiv_const_mul (hd x), smul_apply, smul_apply, smul_eq_mul, smul_eq_mul]
dsimp only [h] at hL
change _ = Real.exp ((1 / 2 : ℝ) * h x) * _
dsimp only [h] at *
rw [sub_eq_iff_eq_add.mp hL]
ring
lemma defectRoot_bounds {n : β„•} {v : Space n β†’ ℝ}
(hv : ContDiff ℝ ∞ v) (hi : βˆ€ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
(hp : βˆ€ x, 0 < diffuseDefect v x) (x : Space n) :
β€–gradient (defectRoot v) xβ€– ≀ relativeDefectConstant n * defectRoot v x ∧
|Laplacian.laplacian (defectRoot v) x - fderiv ℝ (defectRoot v) x (diffuseDrift v x)| ≀
(defectSourceConstant n + relativeDefectConstant n ^ 2) * defectRoot v x := by
have hb := positive_defect_log_bounds hv hi hAC hp
have hC := relativeDefectConstant_pos n
have hS := defectSourceConstant_pos n
have hr : |defectSource v x / diffuseDefect v x| ≀ defectSourceConstant n := by
rw [abs_div, abs_of_pos (hp x)]
exact (div_le_iffβ‚€ (hp x)).mpr ((defectSource_bounds hv hi hAC).1 x)
constructor
Β· rw [defectRoot_gradient hv hi hp, norm_smul, Real.norm_eq_abs,
abs_of_pos (mul_pos (by norm_num) (defectRoot_pos v x))]
have H := mul_le_mul_of_nonneg_left (hb.2.1 x) (defectRoot_pos v x).le
nlinarith [mul_nonneg (defectRoot_pos v x).le
(norm_nonneg (gradient (fun y => Real.log (diffuseDefect v y)) x))]
Β· rw [defectRoot_drift hv hi hAC hp, abs_mul, abs_of_pos (defectRoot_pos v x)]
have H := abs_sub ((1/2 : ℝ) * (defectSource v x / diffuseDefect v x))
((1/4 : ℝ) * β€–gradient (fun y => Real.log (diffuseDefect v y)) xβ€– ^ 2)
have Hpos : 0 ≀ (1/4 : ℝ) * β€–gradient (fun y => Real.log (diffuseDefect v y)) xβ€– ^ 2 := by positivity
have He : |(1/2 : ℝ) * (defectSource v x / diffuseDefect v x)| =
(1/2 : ℝ) * |defectSource v x / diffuseDefect v x| := by rw [abs_mul]; norm_num
rw [He, abs_of_nonneg Hpos] at H
have Hg := (sq_le_sqβ‚€ (norm_nonneg _) hC.le).mpr (hb.2.1 x)
have hh : |(1/2 : ℝ) * (defectSource v x / diffuseDefect v x) -
(1/4 : ℝ) * β€–gradient (fun y => Real.log (diffuseDefect v y)) xβ€– ^ 2| ≀
defectSourceConstant n + relativeDefectConstant n ^ 2 := by nlinarith
nlinarith [defectRoot_pos v x]
lemma defectRoot_le_one {n : β„•} {v : Space n β†’ ℝ} (hp : βˆ€ x, 0 < diffuseDefect v x) (x : Space n) :
defectRoot v x ≀ 1 := by
nlinarith [defectRoot_sq (hp x), defectRoot_pos v x, diffuseDefect_le_one v x]
lemma normalized_tensor_square_bounds {n : β„•} {v : Space n β†’ ℝ}
(hv : ContDiff ℝ ∞ v) (hi : βˆ€ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
(hp : βˆ€ x, 0 < diffuseDefect v x) (x : Space n) :
Real.sqrt (hessianSquare v x) ≀ Real.sqrt (tensorBernsteinConstant n + 3) * defectRoot v x ∧
Real.sqrt (tensorDerivativeSquare v x) ≀ Real.sqrt (derivativeDefectConstant n) * defectRoot v x := by
have hB : 0 ≀ tensorBernsteinConstant n + 3 := by dsimp [tensorBernsteinConstant]; positivity
have he : Real.sqrt (diffuseDefect v x) = defectRoot v x := (defectRoot_eq_sqrt (hp x)).symm
constructor
Β· have H := Real.sqrt_le_sqrt (hessianSquare_le_defect hv hi hAC x)
rwa [Real.sqrt_mul hB, he] at H
Β· have H := Real.sqrt_le_sqrt (tensorDerivativeSquare_le_defect hv hi hAC x)
rwa [Real.sqrt_mul (derivativeDefectConstant_pos n).le, he] at H
def normalizedTensorSourceConstant (n : β„•) : ℝ :=
tensorCoeffConstant n * (1 + 6 * n) *
(1 + Real.sqrt (tensorBernsteinConstant n + 3) + Real.sqrt (derivativeDefectConstant n))
def normalizedTensorSecondConstant (n : β„•) : ℝ :=
2 * (2 * Real.sqrt (derivativeDefectConstant n) +
(normalizedTensorSourceConstant n + Real.sqrt (derivativeDefectConstant n) *
(defectSourceConstant n + relativeDefectConstant n ^ 2)) + 3) *
(2 * Real.sqrt 2 + 2 * relativeDefectConstant n + 1) +
Real.sqrt (derivativeDefectConstant n) * relativeDefectConstant n
lemma normalizedTensorSourceConstant_nonneg (n : β„•) : 0 ≀ normalizedTensorSourceConstant n := by
have hC := tensorCoeffConstant_pos n
dsimp [normalizedTensorSourceConstant]; positivity
lemma normalizedTensorSecondConstant_nonneg (n : β„•) : 0 ≀ normalizedTensorSecondConstant n := by
have hC := relativeDefectConstant_pos n
have hS := defectSourceConstant_pos n
have hT := normalizedTensorSourceConstant_nonneg n
dsimp [normalizedTensorSecondConstant]; positivity
theorem inverseHessian_second_relative {n : β„•} {v : Space n β†’ ℝ}
(hv : ContDiff ℝ ∞ v) (hi : βˆ€ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
(hp : βˆ€ x, 0 < diffuseDefect v x) (i j k : Fin n) (x : Space n) :
β€–gradient (coordDeriv (inverseHessian v i j) k) xβ€– ≀
normalizedTensorSecondConstant n * Real.sqrt (diffuseDefect v x) := by
have hb (y) := normalized_tensor_square_bounds hv hi hAC hp y
have hfb (y) : |coordDeriv (inverseHessian v i j) k y| ≀
Real.sqrt (derivativeDefectConstant n) * defectRoot v y :=
(inverseHessian_deriv_abs_le_sqrt v i j k y).trans (hb y).2
have hfL (y) : |Laplacian.laplacian (coordDeriv (inverseHessian v i j) k) y -
fderiv ℝ (coordDeriv (inverseHessian v i j) k) y (diffuseDrift v y)| ≀
normalizedTensorSourceConstant n * defectRoot v y := by
apply (inverseHessian_deriv_drift_bound hv hi hAC i j k y).trans
have hD : diffuseDefect v y ≀ defectRoot v y := by
nlinarith [defectRoot_sq (hp y), defectRoot_pos v y, defectRoot_le_one hp y]
have hsum := add_le_add (add_le_add hD (hb y).1) (hb y).2
have hC : 0 ≀ tensorCoeffConstant n * (1 + 6 * n) := by
have := tensorCoeffConstant_pos n; positivity
have H := mul_le_mul_of_nonneg_left hsum hC
dsimp [normalizedTensorSourceConstant]
nlinarith
have H := carrier_gradient_estimate
(smooth_C2 (coordDeriv_smooth (inverseHessian_smooth hv hi i j) k))
(smooth_C2 (defectRoot_smooth hv hi hp)) (defectRoot_pos v) (diffuseDrift v)
(Real.sqrt_nonneg (derivativeDefectConstant n)) (normalizedTensorSourceConstant_nonneg n)
(show 0 ≀ 2 * Real.sqrt 2 by positivity) (relativeDefectConstant_pos n).le
(add_nonneg (defectSourceConstant_pos n).le (sq_nonneg _))
hfb (diffuseDrift_bound (smooth_C2 hv) hi hAC)
(fun y => (defectRoot_bounds hv hi hAC hp y).1) hfL
(fun y => (defectRoot_bounds hv hi hAC hp y).2) x
rw [defectRoot_eq_sqrt (hp x)] at H
exact H
def coordinateJet {n : β„•} (f : Space n β†’ ℝ) : List (Fin n) β†’ Space n β†’ ℝ
| [] => f
| i :: l => coordDeriv (coordinateJet f l) i
lemma coordinateJet_smooth {n : β„•} {f : Space n β†’ ℝ}
(hf : ContDiff ℝ ∞ f) (l : List (Fin n)) : ContDiff ℝ ∞ (coordinateJet f l) := by
induction l with
| nil => exact hf
| cons i l ih => exact coordDeriv_smooth ih i
lemma coordinateJet_laplacian {n : β„•} {f : Space n β†’ ℝ}
(hf : ContDiff ℝ ∞ f) (l : List (Fin n)) :
Laplacian.laplacian (coordinateJet f l) = coordinateJet (Laplacian.laplacian f) l := by
induction l with
| nil => rfl
| cons i l ih =>
funext x
change Laplacian.laplacian (coordDeriv (coordinateJet f l) i) x = _
rw [laplacian_coordDeriv (coordinateJet_smooth hf l), ih]
rfl
def jetSplits {Ξ± : Type*} : List Ξ± β†’ List (List Ξ± Γ— List Ξ±)
| [] => [([], [])]
| i :: l => (jetSplits l).map (fun p => (i :: p.1, p.2)) ++
(jetSplits l).map (fun p => (p.1, i :: p.2))
lemma jetSplits_length {Ξ± : Type*} (l : List Ξ±) (p : List Ξ± Γ— List Ξ±)
(hp : p ∈ jetSplits l) : p.1.length ≀ l.length ∧ p.2.length ≀ l.length := by
induction l generalizing p with
| nil => simp [jetSplits] at hp; subst p; simp
| cons i l ih =>
simp only [jetSplits, List.mem_append, List.mem_map] at hp
rcases hp with ⟨q, hq, rfl⟩ | ⟨q, hq, rfl⟩
· obtain ⟨h1,h2⟩ := ih q hq
simp only [List.length_cons]; omega
· obtain ⟨h1,h2⟩ := ih q hq
simp only [List.length_cons]; omega
lemma differentiable_list_sum {n : β„•} {Ξ± : Type*} (l : List Ξ±) (f : Ξ± β†’ Space n β†’ ℝ)
(hf : βˆ€ a ∈ l, Differentiable ℝ (f a)) :
Differentiable ℝ (fun y => (l.map (fun a => f a y)).sum) := by
induction l with
| nil => simp
| cons a l ih =>
simp only [List.map_cons, List.sum_cons]
exact (hf a (by simp)).add (ih (fun b hb => hf b (by simp [hb])))
lemma coordDeriv_list_sum {n : β„•} {Ξ± : Type*} (l : List Ξ±) (f : Ξ± β†’ Space n β†’ ℝ)
(hf : βˆ€ a ∈ l, Differentiable ℝ (f a)) (i : Fin n) (x : Space n) :
coordDeriv (fun y => (l.map (fun a => f a y)).sum) i x =
(l.map (fun a => coordDeriv (f a) i x)).sum := by
induction l with
| nil => simp [coordDeriv]
| cons a l ih =>
simp only [List.map_cons, List.sum_cons]
rw [coordDeriv_add (hf a (by simp))
(differentiable_list_sum l f (fun b hb => hf b (by simp [hb]))),
ih (fun b hb => hf b (by simp [hb]))]
lemma coordinateJet_mul {n : β„•} {f g : Space n β†’ ℝ}
(hf : ContDiff ℝ ∞ f) (hg : ContDiff ℝ ∞ g) (l : List (Fin n)) (x : Space n) :
coordinateJet (fun y => f y*g y) l x =
((jetSplits l).map (fun p => coordinateJet f p.1 x * coordinateJet g p.2 x)).sum := by
induction l generalizing x with
| nil => simp [coordinateJet, jetSplits]
| cons i l ih =>
have he : coordinateJet (fun y => f y*g y) l = fun y =>
((jetSplits l).map (fun p => coordinateJet f p.1 y * coordinateJet g p.2 y)).sum := funext ih
change coordDeriv (coordinateJet (fun y => f y*g y) l) i x = _
rw [he, coordDeriv_list_sum]
Β· simp only [jetSplits, List.map_append, List.map_map, List.sum_append, Function.comp_def,
coordinateJet]
rw [← List.sum_map_add]
apply congrArg List.sum
apply List.map_congr_left
intro p hp
rw [coordDeriv_mul ((coordinateJet_smooth hf p.1).differentiable (by simp))
((coordinateJet_smooth hg p.2).differentiable (by simp))]
ring
Β· intro p hp
exact ((coordinateJet_smooth hf p.1).mul (coordinateJet_smooth hg p.2)).differentiable (by simp)
lemma coordinateJet_zero {n : β„•} (l : List (Fin n)) :
coordinateJet (fun _ : Space n => (0 : ℝ)) l = fun _ => 0 := by
induction l with
| nil => rfl
| cons i l ih =>
funext x
change coordDeriv (coordinateJet (fun _ => 0) l) i x = 0
rw [ih]
simp [coordDeriv]
lemma coordinateJet_const {n : β„•} (a : ℝ) (l : List (Fin n)) :
coordinateJet (fun _ : Space n => a) l = fun _ => if l=[] then a else 0 := by
induction l with
| nil => simp [coordinateJet]
| cons i l ih =>
funext x
change coordDeriv (coordinateJet (fun _ => a) l) i x = 0
rw [ih]
by_cases hl : l=[]
Β· simp only [hl]
simp [coordDeriv]
Β· simp only [ite_eq_right hl]
simp [coordDeriv]
lemma coordinateJet_add {n : β„•} {f g : Space n β†’ ℝ}
(hf : ContDiff ℝ ∞ f) (hg : ContDiff ℝ ∞ g) (l : List (Fin n)) :
coordinateJet (fun x => f x+g x) l = fun x => coordinateJet f l x+coordinateJet g l x := by
induction l with
| nil => rfl
| cons i l ih =>
funext x
change coordDeriv (coordinateJet (fun x => f x+g x) l) i x = _
rw [ih, coordDeriv_add ((coordinateJet_smooth hf l).differentiable (by simp))
((coordinateJet_smooth hg l).differentiable (by simp))]
rfl
lemma coordinateJet_const_mul {n : β„•} {f : Space n β†’ ℝ}
(hf : ContDiff ℝ ∞ f) (a : ℝ) (l : List (Fin n)) :
coordinateJet (fun x => a*f x) l = fun x => a*coordinateJet f l x := by
induction l with
| nil => rfl
| cons i l ih =>
funext x
change coordDeriv (coordinateJet (fun x => a*f x) l) i x = _
rw [ih]
simp only [coordinateJet, coordDeriv,
fderiv_const_mul ((coordinateJet_smooth hf l).differentiable (by simp) x),
smul_apply, smul_eq_mul]
lemma coordinateJet_sum {n : β„•} {ΞΉ : Type*} (s : Finset ΞΉ)
{f : ΞΉ β†’ Space n β†’ ℝ} (hf : βˆ€ i ∈ s, ContDiff ℝ ∞ (f i)) (l : List (Fin n)) :
coordinateJet (fun x => βˆ‘ i ∈ s, f i x) l = fun x => βˆ‘ i ∈ s, coordinateJet (f i) l x := by
classical
induction s using Finset.induction_on with
| empty => simpa using coordinateJet_zero l
| @insert i s hi ih =>
simp only [Finset.sum_insert hi]
rw [coordinateJet_add (hf i (by simp)) (ContDiff.sum (fun j hj => hf j (by simp [hj]))),
ih (fun j hj => hf j (by simp [hj]))]
lemma coordinateJet_coordDeriv {n : β„•} {f : Space n β†’ ℝ}
(hf : ContDiff ℝ ∞ f) (l : List (Fin n)) (i : Fin n) :
coordinateJet (coordDeriv f i) l = coordDeriv (coordinateJet f l) i := by
induction l with
| nil => rfl
| cons j l ih =>
change coordDeriv (coordinateJet (coordDeriv f i) l) j = _
rw [ih, coordDeriv_comm (smooth_C2 (coordinateJet_smooth hf l))]
rfl
def jetRestSplits {Ξ± : Type*} : List Ξ± β†’ List (List Ξ± Γ— List Ξ±)
| [] => []
| i::l => (jetSplits l).map (fun p => (i::p.1,p.2)) ++
(jetRestSplits l).map (fun p => (p.1,i::p.2))
lemma jetSplits_perm_rest {Ξ± : Type*} (l : List Ξ±) :
(jetSplits l).Perm (([],l)::jetRestSplits l) := by
induction l with
| nil => simp [jetSplits, jetRestSplits]
| cons i l ih =>
simp only [jetSplits, jetRestSplits]
have H := List.Perm.append_left ((jetSplits l).map (fun p => (i::p.1,p.2)))
(ih.map (fun p => (p.1,i::p.2)))
simp only [List.map_cons] at H
exact H.trans List.perm_middle
lemma jetRestSplits_length {Ξ± : Type*} (l : List Ξ±) (p : List Ξ± Γ— List Ξ±)
(hp : p ∈ jetRestSplits l) : p.1.length ≀ l.length ∧ p.2.length < l.length := by
induction l generalizing p with
| nil => simp [jetRestSplits] at hp
| cons i l ih =>
simp only [jetRestSplits, List.mem_append, List.mem_map] at hp
rcases hp with ⟨q,hq,rfl⟩ | ⟨q,hq,rfl⟩
· obtain ⟨h1,h2⟩ := jetSplits_length l q hq
simp only [List.length_cons]; omega
· obtain ⟨h1,h2⟩ := ih q hq
simp only [List.length_cons]; omega
end DeGiorgi
end
end OAI