math / data /lean /OAI /Probability /GaussianPropeller /QuantileCalculus.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
6.38 kB
import OAI.Probability.GaussianPropeller.Quantile
namespace OAI
universe uE uΞΉ
open MeasureTheory ProbabilityTheory
open scoped ENNReal
open scoped RealInnerProductSpace
open scoped RealInnerProductSpace
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal RealInnerProductSpace
open Filter
open scoped Topology
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology
open scoped RealInnerProductSpace
namespace GaussianPropeller.QuantilePDE
open GaussianPropeller.Quantile
variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
lemma quantile_fderiv {u : E β†’ ℝ} {g : E} {x : E}
(hu : u x ∈ Ioo (0:ℝ) 1) (hd : HasFDerivAt u (innerSL ℝ g) x) :
HasFDerivAt (fun y => q (u y)) (innerSL ℝ ((Ο† (q (u x)))⁻¹ β€’ g)) x := by
have hh := (hasDerivAt_q hu).comp_hasFDerivAt x hd
convert hh using 1 <;> (first | rfl | (ext y; simp))
lemma quantile_gradient_line_derivative {u : E β†’ ℝ} {g : E β†’ E}
{K : E β†’ E β†’L[ℝ] E} (hu : βˆ€ x, u x ∈ Ioo (0:ℝ) 1)
(hdu : βˆ€ x, HasFDerivAt u (innerSL ℝ (g x)) x)
(hdg : βˆ€ x, HasFDerivAt g (K x) x) (x e : E) :
HasDerivAt (fun s : ℝ => βŸͺ(Ο† (q (u (x+sβ€’e))))⁻¹ β€’ g (x+sβ€’e), e⟫)
((Ο† (q (u x)))⁻¹*βŸͺK x e,e⟫ +
q (u x)*(Ο† (q (u x)))⁻¹^2*βŸͺg x,e⟫^2) 0 := by
have hdx : HasDerivAt (fun s : ℝ => x+sβ€’e) e 0 := by
simpa using ((hasDerivAt_id (0:ℝ)).smul_const e).const_add x
have hdv : HasDerivAt (fun s : ℝ => q (u (x+sβ€’e)))
((Ο† (q (u x)))⁻¹*βŸͺg x,e⟫) 0 := by
simpa [Function.comp_def] using (quantile_fderiv (hu (x+0β€’e)) (hdu (x+0β€’e))).comp_hasDerivAt 0 hdx
have hdφ := (hasDerivAt_φ (q (u (x+0‒e)))).comp 0 hdv
have hdi := hdφ.inv (ne_of_gt (φ_pos _))
have hdg' : HasDerivAt (fun s : ℝ => g (x+sβ€’e)) (K x e) 0 := by
simpa only [Function.comp_def, zero_smul, add_zero] using (hdg (x+0β€’e)).comp_hasDerivAt 0 hdx
have hi : HasDerivAt (fun s : ℝ => βŸͺg (x+sβ€’e), e⟫) βŸͺK x e,e⟫ 0 := by
simpa using hdg'.inner ℝ (hasDerivAt_const (0:ℝ) e)
have hh := hdi.mul hi
convert hh using 1 <;> try rfl
Β· funext s; simp only [real_inner_smul_left, Function.comp_def, Pi.mul_apply, Pi.inv_apply]
Β· simp only [Function.comp_def, zero_smul, add_zero, Pi.inv_apply]
field_simp [ne_of_gt (Ο†_pos (q (u x)))]
ring
lemma trace_quantile_hessian {ΞΉ : Type uΞΉ} [Fintype ΞΉ]
(e : OrthonormalBasis ΞΉ ℝ E) (v a : ℝ) (g : E) (K : E β†’L[ℝ] E) :
(βˆ‘ i : ΞΉ, (a*βŸͺK (e i),e i⟫ + v*a^2*βŸͺg,e i⟫^2)) - v*β€–a β€’ gβ€–^2 =
a*(βˆ‘ i : ΞΉ, βŸͺK (e i),e i⟫) := by
rw [Finset.sum_add_distrib, ← Finset.mul_sum, ← Finset.mul_sum,
e.sum_sq_inner_left, norm_smul, Real.norm_eq_abs, mul_pow, sq_abs]
ring
end GaussianPropeller.QuantilePDE
namespace GaussianPropeller.SmoothCDF
open GaussianPropeller.Quantile
variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
lemma abs_mul_Ο†_le (a : ℝ) : |a| *Ο† a ≀ Ο† 0 := by
have hsq : |a| ≀ 1+a^2/2 := by nlinarith [sq_nonneg (|a|-1), sq_abs a]
have he : |a| ≀ Real.exp (a^2/2) := hsq.trans (by nlinarith [Real.add_one_le_exp (a^2/2)])
have hh := mul_le_mul_of_nonneg_right he (Real.exp_pos (-a^2/2)).le
rw [← Real.exp_add] at hh
have heq : a^2/2 + -a^2/2 = 0 := by ring
rw [heq, Real.exp_zero] at hh
unfold Ο†
simp only [zero_pow (by norm_num : 2 β‰  0), neg_zero, zero_div, Real.exp_zero, mul_one]
nlinarith [mul_le_mul_of_nonneg_left hh (by positivity : 0 ≀ (Real.sqrt (2*Real.pi))⁻¹)]
noncomputable def grad (f : E β†’ ℝ) (g : E β†’ E) (x : E) : E := Ο† (f x) β€’ g x
noncomputable def hess (f : E β†’ ℝ) (g : E β†’ E) (K : E β†’ E β†’L[ℝ] E) (x : E) : E β†’L[ℝ] E :=
Ο† (f x) β€’ K x - (f x*Ο† (f x)) β€’ ((innerSL ℝ (g x)).smulRight (g x))
lemma fderiv {f : E β†’ ℝ} {g : E β†’ E}
(hf : βˆ€ x, HasFDerivAt f (innerSL ℝ (g x)) x) (x : E) :
HasFDerivAt (fun y => Ξ¦ (f y)) (innerSL ℝ (grad f g x)) x := by
have h := (hasDerivAt_Ξ¦ (f x)).comp_hasFDerivAt x (hf x)
convert h using 1 <;> (first | rfl | (ext e; simp [grad]))
lemma grad_fderiv {f : E β†’ ℝ} {g : E β†’ E} {K : E β†’ E β†’L[ℝ] E}
(hf : βˆ€ x, HasFDerivAt f (innerSL ℝ (g x)) x)
(hg : βˆ€ x, HasFDerivAt g (K x) x) (x : E) :
HasFDerivAt (grad f g) (hess f g K x) x := by
have h := ((hasDerivAt_Ο† (f x)).comp_hasFDerivAt x (hf x)).smul (hg x)
convert h using 1 <;> try rfl
ext e
simp only [hess, sub_apply, add_apply,
smul_apply, ContinuousLinearMap.smulRight_apply, innerSL_apply_apply, smul_eq_mul, Function.comp_def]
module
lemma continuous_hess {f : E β†’ ℝ} {g : E β†’ E} {K : E β†’ E β†’L[ℝ] E}
(hf : Continuous f) (hg : Continuous g) (hK : Continuous K) : Continuous (hess f g K) := by
have hφ := continuous_φ.comp hf
unfold hess
fun_prop
omit [NormedAddCommGroup E] [InnerProductSpace ℝ E] in
lemma cdf_bound [NormedAddCommGroup E] [InnerProductSpace ℝ E]
(f : E β†’ ℝ) (x : E) : β€–Ξ¦ (f x)β€– ≀ 1 := by
rw [Real.norm_eq_abs, abs_of_pos (Ξ¦_pos _)]; exact (Ξ¦_lt_one _).le
lemma grad_bound {f : E β†’ ℝ} {g : E β†’ E} {L : ℝ}
(hL : βˆ€ x, β€–g xβ€– ≀ L) (x : E) : β€–grad f g xβ€– ≀ Ο† 0*L := by
rw [grad, norm_smul, Real.norm_eq_abs, abs_of_pos (Ο†_pos _)]
exact mul_le_mul (Ο†_le_zero _) (hL x) (norm_nonneg _) (Ο†_pos _).le
lemma hess_bound {f : E β†’ ℝ} {g : E β†’ E} {K : E β†’ E β†’L[ℝ] E} {L D : ℝ}
(hL0 : 0 ≀ L) (hL : βˆ€ x, β€–g xβ€– ≀ L) (hD : βˆ€ x, β€–K xβ€– ≀ D) (x : E) :
β€–hess f g K xβ€– ≀ Ο† 0*(D+L^2) := by
have hD0 : 0 ≀ D := (norm_nonneg (K x)).trans (hD x)
calc
β€–hess f g K xβ€– ≀ β€–Ο† (f x) β€’ K xβ€– +
β€–(f x*Ο† (f x)) β€’ ((innerSL ℝ (g x)).smulRight (g x))β€– := norm_sub_le _ _
_ = Ο† (f x)*β€–K xβ€– + (|f x| *Ο† (f x))*β€–g xβ€–^2 := by
rw [norm_smul, norm_smul, Real.norm_eq_abs, Real.norm_eq_abs,
abs_of_pos (Ο†_pos _), abs_mul, abs_of_pos (Ο†_pos _),
ContinuousLinearMap.norm_smulRight_apply, innerSL_apply_norm]
ring
_ ≀ Ο† 0*D + Ο† 0*L^2 := add_le_add
(mul_le_mul (Ο†_le_zero _) (hD x) (norm_nonneg _) (Ο†_pos _).le)
(mul_le_mul (abs_mul_Ο†_le _) ((sq_le_sqβ‚€ (norm_nonneg _) hL0).2 (hL x))
(sq_nonneg _) (Ο†_pos _).le)
_ = _ := by ring
end GaussianPropeller.SmoothCDF
end OAI