| import Mathlib |
| import OAI.Probability.SKBarriers.Calculus.ParameterCalculus |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open scoped BigOperators Topology |
| open MeasureTheory ProbabilityTheory Filter |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped Topology Interval |
| noncomputable section |
| open MeasureTheory Set |
| open scoped Interval |
| namespace SK.Analytic |
|
|
| theorem cubeIntegral_congr_parameter (n : ℕ) (f g : ParameterSpace n → ℝ) |
| (a b x : ℝ) (he : ∀ z, parameter n z = x → f z = g z) : |
| cubeIntegral n f a b x = cubeIntegral n g a b x := by |
| induction n with |
| | zero => exact he x rfl |
| | succ n ih => |
| apply ih |
| intro z hz |
| apply intervalIntegral.integral_congr |
| intro y _ |
| exact he (z,y) hz |
|
|
| theorem cubeIntegral_pos (n : ℕ) (f : ParameterSpace n → ℝ) |
| (hf : Continuous f) (hpos : ∀ z, 0 < f z) {a b : ℝ} (hab : a < b) (x : ℝ) : |
| 0 < cubeIntegral n f a b x := by |
| induction n with |
| | zero => exact hpos x |
| | succ n ih => |
| apply ih _ (contDiff_zero.mp (contDiff_intervalIntegral 0 f (contDiff_zero.mpr hf) a b)) |
| intro z |
| apply intervalIntegral.integral_pos hab |
| (hf.comp (continuous_const.prodMk continuous_id)).continuousOn |
| · exact fun y _ => (hpos (z,y)).le |
| · exact ⟨a, ⟨le_rfl, hab.le⟩, hpos (z,a)⟩ |
|
|
| theorem cubeIntegral_const_mul (n : ℕ) (f : ParameterSpace n → ℝ) (c a b x : ℝ) : |
| cubeIntegral n (fun z => c*f z) a b x = c*cubeIntegral n f a b x := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| change cubeIntegral n (fun z => ∫ y in a..b, c*f (z,y)) a b x = _ |
| simp_rw [intervalIntegral.integral_const_mul] |
| exact ih _ |
|
|
| theorem cubeIntegral_sub (n : ℕ) (f g : ParameterSpace n → ℝ) |
| (hf : Continuous f) (hg : Continuous g) (a b x : ℝ) : |
| cubeIntegral n (fun z => f z-g z) a b x = cubeIntegral n f a b x-cubeIntegral n g a b x := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| have hiF (z : ParameterSpace n) : IntervalIntegrable (fun y => f (z,y)) volume a b := |
| (hf.comp (continuous_const.prodMk continuous_id)).intervalIntegrable a b |
| have hiG (z : ParameterSpace n) : IntervalIntegrable (fun y => g (z,y)) volume a b := |
| (hg.comp (continuous_const.prodMk continuous_id)).intervalIntegrable a b |
| change cubeIntegral n (fun z => ∫ y in a..b, f (z,y)-g (z,y)) a b x = _ |
| simp_rw [intervalIntegral.integral_sub (hiF _) (hiG _)] |
| exact ih _ _ (contDiff_zero.mp (contDiff_intervalIntegral 0 f (contDiff_zero.mpr hf) a b)) |
| (contDiff_zero.mp (contDiff_intervalIntegral 0 g (contDiff_zero.mpr hg) a b)) |
|
|
| theorem cubePotential_exp_eq (n : ℕ) (V : ParameterSpace n → ℝ) |
| (hV : ContDiff ℝ 2 V) {a b : ℝ} (hab : a < b) (x : ℝ) : |
| Real.exp (-cubePotential n V a b x) = cubeIntegral n (fun z => Real.exp (-V z)) a b x := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| change Real.exp (-cubePotential n (marginalPotential V a b) a b x) = _ |
| rw [ih _ (contDiff_marginalPotential _ 2 hV hab)] |
| congr 1 |
| funext z |
| dsimp only [marginalPotential] |
| have hc : Continuous (fun y => V (z,y)) := |
| hV.continuous.comp (continuous_const.prodMk continuous_id) |
| rw [neg_neg, Real.exp_log (intervalPartition_pos hc hab)] |
| rfl |
|
|
| theorem cubePotential_eq_neg_log (n : ℕ) (V : ParameterSpace n → ℝ) |
| (hV : ContDiff ℝ 2 V) {a b : ℝ} (hab : a < b) : |
| cubePotential n V a b = fun x => -Real.log (cubeIntegral n (fun z => Real.exp (-V z)) a b x) := by |
| funext x |
| rw [← cubePotential_exp_eq n V hV hab x, Real.log_exp, neg_neg] |
|
|
| theorem contDiff_cubePotential (n : ℕ) (V : ParameterSpace n → ℝ) |
| (hV : ContDiff ℝ 2 V) {a b : ℝ} (hab : a < b) : |
| ContDiff ℝ 2 (cubePotential n V a b) := by |
| induction n with |
| | zero => exact hV |
| | succ n ih => exact ih _ (contDiff_marginalPotential _ 2 hV hab) |
|
|
| theorem contDiff_parameterDerivative (n : ℕ) (f : ParameterSpace n → ℝ) |
| (hf : ContDiff ℝ 2 f) : ContDiff ℝ 1 (parameterDerivative n f) := |
| (hf.fderiv_right (by norm_num)).clm_apply contDiff_const |
|
|
| theorem cubePotential_hessian_formula (n : ℕ) (V : ParameterSpace n → ℝ) |
| (hV : ContDiff ℝ 2 V) {a b : ℝ} (hab : a < b) (x : ℝ) : |
| let w := fun z => Real.exp (-V z) |
| let Z := cubeIntegral n w a b x |
| let Z₁ := cubeIntegral n (parameterDerivative n w) a b x |
| let Z₂ := cubeIntegral n (parameterDerivative n (parameterDerivative n w)) a b x |
| Hessian (cubePotential n V a b) x 1 1 = (Z₁/Z)^2-Z₂/Z := by |
| let w : ParameterSpace n → ℝ := fun z => Real.exp (-V z) |
| have hw : ContDiff ℝ 2 w := hV.neg.exp |
| let Z := cubeIntegral n w a b |
| let Z₁ := cubeIntegral n (parameterDerivative n w) a b |
| let Z₂ := cubeIntegral n (parameterDerivative n (parameterDerivative n w)) a b |
| have hZpos (t : ℝ) : 0 < Z t := cubeIntegral_pos n w hw.continuous |
| (fun _ => Real.exp_pos _) hab t |
| have hD (t : ℝ) : HasDerivAt Z (Z₁ t) t := |
| hasDerivAt_cubeIntegral n w (hw.of_le (by norm_num)) a b t |
| have hD₁ (t : ℝ) : HasDerivAt Z₁ (Z₂ t) t := |
| hasDerivAt_cubeIntegral n _ (contDiff_parameterDerivative n w hw) a b t |
| have hM (t : ℝ) : HasDerivAt (cubePotential n V a b) (-(Z₁ t/Z t)) t := by |
| rw [cubePotential_eq_neg_log n V hV hab] |
| exact ((hD t).log (ne_of_gt (hZpos t))).neg |
| have he : (fun t => fderiv ℝ (cubePotential n V a b) t 1) = fun t => -(Z₁ t/Z t) := by |
| funext t |
| exact (hM t).deriv |
| have hH := hasDerivAt_score_comp (cubePotential n V a b) |
| (contDiff_cubePotential n V hV hab) (hasDerivAt_id x) 1 |
| change HasDerivAt (fun t => fderiv ℝ (cubePotential n V a b) t 1) |
| (Hessian (cubePotential n V a b) x 1 1) x at hH |
| rw [he] at hH |
| have hq := ((hD₁ x).div (hD x) (ne_of_gt (hZpos x))).neg |
| have hh := hH.unique hq |
| change Hessian (cubePotential n V a b) x 1 1 = (Z₁ x/Z x)^2-Z₂ x/Z x |
| rw [hh] |
| field_simp |
| ring |
|
|
| end SK.Analytic |
|
|
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
