| import Mathlib |
| import OAI.Computability.MaxCut.Games.Identities |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace OptimalMaxCut.GaussianBellman |
|
|
| open scoped Real Topology NNReal ContDiff |
| open Set Filter MeasureTheory |
| open ProbabilityTheory |
|
|
| noncomputable def density (x : ℝ) : ℝ := gaussianPDFReal 0 1 x |
|
|
| noncomputable def cdf (x : ℝ) : ℝ := (1 / 2 : ℝ) + ∫ t in (0 : ℝ)..x, density t |
|
|
| theorem density_pos (x : ℝ) : 0 < density x := gaussianPDFReal_pos 0 1 x (by norm_num) |
| theorem density_nonneg (x : ℝ) : 0 ≤ density x := (density_pos x).le |
| theorem density_continuous : Continuous density := by |
| unfold density gaussianPDFReal |
| fun_prop |
|
|
| theorem density_integrable : Integrable density := integrable_gaussianPDFReal 0 1 |
|
|
| theorem density_neg (x : ℝ) : density (-x) = density x := by |
| simp [density, gaussianPDFReal] |
|
|
| theorem density_deriv (x : ℝ) : HasDerivAt density (-x * density x) x := by |
| unfold density gaussianPDFReal |
| convert (HasDerivAt.const_mul (√(2 * Real.pi * (1 : ℝ≥0) : ℝ))⁻¹ |
| (((hasDerivAt_id x).pow 2).neg.div_const (2 * (1 : ℝ≥0))).exp) using 1 <;> |
| norm_num |
| all_goals first | rfl | ring |
|
|
| theorem cdf_deriv (x : ℝ) : HasDerivAt cdf (density x) x := by |
| have h := intervalIntegral.integral_hasDerivAt_right |
| (density_continuous.intervalIntegrable 0 x) |
| density_continuous.stronglyMeasurable.stronglyMeasurableAtFilter |
| density_continuous.continuousAt |
| convert h.const_add (1 / 2 : ℝ) using 1 |
| rfl |
|
|
| theorem cdf_continuous : Continuous cdf := continuous_iff_continuousAt.mpr |
| (fun x => (cdf_deriv x).continuousAt) |
|
|
| theorem cdf_strictMono : StrictMono cdf := by |
| apply strictMono_of_deriv_pos |
| intro x |
| rw [(cdf_deriv x).deriv] |
| exact density_pos x |
|
|
| @[simp] theorem cdf_zero : cdf 0 = 1 / 2 := by simp [cdf] |
|
|
| theorem integral_density : ∫ x, density x = 1 := |
| integral_gaussianPDFReal_eq_one 0 (by norm_num : (1 : ℝ≥0) ≠ 0) |
|
|
| theorem half_integral : ∫ x in Iic (0 : ℝ), density x = 1 / 2 := by |
| have he : (∫ x in Iic (0 : ℝ), density x) = ∫ x in Ioi (0 : ℝ), density x := by |
| simpa only [density_neg, neg_zero] using integral_comp_neg_Iic 0 density |
| have h := intervalIntegral.integral_Iic_add_Ioi (b := 0) |
| density_integrable.integrableOn density_integrable.integrableOn |
| rw [integral_density, ← he] at h |
| linarith |
|
|
| theorem cdf_eq_integral (x : ℝ) : cdf x = ∫ t in Iic x, density t := by |
| have h := intervalIntegral.integral_Iic_sub_Iic (a := 0) (b := x) |
| density_integrable.integrableOn density_integrable.integrableOn |
| rw [half_integral] at h |
| unfold cdf |
| linarith |
|
|
| theorem cdf_mem_Ioo (x : ℝ) : cdf x ∈ Ioo (0 : ℝ) 1 := by |
| have h0 (y : ℝ) : 0 ≤ cdf y := by |
| rw [cdf_eq_integral] |
| exact integral_nonneg density_nonneg |
| have h1 (y : ℝ) : cdf y ≤ 1 := by |
| rw [cdf_eq_integral] |
| have h := intervalIntegral.integral_Iic_add_Ioi (b := y) |
| density_integrable.integrableOn density_integrable.integrableOn |
| rw [integral_density] at h |
| have hn : 0 ≤ ∫ t in Ioi y, density t := integral_nonneg density_nonneg |
| linarith |
| exact ⟨(h0 (x - 1)).trans_lt (cdf_strictMono (by linarith)), |
| (cdf_strictMono (show x < x + 1 by linarith)).trans_le (h1 (x + 1))⟩ |
|
|
| theorem cdf_neg (x : ℝ) : cdf (-x) = 1 - cdf x := by |
| have h := intervalIntegral.integral_comp_neg (a := 0) (b := x) density |
| simp only [density_neg, neg_zero] at h |
| have h' : (∫ t in (0 : ℝ)..-x, density t) = -(∫ t in (0 : ℝ)..x, density t) := by |
| rw [intervalIntegral.integral_symm, ← h] |
| dsimp [cdf] |
| rw [h'] |
| ring |
|
|
| theorem cdf_tendsto_atBot : Tendsto cdf atBot (𝓝 0) := by |
| convert (tendsto_integral_Iic_zero (f := density) (μ := volume) tendsto_id) using 1 |
| funext x |
| exact cdf_eq_integral x |
|
|
| theorem cdf_tendsto_atTop : Tendsto cdf atTop (𝓝 1) := by |
| have h := cdf_tendsto_atBot.comp tendsto_neg_atTop_atBot |
| have h' := h.const_sub 1 |
| simpa only [Function.comp_def, cdf_neg, sub_sub_cancel, sub_zero] using h' |
|
|
| theorem cdf_range : range cdf = Ioo (0 : ℝ) 1 := by |
| apply Subset.antisymm |
| · rintro _ ⟨x, rfl⟩; exact cdf_mem_Ioo x |
| · have h := isPreconnected_univ.intermediate_value_Ioo |
| (l₁ := atBot) (l₂ := atTop) (by simp) (by simp) |
| cdf_continuous.continuousOn cdf_tendsto_atBot cdf_tendsto_atTop |
| simpa only [image_univ] using h |
|
|
| noncomputable def quantile : ℝ → ℝ := Function.invFun cdf |
|
|
| @[simp] theorem quantile_cdf (x : ℝ) : quantile (cdf x) = x := |
| Function.leftInverse_invFun cdf_strictMono.injective x |
|
|
| theorem cdf_quantile {x : ℝ} (hx : x ∈ Ioo (0 : ℝ) 1) : cdf (quantile x) = x := by |
| obtain ⟨y, rfl⟩ : x ∈ range cdf := cdf_range.symm ▸ hx |
| exact congrArg cdf (quantile_cdf y) |
|
|
| theorem quantile_strictMonoOn : StrictMonoOn quantile (Ioo (0 : ℝ) 1) := by |
| intro a ha b hb hab |
| apply cdf_strictMono.lt_iff_lt.mp |
| rwa [cdf_quantile ha, cdf_quantile hb] |
|
|
| theorem quantile_image : quantile '' Ioo (0 : ℝ) 1 = univ := by |
| apply eq_univ_of_forall |
| intro x |
| exact ⟨cdf x, cdf_mem_Ioo x, quantile_cdf x⟩ |
|
|
| theorem quantile_continuousAt {x : ℝ} (hx : x ∈ Ioo (0 : ℝ) 1) : |
| ContinuousAt quantile x := by |
| apply quantile_strictMonoOn.continuousAt_of_image_mem_nhds (isOpen_Ioo.mem_nhds hx) |
| rw [quantile_image] |
| exact univ_mem |
|
|
| theorem quantile_deriv {x : ℝ} (hx : x ∈ Ioo (0 : ℝ) 1) : |
| HasDerivAt quantile (density (quantile x))⁻¹ x := by |
| apply HasDerivAt.of_local_left_inverse (quantile_continuousAt hx) |
| (cdf_deriv (quantile x)) (ne_of_gt (density_pos _)) |
| filter_upwards [isOpen_Ioo.mem_nhds hx] with y hy |
| exact cdf_quantile hy |
|
|
| @[simp] theorem quantile_half : quantile (1 / 2) = 0 := by |
| simpa only [cdf_zero] using quantile_cdf 0 |
|
|
| / |
| bound, to be applied to the Plackett integrand below. -/ |
| theorem integral_hasDerivAt_compact {F F' : ℝ → ℝ → ℝ} {a b u v x : ℝ} |
| (hx : x ∈ Ioo u v) (hab : a ≤ b) |
| (hc : ContinuousOn (Function.uncurry F) (Icc u v ×ˢ Icc a b)) |
| (hc' : ContinuousOn (Function.uncurry F') (Icc u v ×ˢ Icc a b)) |
| (hd : ∀ z ∈ Icc u v, ∀ t ∈ Icc a b, HasDerivAt (F · t) (F' z t) z) : |
| HasDerivAt (fun z => ∫ t in a..b, F z t) (∫ t in a..b, F' x t) x := by |
| have section_cont {H : ℝ → ℝ → ℝ} |
| (hh : ContinuousOn (Function.uncurry H) (Icc u v ×ˢ Icc a b)) |
| {z : ℝ} (hz : z ∈ Icc u v) : ContinuousOn (H z) (Icc a b) := by |
| exact hh.comp (continuous_const.prodMk continuous_id).continuousOn (fun t ht => ⟨hz, ht⟩) |
| obtain ⟨C, hC⟩ := (isCompact_Icc.prod isCompact_Icc).exists_bound_of_continuousOn hc' |
| have h := hasDerivAt_integral_of_dominated_loc_of_deriv_le |
| (μ := volume.restrict (Ioc a b)) (F := F) (F' := F') (bound := fun _ => C) |
| (Icc_mem_nhds hx.1 hx.2) |
| (show ∀ᶠ z in 𝓝 x, AEStronglyMeasurable (F z) (volume.restrict (Ioc a b)) from by |
| filter_upwards [Icc_mem_nhds hx.1 hx.2] with z hz |
| exact ((section_cont hc hz).mono Ioc_subset_Icc_self).aestronglyMeasurable measurableSet_Ioc) |
| (((section_cont hc ⟨hx.1.le, hx.2.le⟩).integrableOn_Icc).mono_set Ioc_subset_Icc_self) |
| (((section_cont hc' ⟨hx.1.le, hx.2.le⟩).mono Ioc_subset_Icc_self).aestronglyMeasurable |
| measurableSet_Ioc) |
| (show ∀ᵐ t ∂volume.restrict (Ioc a b), ∀ z ∈ Icc u v, ‖F' z t‖ ≤ C from by |
| filter_upwards [ae_restrict_mem measurableSet_Ioc] with t ht z hz |
| exact hC (z, t) ⟨hz, Ioc_subset_Icc_self ht⟩) |
| (integrable_const C) |
| (show ∀ᵐ t ∂volume.restrict (Ioc a b), ∀ z ∈ Icc u v, |
| HasDerivAt (F · t) (F' z t) z from by |
| filter_upwards [ae_restrict_mem measurableSet_Ioc] with t ht z hz |
| exact hd z hz t (Ioc_subset_Icc_self ht)) |
| simpa only [intervalIntegral.integral_of_le hab] using h.2 |
|
|
| noncomputable def sigma (t : ℝ) : ℝ := Real.sqrt (1 - t ^ 2) |
| noncomputable def conditionalArg (t u v : ℝ) : ℝ := (v - t * u) / sigma t |
| noncomputable def plackett (t u v : ℝ) : ℝ := |
| density u * density (conditionalArg t u v) / sigma t |
| noncomputable def kernel (t x y : ℝ) : ℝ := |
| x * y + ∫ r in (0 : ℝ)..t, plackett r (quantile x) (quantile y) |
|
|
| theorem sigma_pos {t : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) : 0 < sigma t := by |
| apply Real.sqrt_pos.mpr |
| nlinarith [ht.1, ht.2] |
|
|
| theorem sigma_sq {t : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) : (sigma t) ^ 2 = 1 - t ^ 2 := by |
| apply Real.sq_sqrt |
| nlinarith [ht.1, ht.2] |
|
|
| theorem sigma_continuous : Continuous sigma := by unfold sigma; fun_prop |
|
|
| theorem sigma_deriv {t : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) : |
| HasDerivAt sigma (-t / sigma t) t := by |
| have h := ((hasDerivAt_id t).pow 2).const_sub 1 |
| convert h.sqrt (ne_of_gt (show 0 < 1 - t ^ 2 by nlinarith [ht.1, ht.2])) using 1 <;> |
| first | rfl | (dsimp [sigma]; ring) |
|
|
| theorem plackett_pos {t : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) (u v : ℝ) : |
| 0 < plackett t u v := div_pos (mul_pos (density_pos _) (density_pos _)) (sigma_pos ht) |
|
|
| theorem conditionalArg_continuousOn : |
| ContinuousOn (fun p : ℝ × ℝ × ℝ => conditionalArg p.1 p.2.1 p.2.2) |
| {p | p.1 ∈ Ioo (-1 : ℝ) 1} := by |
| unfold conditionalArg |
| exact ((continuous_snd.snd.sub (continuous_fst.mul continuous_snd.fst)).continuousOn).div |
| (sigma_continuous.comp continuous_fst).continuousOn (fun p hp => ne_of_gt (sigma_pos hp)) |
|
|
| theorem plackett_continuousOn : |
| ContinuousOn (fun p : ℝ × ℝ × ℝ => plackett p.1 p.2.1 p.2.2) |
| {p | p.1 ∈ Ioo (-1 : ℝ) 1} := by |
| unfold plackett |
| exact ((density_continuous.comp continuous_snd.fst).continuousOn.mul |
| (density_continuous.comp_continuousOn conditionalArg_continuousOn)).div |
| (sigma_continuous.comp continuous_fst).continuousOn (fun p hp => ne_of_gt (sigma_pos hp)) |
|
|
| theorem kernel_ge_product {t : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) (x y : ℝ) : |
| x * y ≤ kernel t x y := by |
| have h : 0 ≤ ∫ r in (0 : ℝ)..t, plackett r (quantile x) (quantile y) := by |
| apply intervalIntegral.integral_nonneg ht.1 |
| intro r hr |
| exact (plackett_pos ⟨by linarith [hr.1], hr.2.trans_lt ht.2⟩ _ _).le |
| exact le_add_of_nonneg_right h |
|
|
| theorem density_mul (u v : ℝ) : density u * density v = |
| density 0 ^ 2 * Real.exp (-u ^ 2 / 2 + -v ^ 2 / 2) := by |
| simp only [density, gaussianPDFReal, NNReal.coe_one, mul_one, sub_zero, |
| zero_pow (by decide : (2 : ℕ) ≠ 0), neg_zero, zero_div, Real.exp_zero, Real.exp_add] |
| ring |
|
|
| theorem density_zero_sq : density 0 ^ 2 = (2 * Real.pi)⁻¹ := by |
| have h : (Real.sqrt (2 * Real.pi)) ^ 2 = 2 * Real.pi := Real.sq_sqrt (by positivity) |
| simp only [density, gaussianPDFReal, NNReal.coe_one, sub_self, zero_pow (by decide : (2 : ℕ) ≠ 0), |
| neg_zero, zero_div, Real.exp_zero, mul_one, inv_pow, h] |
|
|
| theorem plackett_symm {t : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) (u v : ℝ) : |
| plackett t u v = plackett t v u := by |
| have hn := ne_of_gt (sigma_pos ht) |
| have he : -u ^ 2 / 2 + -(conditionalArg t u v) ^ 2 / 2 = |
| -v ^ 2 / 2 + -(conditionalArg t v u) ^ 2 / 2 := by |
| unfold conditionalArg |
| calc |
| _ = -(u ^ 2 * sigma t ^ 2 + (v - t * u) ^ 2) / (2 * sigma t ^ 2) := by |
| field_simp; ring |
| _ = -(v ^ 2 * sigma t ^ 2 + (u - t * v) ^ 2) / (2 * sigma t ^ 2) := by |
| rw [sigma_sq ht]; ring |
| _ = _ := by field_simp; ring |
| unfold plackett |
| rw [density_mul, density_mul, he] |
|
|
| theorem kernel_symm {t : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) (x y : ℝ) : |
| kernel t x y = kernel t y x := by |
| unfold kernel |
| rw [mul_comm x y] |
| congr 1 |
| apply intervalIntegral.integral_congr |
| intro r hr |
| rw [uIcc_of_le ht.1] at hr |
| exact plackett_symm ⟨by linarith [hr.1], hr.2.trans_lt ht.2⟩ _ _ |
|
|
| theorem kernel_half {t : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) : |
| kernel t (1 / 2) (1 / 2) = 1 / 4 + Real.arcsin t / (2 * Real.pi) := by |
| have hi : IntervalIntegrable (fun r => 1 / sigma r) volume 0 t := by |
| apply ContinuousOn.intervalIntegrable |
| exact continuousOn_const.div sigma_continuous.continuousOn (fun r hr => by |
| rw [uIcc_of_le ht.1] at hr |
| exact ne_of_gt (sigma_pos ⟨by linarith [hr.1], hr.2.trans_lt ht.2⟩)) |
| have h := intervalIntegral.integral_eq_sub_of_hasDerivAt (a := 0) (b := t) |
| (f := Real.arcsin) (f' := fun r => 1 / sigma r) |
| (fun r hr => by |
| rw [uIcc_of_le ht.1] at hr |
| exact Real.hasDerivAt_arcsin (by linarith [hr.1]) (ne_of_lt (hr.2.trans_lt ht.2))) hi |
| simp only [kernel, quantile_half, plackett, conditionalArg, mul_zero, sub_zero, zero_div, |
| ← pow_two, density_zero_sq] |
| simp only [div_eq_mul_inv, one_mul, intervalIntegral.integral_const_mul] at h ⊢ |
| rw [h, Real.arcsin_zero, sub_zero] |
| ring |
|
|
| theorem conditionalArg_deriv_u (t u v : ℝ) : |
| HasDerivAt (fun z => conditionalArg t z v) (-t / sigma t) u := by |
| convert (((hasDerivAt_id u).const_mul t).const_sub v).div_const (sigma t) using 1 <;> |
| first | rfl | simp |
|
|
| theorem conditionalArg_deriv_v (t u v : ℝ) : |
| HasDerivAt (conditionalArg t u) (1 / sigma t) v := by |
| convert ((hasDerivAt_id v).sub_const (t * u)).div_const (sigma t) using 1 |
| rfl |
|
|
| theorem conditionalArg_deriv_t {t : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) (u v : ℝ) : |
| HasDerivAt (fun r => conditionalArg r u v) ((t * v - u) / sigma t ^ 3) t := by |
| have hn := ne_of_gt (sigma_pos ht) |
| have he : ((-u) * sigma t - (v - t * u) * (-t / sigma t)) / sigma t ^ 2 = |
| (t * v - u) / sigma t ^ 3 := by |
| field_simp |
| rw [sigma_sq ht] |
| ring |
| convert (((hasDerivAt_id t).mul_const u).const_sub v).div (sigma_deriv ht) hn using 1 <;> try rfl |
| simpa only [id_eq, one_mul] using he.symm |
|
|
| theorem plackett_deriv_u {t : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) (u v : ℝ) : |
| HasDerivAt (fun z => plackett t z v) |
| (density u * density (conditionalArg t u v) * (t * v - u) / sigma t ^ 3) u := by |
| have hn := ne_of_gt (sigma_pos ht) |
| have hd := ((density_deriv u).mul |
| ((density_deriv (conditionalArg t u v)).comp u (conditionalArg_deriv_u t u v))).div_const |
| (sigma t) |
| convert hd using 1 <;> try rfl |
| dsimp only [Function.comp_apply] |
| unfold conditionalArg |
| field_simp |
| rw [sigma_sq ht] |
| ring |
|
|
| theorem plackett_quantile_deriv_x {t x : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) |
| (hx : x ∈ Ioo (0 : ℝ) 1) (y : ℝ) : |
| HasDerivAt (fun z => plackett t (quantile z) (quantile y)) |
| (density (conditionalArg t (quantile x) (quantile y)) * |
| (t * quantile y - quantile x) / sigma t ^ 3) x := by |
| convert (plackett_deriv_u ht (quantile x) (quantile y)).comp x (quantile_deriv hx) using 1 <;> try rfl |
| field_simp [ne_of_gt (density_pos (quantile x))] |
|
|
| theorem conditionalCDF_deriv_t {t : ℝ} (ht : t ∈ Ioo (-1 : ℝ) 1) (u v : ℝ) : |
| HasDerivAt (fun r => cdf (conditionalArg r u v)) |
| (density (conditionalArg t u v) * (t * v - u) / sigma t ^ 3) t := by |
| convert (cdf_deriv (conditionalArg t u v)).comp t (conditionalArg_deriv_t ht u v) using 1 <;> try rfl |
| ring |
|
|
| noncomputable def flux (t u v : ℝ) : ℝ := |
| density (conditionalArg t u v) * (t * v - u) / sigma t ^ 3 |
|
|
| theorem flux_continuousOn : |
| ContinuousOn (fun p : ℝ × ℝ × ℝ => flux p.1 p.2.1 p.2.2) |
| {p | p.1 ∈ Ioo (-1 : ℝ) 1} := by |
| unfold flux |
| exact ((density_continuous.comp_continuousOn conditionalArg_continuousOn).mul |
| ((continuous_fst.mul continuous_snd.snd).sub continuous_snd.fst).continuousOn).div |
| ((sigma_continuous.comp continuous_fst).pow 3).continuousOn |
| (fun p hp => pow_ne_zero _ (ne_of_gt (sigma_pos hp))) |
|
|
| theorem quantile_continuousOn : ContinuousOn quantile (Ioo (0 : ℝ) 1) := |
| fun _ hx => (quantile_continuousAt hx).continuousWithinAt |
|
|
| theorem kernel_deriv_x {t x y : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) |
| (hx : x ∈ Ioo (0 : ℝ) 1) (hy : y ∈ Ioo (0 : ℝ) 1) : |
| HasDerivAt (fun z => kernel t z y) (cdf (conditionalArg t (quantile x) (quantile y))) x := by |
| let u := x / 2 |
| let v := (x + 1) / 2 |
| have huxv : x ∈ Ioo u v := by dsimp [u, v]; constructor <;> linarith [hx.1, hx.2] |
| have huv : Icc u v ⊆ Ioo (0 : ℝ) 1 := by |
| intro z hz; dsimp [u, v] at hz; constructor <;> linarith [hx.1, hx.2, hz.1, hz.2] |
| have hrt : Icc (0 : ℝ) t ⊆ Ioo (-1 : ℝ) 1 := by |
| intro r hr; exact ⟨by linarith [hr.1], hr.2.trans_lt ht.2⟩ |
| have hm : ContinuousOn (fun p : ℝ × ℝ => (p.2, quantile p.1, quantile y)) |
| (Icc u v ×ˢ Icc (0 : ℝ) t) := by |
| apply continuous_snd.continuousOn.prodMk |
| exact (quantile_continuousOn.comp continuous_fst.continuousOn |
| (fun p hp => huv hp.1)).prodMk continuousOn_const |
| have hc := plackett_continuousOn.comp hm (fun p hp => hrt hp.2) |
| have hc' := flux_continuousOn.comp hm (fun p hp => hrt hp.2) |
| have hd := integral_hasDerivAt_compact (F := fun z r => plackett r (quantile z) (quantile y)) |
| (F' := fun z r => flux r (quantile z) (quantile y)) huxv ht.1 hc hc' |
| (fun z hz r hr => plackett_quantile_deriv_x (hrt hr) (huv hz) y) |
| have hint : (∫ r in (0 : ℝ)..t, flux r (quantile x) (quantile y)) = |
| cdf (conditionalArg t (quantile x) (quantile y)) - y := by |
| have hfc : ContinuousOn (fun r => flux r (quantile x) (quantile y)) (uIcc 0 t) := by |
| apply flux_continuousOn.comp |
| (continuous_id.prodMk (continuous_const.prodMk continuous_const)).continuousOn |
| intro r hr |
| rw [uIcc_of_le ht.1] at hr |
| exact hrt hr |
| have hh := intervalIntegral.integral_eq_sub_of_hasDerivAt (a := 0) (b := t) |
| (fun r hr => conditionalCDF_deriv_t (hrt (by rwa [uIcc_of_le ht.1] at hr)) |
| (quantile x) (quantile y)) hfc.intervalIntegrable |
| simpa only [flux, conditionalArg, sigma, zero_pow (by decide : (2 : ℕ) ≠ 0), sub_zero, |
| Real.sqrt_one, zero_mul, div_one, cdf_quantile hy] using hh |
| convert ((hasDerivAt_id x).mul_const y).add hd using 1 <;> try rfl |
| simp only [one_mul] |
| rw [hint] |
| ring |
|
|
| theorem kernel_deriv_y {t x y : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) |
| (hx : x ∈ Ioo (0 : ℝ) 1) (hy : y ∈ Ioo (0 : ℝ) 1) : |
| HasDerivAt (kernel t x) (cdf (conditionalArg t (quantile y) (quantile x))) y := by |
| have h := kernel_deriv_x ht hy hx |
| have he : (fun z => kernel t z x) = kernel t x := by |
| funext z; exact kernel_symm ht z x |
| rwa [he] at h |
|
|
| noncomputable def kernelX (t x y : ℝ) : ℝ := cdf (conditionalArg t (quantile x) (quantile y)) |
| noncomputable def kernelXX (t x y : ℝ) : ℝ := |
| -t * plackett t (quantile x) (quantile y) / density (quantile x) ^ 2 |
| noncomputable def kernelXY (t x y : ℝ) : ℝ := |
| plackett t (quantile x) (quantile y) / (density (quantile x) * density (quantile y)) |
|
|
| theorem kernelX_deriv_x {t x y : ℝ} (_ht : t ∈ Ico (0 : ℝ) 1) |
| (hx : x ∈ Ioo (0 : ℝ) 1) : |
| HasDerivAt (fun z => kernelX t z y) (kernelXX t x y) x := by |
| have h := (cdf_deriv (conditionalArg t (quantile x) (quantile y))).comp x |
| ((conditionalArg_deriv_u t (quantile x) (quantile y)).comp x (quantile_deriv hx)) |
| convert h using 1 <;> try rfl |
| unfold kernelXX plackett |
| field_simp [ne_of_gt (density_pos (quantile x))] |
|
|
| theorem kernelX_deriv_y {t x y : ℝ} (_ht : t ∈ Ico (0 : ℝ) 1) |
| (hy : y ∈ Ioo (0 : ℝ) 1) : |
| HasDerivAt (kernelX t x) (kernelXY t x y) y := by |
| have h := (cdf_deriv (conditionalArg t (quantile x) (quantile y))).comp y |
| ((conditionalArg_deriv_v t (quantile x) (quantile y)).comp y (quantile_deriv hy)) |
| convert h using 1 <;> try rfl |
| unfold kernelXY plackett |
| field_simp [ne_of_gt (density_pos (quantile x)), ne_of_gt (density_pos (quantile y))] |
|
|
| theorem kernel_weighted_hessian {t : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) (x y a b : ℝ) : |
| kernelXX t x y * a ^ 2 + 2 * t * kernelXY t x y * a * b + kernelXX t y x * b ^ 2 = |
| -t * plackett t (quantile x) (quantile y) * |
| (a / density (quantile x) - b / density (quantile y)) ^ 2 := by |
| have ht' : t ∈ Ioo (-1 : ℝ) 1 := ⟨by linarith [ht.1], ht.2⟩ |
| unfold kernelXX kernelXY |
| rw [plackett_symm ht' (quantile y) (quantile x)] |
| field_simp [ne_of_gt (density_pos (quantile x)), ne_of_gt (density_pos (quantile y))] |
| ring |
|
|
| theorem kernel_weighted_hessian_nonpos {t : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) (x y a b : ℝ) : |
| kernelXX t x y * a ^ 2 + 2 * t * kernelXY t x y * a * b + kernelXX t y x * b ^ 2 ≤ 0 := by |
| rw [kernel_weighted_hessian ht] |
| apply mul_nonpos_of_nonpos_of_nonneg |
| · exact mul_nonpos_of_nonpos_of_nonneg (by linarith [ht.1]) |
| (plackett_pos ⟨by linarith [ht.1], ht.2⟩ _ _).le |
| · exact sq_nonneg _ |
|
|
| theorem density_contDiff (n : ℕ∞ω) : ContDiff ℝ n density := by |
| unfold density gaussianPDFReal |
| fun_prop |
|
|
| theorem cdf_contDiff (n : ℕ) : ContDiff ℝ n cdf := by |
| cases n with |
| | zero => exact contDiff_zero.mpr cdf_continuous |
| | succ n => |
| rw [show ((n + 1 : ℕ) : ℕ∞ω) = (n : ℕ∞ω) + 1 by simp, contDiff_succ_iff_deriv] |
| refine ⟨fun x => (cdf_deriv x).differentiableAt, by simp, ?_⟩ |
| have he : deriv cdf = density := funext (fun x => (cdf_deriv x).deriv) |
| rw [he] |
| exact density_contDiff n |
|
|
| theorem quantile_contDiffOn (n : ℕ) : ContDiffOn ℝ n quantile (Ioo (0 : ℝ) 1) := by |
| induction n with |
| | zero => exact contDiffOn_zero.mpr quantile_continuousOn |
| | succ n ih => |
| rw [show ((n + 1 : ℕ) : ℕ∞ω) = (n : ℕ∞ω) + 1 by simp, |
| contDiffOn_succ_iff_deriv_of_isOpen isOpen_Ioo] |
| refine ⟨fun x hx => (quantile_deriv hx).differentiableAt.differentiableWithinAt, by simp, ?_⟩ |
| have h : ContDiffOn ℝ n (fun x => (density (quantile x))⁻¹) (Ioo (0 : ℝ) 1) := by |
| exact ((density_contDiff n).comp_contDiffOn ih).inv (fun _ _ => ne_of_gt (density_pos _)) |
| apply h.congr |
| intro x hx |
| exact (quantile_deriv hx).deriv |
|
|
| theorem kernelX_contDiffOn {t : ℝ} (n : ℕ) : |
| ContDiffOn ℝ n (Function.uncurry (kernelX t)) (Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) := by |
| have hx : ContDiffOn ℝ n (fun p : ℝ × ℝ => quantile p.1) |
| (Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) := |
| (quantile_contDiffOn n).comp contDiffOn_fst (fun _ hp => hp.1) |
| have hy : ContDiffOn ℝ n (fun p : ℝ × ℝ => quantile p.2) |
| (Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) := |
| (quantile_contDiffOn n).comp contDiffOn_snd (fun _ hp => hp.2) |
| exact (cdf_contDiff n).comp_contDiffOn ((hy.sub (contDiffOn_const.mul hx)).div_const (sigma t)) |
|
|
| noncomputable def kernelD (t : ℝ) (p : ℝ × ℝ) : (ℝ × ℝ) →L[ℝ] ℝ := |
| kernelX t p.1 p.2 • ContinuousLinearMap.fst ℝ ℝ ℝ + |
| kernelX t p.2 p.1 • ContinuousLinearMap.snd ℝ ℝ ℝ |
|
|
| theorem kernelD_contDiffOn (t : ℝ) (n : ℕ) : |
| ContDiffOn ℝ n (kernelD t) (Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) := by |
| have hswap : ContDiffOn ℝ n (fun p : ℝ × ℝ => kernelX t p.2 p.1) |
| (Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) := |
| (kernelX_contDiffOn n).comp (contDiffOn_snd.prodMk contDiffOn_fst) |
| (fun _ hp => ⟨hp.2, hp.1⟩) |
| exact ((kernelX_contDiffOn n).smul_const _).add (hswap.smul_const _) |
|
|
| theorem kernel_fderiv {t : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) {p : ℝ × ℝ} |
| (hp : p ∈ Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) : |
| HasFDerivAt (Function.uncurry (kernel t)) (kernelD t p) p := by |
| have hn := (isOpen_Ioo.prod isOpen_Ioo).mem_nhds hp |
| have hc : ContinuousAt (Function.uncurry (kernelX t)) p := |
| (kernelX_contDiffOn 0).continuousOn.continuousAt hn |
| have hswap : ContDiffOn ℝ 0 (fun q : ℝ × ℝ => kernelX t q.2 q.1) |
| (Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) := |
| (kernelX_contDiffOn 0).comp (contDiffOn_snd.prodMk contDiffOn_fst) |
| (fun _ hq => ⟨hq.2, hq.1⟩) |
| have hcs : ContinuousAt (fun q : ℝ × ℝ => kernelX t q.2 q.1) p := |
| hswap.continuousOn.continuousAt hn |
| have hf := hasStrictFDerivAt_uncurry_coprod (𝕜 := ℝ) (f := kernel t) |
| (f₁ := fun x y => ContinuousLinearMap.toSpanSingleton ℝ (kernelX t x y)) |
| (f₂ := fun x y => ContinuousLinearMap.toSpanSingleton ℝ (kernelX t y x)) |
| (Filter.mem_of_superset hn (fun q hq => (kernel_deriv_x ht hq.1 hq.2).hasFDerivAt)) |
| (Filter.mem_of_superset hn (fun q hq => (kernel_deriv_y ht hq.1 hq.2).hasFDerivAt)) |
| ((ContinuousLinearMap.toSpanSingletonLIE ℝ ℝ).continuous.continuousAt.comp hc) |
| ((ContinuousLinearMap.toSpanSingletonLIE ℝ ℝ).continuous.continuousAt.comp hcs) |
| convert hf.hasFDerivAt using 1 <;> try rfl |
| apply ContinuousLinearMap.ext |
| intro q |
| change kernelX t p.1 p.2 * q.1 + kernelX t p.2 p.1 * q.2 = |
| q.1 * kernelX t p.1 p.2 + q.2 * kernelX t p.2 p.1 |
| ring |
|
|
| theorem kernel_contDiffOn {t : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) (n : ℕ) : |
| ContDiffOn ℝ n (Function.uncurry (kernel t)) (Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) := by |
| cases n with |
| | zero => |
| apply contDiffOn_zero.mpr |
| intro p hp |
| exact (kernel_fderiv ht hp).continuousAt.continuousWithinAt |
| | succ n => |
| rw [show ((n + 1 : ℕ) : ℕ∞ω) = (n : ℕ∞ω) + 1 by simp, |
| contDiffOn_succ_iff_fderiv_of_isOpen (isOpen_Ioo.prod isOpen_Ioo)] |
| refine ⟨fun p hp => (kernel_fderiv ht hp).differentiableAt.differentiableWithinAt, by simp, ?_⟩ |
| apply (kernelD_contDiffOn t n).congr |
| intro p hp |
| exact (kernel_fderiv ht hp).fderiv |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| theorem affinePath_deriv (p d : E) (u : ℝ) : |
| HasDerivAt (fun v : ℝ => p + v • d) d u := by |
| simpa using ((hasDerivAt_id u).smul_const d).const_add p |
|
|
| theorem affinePath_iterated_two (p d : E) (u : ℝ) : |
| iteratedDeriv 2 (fun v : ℝ => p + v • d) u = 0 := by |
| rw [iteratedDeriv_const_add (by norm_num), |
| iteratedDeriv_smul_const (f := fun v : ℝ => v) (contDiffAt_id : ContDiffAt ℝ 2 _ _)] |
| simp [iteratedDeriv_fun_id] |
|
|
| theorem affinePath_iterated_three (p d : E) (u : ℝ) : |
| iteratedDeriv 3 (fun v : ℝ => p + v • d) u = 0 := by |
| rw [iteratedDeriv_const_add (by norm_num), |
| iteratedDeriv_smul_const (f := fun v : ℝ => v) (contDiffAt_id : ContDiffAt ℝ 3 _ _)] |
| simp [iteratedDeriv_fun_id] |
|
|
| theorem iteratedDeriv_affinePath_two {F : E → ℝ} {p d : E} {u : ℝ} |
| (hf : ContDiffAt ℝ 2 F (p + u • d)) : |
| iteratedDeriv 2 (fun v : ℝ => F (p + v • d)) u = |
| iteratedFDeriv ℝ 2 F (p + u • d) (fun _ => d) := by |
| have h := iteratedDeriv_vcomp_two hf |
| (show ContDiffAt ℝ 2 (fun v : ℝ => p + v • d) u by fun_prop) |
| simpa [Function.comp_def, (affinePath_deriv p d u).deriv, |
| affinePath_iterated_two] using h |
|
|
| theorem iteratedDeriv_affinePath_three {F : E → ℝ} {p d : E} {u : ℝ} |
| (hf : ContDiffAt ℝ 3 F (p + u • d)) : |
| iteratedDeriv 3 (fun v : ℝ => F (p + v • d)) u = |
| iteratedFDeriv ℝ 3 F (p + u • d) (fun _ => d) := by |
| have h := iteratedDeriv_vcomp_three hf |
| (show ContDiffAt ℝ 3 (fun v : ℝ => p + v • d) u by fun_prop) |
| have hz₀ := (iteratedFDeriv ℝ 2 F (p + u • d)).map_coord_zero |
| (m := ![0, d]) 0 (by simp) |
| have hz₁ := (iteratedFDeriv ℝ 2 F (p + u • d)).map_coord_zero |
| (m := ![d, 0]) 1 (by simp) |
| simpa [Function.comp_def, (affinePath_deriv p d u).deriv, |
| affinePath_iterated_two, affinePath_iterated_three, hz₀, hz₁] using h |
|
|
| theorem compact_third_derivative_bound {O K : Set E} (hO : IsOpen O) |
| (hK : IsCompact K) (hKO : K ⊆ O) {F : E → ℝ} (hf : ContDiffOn ℝ 3 F O) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ p ∈ K, ‖iteratedFDeriv ℝ 3 F p‖ ≤ C := by |
| have hc : ContinuousOn (iteratedFDeriv ℝ 3 F) O := by |
| apply (hf.continuousOn_iteratedFDerivWithin (by norm_num) hO.uniqueDiffOn).congr |
| intro p hp |
| exact (iteratedFDerivWithin_eq_iteratedFDeriv hO.uniqueDiffOn |
| (hf.contDiffAt (hO.mem_nhds hp)) hp).symm |
| obtain ⟨C, hC⟩ := hK.exists_bound_of_continuousOn (hc.mono hKO) |
| refine ⟨max 0 C, le_max_left _ _, fun p hp => (hC p hp).trans (le_max_right _ _)⟩ |
|
|
| theorem compact_cubic_taylor_bound {O K : Set E} (hO : IsOpen O) |
| (hK : IsCompact K) (hcv : Convex ℝ K) (hKO : K ⊆ O) |
| {F : E → ℝ} (hf : ContDiffOn ℝ 3 F O) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ p ∈ K, ∀ q ∈ K, |
| |F q - F p - fderiv ℝ F p (q - p) - |
| (1 / 2 : ℝ) * iteratedFDeriv ℝ 2 F p (fun _ => q - p)| ≤ C * ‖q - p‖ ^ 3 := by |
| obtain ⟨C, hC0, hC⟩ := compact_third_derivative_bound hO hK hKO hf |
| refine ⟨C, hC0, ?_⟩ |
| intro p hp q hq |
| let d := q - p |
| let g : ℝ → ℝ := fun u => F (p + u • d) |
| have hpath (u : ℝ) (hu : u ∈ Icc (0 : ℝ) 1) : p + u • d ∈ K := |
| hcv.add_smul_sub_mem hp hq hu |
| have hF (u : ℝ) (hu : u ∈ Icc (0 : ℝ) 1) : ContDiffAt ℝ 3 F (p + u • d) := |
| hf.contDiffAt (hO.mem_nhds (hKO (hpath u hu))) |
| have hg (u : ℝ) (hu : u ∈ Icc (0 : ℝ) 1) : ContDiffAt ℝ 3 g u := |
| (hF u hu).comp u (by fun_prop) |
| have hthird (u : ℝ) (hu : u ∈ Icc (0 : ℝ) 1) : |
| ‖iteratedDerivWithin 3 g (Icc 0 1) u‖ ≤ C * ‖d‖ ^ 3 := by |
| rw [iteratedDerivWithin_eq_iteratedDeriv (uniqueDiffOn_Icc (by norm_num)) (hg u hu) hu] |
| change ‖iteratedDeriv 3 (fun v => F (p + v • d)) u‖ ≤ _ |
| rw [iteratedDeriv_affinePath_three (hF u hu)] |
| simpa using (iteratedFDeriv ℝ 3 F (p + u • d)).le_of_opNorm_le |
| (hC _ (hpath u hu)) (fun _ => d) |
| have hb := taylor_mean_remainder_bound (n := 2) (a := (0 : ℝ)) (b := 1) |
| (x := 1) (by norm_num) (fun u hu => (hg u hu).contDiffWithinAt) |
| (by constructor <;> norm_num) hthird |
| have h0 : (0 : ℝ) ∈ Icc (0 : ℝ) 1 := by constructor <;> norm_num |
| have hg0 : ContDiffAt ℝ 3 g 0 := hg 0 h0 |
| have hg1 : deriv g 0 = fderiv ℝ F p d := by |
| have hh := (hf.contDiffAt (hO.mem_nhds (hKO hp))).differentiableAt (by norm_num) |
| have hh' : HasFDerivAt F (fderiv ℝ F p) (p + (0 : ℝ) • d) := by simpa using hh.hasFDerivAt |
| simpa [g, Function.comp_def] using (hh'.comp_hasDerivAt 0 (affinePath_deriv p d 0)).deriv |
| have hg2 : iteratedDeriv 2 g 0 = iteratedFDeriv ℝ 2 F p (fun _ => d) := by |
| simpa [g] using iteratedDeriv_affinePath_two ((hF 0 h0).of_le (by norm_num)) |
| have ht : taylorWithinEval g 2 (Icc 0 1) 0 1 = |
| F p + fderiv ℝ F p d + (1 / 2 : ℝ) * iteratedFDeriv ℝ 2 F p (fun _ => d) := by |
| rw [taylorWithinEval_succ g 1, taylorWithinEval_succ g 0, taylor_within_zero_eval] |
| rw [iteratedDerivWithin_eq_iteratedDeriv (uniqueDiffOn_Icc (by norm_num)) |
| (hg0.of_le (by norm_num)) h0, |
| iteratedDerivWithin_eq_iteratedDeriv (uniqueDiffOn_Icc (by norm_num)) |
| (hg0.of_le (by norm_num)) h0] |
| simp only [hg2] |
| norm_num [g] |
| exact hg1 |
| rw [ht] at hb |
| have hg_end : g 1 = F q := by simp [g, d] |
| rw [hg_end] at hb |
| norm_num at hb |
| calc |
| _ = |F q - (F p + fderiv ℝ F p d + |
| (1 / 2 : ℝ) * iteratedFDeriv ℝ 2 F p (fun _ => d))| := by congr 1; dsimp [d]; ring |
| _ ≤ C * ‖d‖ ^ 3 / 2 := hb |
| _ ≤ C * ‖q - p‖ ^ 3 := div_le_self (by positivity) (by norm_num) |
|
|
| theorem kernelX_line_deriv {t x y a b u : ℝ} (_ht : t ∈ Ico (0 : ℝ) 1) |
| (hx : x + u * a ∈ Ioo (0 : ℝ) 1) (hy : y + u * b ∈ Ioo (0 : ℝ) 1) : |
| HasDerivAt (fun v : ℝ => kernelX t (x + v * a) (y + v * b)) |
| (kernelXX t (x + u * a) (y + u * b) * a + |
| kernelXY t (x + u * a) (y + u * b) * b) u := by |
| have hqx := (quantile_deriv hx).comp u (((hasDerivAt_id u).mul_const a).const_add x) |
| have hqy := (quantile_deriv hy).comp u (((hasDerivAt_id u).mul_const b).const_add y) |
| have h := (cdf_deriv (conditionalArg t (quantile (x + u * a)) (quantile (y + u * b)))).comp u |
| ((hqy.sub (hqx.const_mul t)).div_const (sigma t)) |
| convert h using 1 <;> try rfl |
| unfold kernelXX kernelXY plackett |
| field_simp [ne_of_gt (density_pos (quantile (x + u * a))), |
| ne_of_gt (density_pos (quantile (y + u * b)))] |
| ring |
|
|
| theorem kernel_line_deriv {t x y a b u : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) |
| (hx : x + u * a ∈ Ioo (0 : ℝ) 1) (hy : y + u * b ∈ Ioo (0 : ℝ) 1) : |
| HasDerivAt (fun v : ℝ => kernel t (x + v * a) (y + v * b)) |
| (kernelX t (x + u * a) (y + u * b) * a + |
| kernelX t (y + u * b) (x + u * a) * b) u := by |
| have hline : HasDerivAt (fun v : ℝ => (x + v * a, y + v * b)) (a, b) u := |
| by simpa using ((((hasDerivAt_id u).mul_const a).const_add x).prodMk |
| (((hasDerivAt_id u).mul_const b).const_add y)) |
| simpa [Function.comp_def, kernelD] using (kernel_fderiv ht ⟨hx, hy⟩).comp_hasDerivAt u hline |
|
|
| theorem kernel_line_second {t x y a b : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) |
| (hx : x ∈ Ioo (0 : ℝ) 1) (hy : y ∈ Ioo (0 : ℝ) 1) : |
| iteratedDeriv 2 (fun v : ℝ => kernel t (x + v * a) (y + v * b)) 0 = |
| kernelXX t x y * a ^ 2 + 2 * kernelXY t x y * a * b + kernelXX t y x * b ^ 2 := by |
| have hx' : x + (0 : ℝ) * a ∈ Ioo (0 : ℝ) 1 := by simpa using hx |
| have hy' : y + (0 : ℝ) * b ∈ Ioo (0 : ℝ) 1 := by simpa using hy |
| have hne : ∀ᶠ v : ℝ in 𝓝 0, x + v * a ∈ Ioo (0 : ℝ) 1 ∧ |
| y + v * b ∈ Ioo (0 : ℝ) 1 := by |
| have hc : ContinuousAt (fun v : ℝ => (x + v * a, y + v * b)) 0 := by fun_prop |
| exact hc.preimage_mem_nhds ((isOpen_Ioo.prod isOpen_Ioo).mem_nhds ⟨hx', hy'⟩) |
| have he : deriv (fun v : ℝ => kernel t (x + v * a) (y + v * b)) =ᶠ[𝓝 0] |
| (fun v => kernelX t (x + v * a) (y + v * b) * a + |
| kernelX t (y + v * b) (x + v * a) * b) := by |
| filter_upwards [hne] with v hv |
| exact (kernel_line_deriv ht hv.1 hv.2).deriv |
| have hd := ((kernelX_line_deriv ht hx' hy').mul_const a).add |
| ((kernelX_line_deriv ht hy' hx').mul_const b) |
| have heq : kernelXY t y x = kernelXY t x y := by |
| unfold kernelXY |
| rw [plackett_symm ⟨by linarith [ht.1], ht.2⟩ (quantile y) (quantile x), mul_comm] |
| rw [show (2 : ℕ) = 1 + 1 from rfl, iteratedDeriv_succ, iteratedDeriv_one, he.deriv_eq] |
| have hdd := hd.deriv |
| simp only [zero_mul, add_zero, heq] at hdd |
| convert hdd using 1 |
| ring |
|
|
| theorem kernel_second_diagonal {t : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) {p : ℝ × ℝ} |
| (hp : p ∈ Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1) (d : ℝ × ℝ) : |
| iteratedFDeriv ℝ 2 (Function.uncurry (kernel t)) p (fun _ => d) = |
| kernelXX t p.1 p.2 * d.1 ^ 2 + 2 * kernelXY t p.1 p.2 * d.1 * d.2 + |
| kernelXX t p.2 p.1 * d.2 ^ 2 := by |
| have hf : ContDiffAt ℝ 2 (Function.uncurry (kernel t)) (p + (0 : ℝ) • d) := by |
| simpa using (kernel_contDiffOn ht 2).contDiffAt |
| ((isOpen_Ioo.prod isOpen_Ioo).mem_nhds hp) |
| have he := iteratedDeriv_affinePath_two hf |
| simp only [zero_smul, add_zero] at he |
| rw [← he] |
| exact kernel_line_second ht hp.1 hp.2 |
|
|
| theorem norm_pair_cube_le (a b : ℝ) : ‖(a, b)‖ ^ 3 ≤ |a| ^ 3 + |b| ^ 3 := by |
| rw [Prod.norm_def, Real.norm_eq_abs, Real.norm_eq_abs] |
| rcases le_total |a| |b| with h | h |
| · rw [max_eq_right h]; exact le_add_of_nonneg_left (by positivity) |
| · rw [max_eq_left h]; exact le_add_of_nonneg_right (by positivity) |
|
|
| theorem kernel_uniform_cubic {t η : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) |
| (hη : 0 < η) (_hη' : η ≤ 1 / 2) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ p ∈ Icc η (1 - η) ×ˢ Icc η (1 - η), |
| ∀ q ∈ Icc η (1 - η) ×ˢ Icc η (1 - η), |
| |kernel t q.1 q.2 - kernel t p.1 p.2 - |
| (kernelX t p.1 p.2 * (q.1 - p.1) + kernelX t p.2 p.1 * (q.2 - p.2)) - |
| (1 / 2 : ℝ) * (kernelXX t p.1 p.2 * (q.1 - p.1) ^ 2 + |
| 2 * kernelXY t p.1 p.2 * (q.1 - p.1) * (q.2 - p.2) + |
| kernelXX t p.2 p.1 * (q.2 - p.2) ^ 2)| ≤ |
| C * (|q.1 - p.1| ^ 3 + |q.2 - p.2| ^ 3) := by |
| have hsub : Icc η (1 - η) ×ˢ Icc η (1 - η) ⊆ |
| Ioo (0 : ℝ) 1 ×ˢ Ioo (0 : ℝ) 1 := by |
| intro p hp |
| exact ⟨⟨hη.trans_le hp.1.1, by linarith [hp.1.2]⟩, |
| ⟨hη.trans_le hp.2.1, by linarith [hp.2.2]⟩⟩ |
| obtain ⟨C, hC0, hC⟩ := compact_cubic_taylor_bound (isOpen_Ioo.prod isOpen_Ioo) |
| (isCompact_Icc.prod isCompact_Icc) ((convex_Icc η (1 - η)).prod (convex_Icc η (1 - η))) |
| hsub (kernel_contDiffOn ht 3) |
| refine ⟨C, hC0, ?_⟩ |
| intro p hp q hq |
| have hb := hC p hp q hq |
| rw [(kernel_fderiv ht (hsub hp)).fderiv, kernel_second_diagonal ht (hsub hp)] at hb |
| change |kernel t q.1 q.2 - kernel t p.1 p.2 - |
| (kernelX t p.1 p.2 * (q.1 - p.1) + kernelX t p.2 p.1 * (q.2 - p.2)) - |
| (1 / 2 : ℝ) * (kernelXX t p.1 p.2 * (q.1 - p.1) ^ 2 + |
| 2 * kernelXY t p.1 p.2 * (q.1 - p.1) * (q.2 - p.2) + |
| kernelXX t p.2 p.1 * (q.2 - p.2) ^ 2)| ≤ C * ‖q - p‖ ^ 3 at hb |
| exact hb.trans (mul_le_mul_of_nonneg_left (norm_pair_cube_le (q.1 - p.1) (q.2 - p.2)) hC0) |
|
|
| def sign (b : Bool) : ℝ := if b then -1 else 1 |
|
|
| noncomputable def bitPairWeight (t : ℝ) (a b : Bool) : ℝ := (1 + t * sign a * sign b) / 4 |
|
|
| theorem bitPairWeight_nonneg {t : ℝ} (ht : t ∈ Set.Icc (-1 : ℝ) 1) (a b : Bool) : |
| 0 ≤ bitPairWeight t a b := by |
| cases a <;> cases b <;> simp [bitPairWeight, sign] <;> linarith [ht.1, ht.2] |
|
|
| theorem bitPairWeight_mass (t : ℝ) : ∑ a : Bool, ∑ b : Bool, bitPairWeight t a b = 1 := by |
| simp [bitPairWeight, sign]; ring |
|
|
| theorem bitPairWeight_marginal (t : ℝ) (a : Bool) : ∑ b : Bool, bitPairWeight t a b = 1 / 2 := by |
| cases a <;> simp [bitPairWeight, sign] <;> ring |
|
|
| theorem bitPairWeight_symm (t : ℝ) (a b : Bool) : bitPairWeight t a b = bitPairWeight t b a := by |
| unfold bitPairWeight; ring |
|
|
| theorem kernel_one_bit {t η : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) |
| (hη : 0 < η) (hη' : η ≤ 1 / 2) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ x y a b : ℝ, |
| (∀ e : Bool, x + sign e * a ∈ Icc η (1 - η)) → |
| (∀ e : Bool, y + sign e * b ∈ Icc η (1 - η)) → |
| (∑ e : Bool, ∑ f : Bool, bitPairWeight t e f * |
| kernel t (x + sign e * a) (y + sign f * b)) ≤ |
| kernel t x y + C * (|a| ^ 3 + |b| ^ 3) := by |
| obtain ⟨C, hC0, hC⟩ := kernel_uniform_cubic ht hη hη' |
| refine ⟨C, hC0, ?_⟩ |
| intro x y a b hx hy |
| have hxp : x ∈ Icc η (1 - η) := by |
| have hx0 := hx false; have hx1 := hx true |
| simp [sign] at hx0 hx1 |
| constructor <;> linarith [hx0.1, hx0.2, hx1.1, hx1.2] |
| have hyp : y ∈ Icc η (1 - η) := by |
| have hy0 := hy false; have hy1 := hy true |
| simp [sign] at hy0 hy1 |
| constructor <;> linarith [hy0.1, hy0.2, hy1.1, hy1.2] |
| let Q : Bool → Bool → ℝ := fun e f => kernel t x y + |
| (kernelX t x y * (sign e * a) + kernelX t y x * (sign f * b)) + |
| (1 / 2 : ℝ) * (kernelXX t x y * (sign e * a) ^ 2 + |
| 2 * kernelXY t x y * (sign e * a) * (sign f * b) + |
| kernelXX t y x * (sign f * b) ^ 2) + C * (|a| ^ 3 + |b| ^ 3) |
| have hpoint (e f : Bool) : kernel t (x + sign e * a) (y + sign f * b) ≤ Q e f := by |
| have hb := (hC (x, y) ⟨hxp, hyp⟩ (x + sign e * a, y + sign f * b) ⟨hx e, hy f⟩) |
| simp only [add_sub_cancel_left] at hb |
| have he : |sign e * a| = |a| := by cases e <;> simp [sign] |
| have hf : |sign f * b| = |b| := by cases f <;> simp [sign] |
| rw [he, hf] at hb |
| have hb' := (abs_le.mp hb).2 |
| dsimp [Q] |
| linarith |
| have hsum : (∑ e : Bool, ∑ f : Bool, bitPairWeight t e f * |
| kernel t (x + sign e * a) (y + sign f * b)) ≤ |
| ∑ e : Bool, ∑ f : Bool, bitPairWeight t e f * Q e f := by |
| apply Finset.sum_le_sum |
| intro e _ |
| apply Finset.sum_le_sum |
| intro f _ |
| exact mul_le_mul_of_nonneg_left (hpoint e f) |
| (bitPairWeight_nonneg ⟨by linarith [ht.1], ht.2.le⟩ e f) |
| have halg : (∑ e : Bool, ∑ f : Bool, bitPairWeight t e f * Q e f) = |
| kernel t x y + (1 / 2 : ℝ) * |
| (kernelXX t x y * a ^ 2 + 2 * t * kernelXY t x y * a * b + kernelXX t y x * b ^ 2) + |
| C * (|a| ^ 3 + |b| ^ 3) := by |
| simp only [Fintype.sum_bool, Q, bitPairWeight, sign, Bool.false_eq_true, ↓reduceIte] |
| ring |
| rw [halg] at hsum |
| linarith [kernel_weighted_hessian_nonpos ht x y a b] |
|
|
| theorem kernel_lipschitz_x {t x x' y : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) |
| (hx : x ∈ Ioo (0 : ℝ) 1) (hx' : x' ∈ Ioo (0 : ℝ) 1) (hy : y ∈ Ioo (0 : ℝ) 1) : |
| |kernel t x' y - kernel t x y| ≤ |x' - x| := by |
| have hb := Convex.norm_image_sub_le_of_norm_deriv_le |
| (f := fun z => kernel t z y) (C := 1) |
| (fun z hz => (kernel_deriv_x ht hz hy).differentiableAt) |
| (fun z hz => by |
| rw [(kernel_deriv_x ht hz hy).deriv, Real.norm_eq_abs, |
| abs_of_pos (cdf_mem_Ioo _).1] |
| exact (cdf_mem_Ioo _).2.le) |
| (convex_Ioo (0 : ℝ) 1) hx hx' |
| simpa only [Real.norm_eq_abs, one_mul] using hb |
|
|
| theorem kernel_lipschitz {t x x' y y' : ℝ} (ht : t ∈ Ico (0 : ℝ) 1) |
| (hx : x ∈ Ioo (0 : ℝ) 1) (hx' : x' ∈ Ioo (0 : ℝ) 1) |
| (hy : y ∈ Ioo (0 : ℝ) 1) (hy' : y' ∈ Ioo (0 : ℝ) 1) : |
| |kernel t x' y' - kernel t x y| ≤ |x' - x| + |y' - y| := by |
| have h1 := kernel_lipschitz_x ht hx hx' hy' |
| have h2 := kernel_lipschitz_x ht hy hy' hx |
| rw [kernel_symm ht y' x, kernel_symm ht y x] at h2 |
| calc |
| _ = |(kernel t x' y' - kernel t x y') + (kernel t x y' - kernel t x y)| := by congr 1; ring |
| _ ≤ |kernel t x' y' - kernel t x y'| + |kernel t x y' - kernel t x y| := abs_add_le _ _ |
| _ ≤ _ := add_le_add h1 h2 |
|
|
| end OptimalMaxCut.GaussianBellman |
|
|
| end |
|
|
| end OAI |
|
|
