| import Mathlib |
| import OAI.Probability.LogConcave.Model |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Filter |
| open scoped ENNReal NNReal Topology |
|
|
| section UpperProof |
| namespace LogConcaveSampling |
|
|
| theorem Admissible.continuous_firstOrderReply {d : ℕ} {V : Point d → ℝ} |
| (hV : Admissible V) : Continuous (firstOrderReply V) := by |
| have hg : Continuous (gradient V) := |
| (InnerProductSpace.toDual ℝ (Point d)).symm.continuous.comp |
| (hV.smooth.continuous_fderiv (by norm_num)) |
| exact hV.smooth.continuous.prodMk hg |
|
|
| theorem OracleAlgorithm.measurable_history {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ} |
| (A : OracleAlgorithm Ω d q) {V : Point d → ℝ} (hV : Admissible V) (n : ℕ) : |
| Measurable (fun ω => A.history V ω n) := by |
| induction n with |
| | zero => exact measurable_const |
| | succ n ih => |
| by_cases hn : n < q |
| · have hr : Measurable (fun ω => |
| firstOrderReply V (A.query ⟨n, hn⟩ (ω, A.history V ω n))) := |
| hV.continuous_firstOrderReply.measurable.comp |
| ((A.query_measurable ⟨n, hn⟩).comp (measurable_id.prodMk ih)) |
| apply Measurable.of_eval |
| intro i |
| by_cases hi : i = ⟨n, hn⟩ |
| · simpa [history, hn, Function.update_apply, hi] using hr |
| · simpa [history, hn, Function.update_apply, hi, Function.comp_def] using |
| (measurable_pi_apply i).comp ih |
| · simpa [history, hn] using ih |
|
|
| theorem OracleAlgorithm.measurable_run {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ} |
| (A : OracleAlgorithm Ω d q) {V : Point d → ℝ} (hV : Admissible V) : |
| Measurable (A.run V) := |
| A.output_measurable.comp (measurable_id.prodMk (A.measurable_history hV q)) |
|
|
| theorem queryComplexity_le_of_canSample {d q : ℕ} (h : CanSample d q) : |
| queryComplexity d ≤ (q : ℕ∞) := |
| sInf_le ⟨q, h, rfl⟩ |
|
|
| end LogConcaveSampling |
|
|
| namespace LogConcaveSampling |
| open scoped RealInnerProductSpace |
|
|
| theorem quadratic_lower_bound_of_hasDerivAt {f g h : ℝ → ℝ} {a : ℝ} |
| (hf : ∀ t, HasDerivAt f (g t) t) (hg : ∀ t, HasDerivAt g (h t) t) |
| (ha : ∀ t, a ≤ h t) : |
| f 0 + g 0 + a / 2 ≤ f 1 := by |
| have hd : ∀ t, HasDerivAt (fun s => g s - a * s) (h t - a) t := fun t => by |
| convert! (hg t).sub ((hasDerivAt_id t).const_mul a) using 1 |
| simp |
| have hm : Monotone (fun t => g t - a * t) := |
| monotone_of_hasDerivAt_nonneg hd (fun t => sub_nonneg.mpr (ha t)) |
| have hgt : ∀ t, 0 ≤ t → g 0 + a * t ≤ g t := by |
| intro t ht |
| have hh := hm ht |
| dsimp at hh |
| linarith |
| have he : ∀ t, HasDerivAt (fun s => f s - g 0 * s - a / 2 * s ^ 2) |
| (g t - g 0 - a * t) t := fun t => by |
| convert! ((hf t).sub ((hasDerivAt_id t).const_mul (g 0))).sub |
| (((hasDerivAt_id t).pow 2).const_mul (a / 2)) using 1 |
| simp |
| ring |
| have hem : MonotoneOn (fun t => f t - g 0 * t - a / 2 * t ^ 2) (Set.Ici 0) := |
| monotoneOn_of_hasDerivWithinAt_nonneg (convex_Ici 0) |
| (fun t _ => (he t).continuousAt.continuousWithinAt) |
| (fun t _ => (he t).hasDerivWithinAt) |
| (fun t ht => by |
| have ht0 : 0 ≤ t := Set.mem_Ici.mp (interior_subset ht) |
| have := hgt t ht0 |
| linarith) |
| have hend := hem (by simp : (0 : ℝ) ∈ Set.Ici 0) (by simp : (1 : ℝ) ∈ Set.Ici 0) |
| (by norm_num : (0 : ℝ) ≤ 1) |
| dsimp at hend |
| norm_num at hend |
| linarith |
|
|
| theorem quadratic_bounds_of_hasDerivAt {f g h : ℝ → ℝ} {a b : ℝ} |
| (hf : ∀ t, HasDerivAt f (g t) t) (hg : ∀ t, HasDerivAt g (h t) t) |
| (hb : ∀ t, a ≤ h t ∧ h t ≤ b) : |
| f 0 + g 0 + a / 2 ≤ f 1 ∧ f 1 ≤ f 0 + g 0 + b / 2 := by |
| refine ⟨quadratic_lower_bound_of_hasDerivAt hf hg (fun t => (hb t).1), ?_⟩ |
| have hn := quadratic_lower_bound_of_hasDerivAt |
| (fun t => (hf t).neg) (fun t => (hg t).neg) |
| (a := -b) (fun t => neg_le_neg (hb t).2) |
| dsimp at hn |
| linarith |
|
|
| theorem Admissible.contDiff_gradient {d : ℕ} {V : Point d → ℝ} |
| (hV : Admissible V) : ContDiff ℝ 1 (gradient V) := by |
| exact (InnerProductSpace.toDual ℝ (Point d)).symm.contDiff.comp |
| (hV.smooth.fderiv_right (by norm_num)) |
|
|
| theorem Admissible.quadratic_bounds {d : ℕ} {V : Point d → ℝ} |
| (hV : Admissible V) (x : Point d) : |
| ‖x‖ ^ 2 / 2 ≤ V x ∧ V x ≤ ‖x‖ ^ 2 := by |
| let f : ℝ → ℝ := fun t => V (t • x) |
| let g : ℝ → ℝ := fun t => inner ℝ x (gradient V (t • x)) |
| let h : ℝ → ℝ := fun t => inner ℝ x (fderiv ℝ (gradient V) (t • x) x) |
| have hp : ∀ t : ℝ, HasDerivAt (fun s : ℝ => s • x) x t := fun t => by |
| simpa using (hasDerivAt_id t).smul_const x |
| have hdg := hV.contDiff_gradient.differentiable (by norm_num) |
| have hf : ∀ t, HasDerivAt f (g t) t := by |
| intro t |
| have hh := ((hV.smooth.differentiable (by norm_num) (t • x)).hasFDerivAt).comp_hasDerivAt t (hp t) |
| convert! hh using 1 |
| change inner ℝ x (gradient V (t • x)) = fderiv ℝ V (t • x) x |
| rw [real_inner_comm] |
| exact InnerProductSpace.toDual_symm_apply |
| have hg : ∀ t, HasDerivAt g (h t) t := by |
| intro t |
| have hh := (hdg (t • x)).hasFDerivAt.comp_hasDerivAt t (hp t) |
| simpa [g, h, Function.comp_def] using |
| (hasDerivAt_const t x).inner ℝ hh |
| have ht := quadratic_bounds_of_hasDerivAt hf hg |
| (fun t => hV.hessian_bounds (t • x) x) |
| dsimp only [f, g] at ht |
| rw [zero_smul, one_smul, hV.value_zero, hV.gradient_zero, inner_zero_right, zero_add] at ht |
| constructor <;> linarith [ht.1, ht.2] |
|
|
| theorem integrable_gaussian_envelope (d : ℕ) {b : ℝ} (hb : 0 < b) : |
| Integrable (fun x : Point d => Real.exp (-b * ‖x‖ ^ 2)) := by |
| have hg := (GaussianFourier.integrable_cexp_neg_mul_sq_norm_add |
| (V := Point d) (b := (b : ℂ)) (by exact hb) 0 0).norm |
| convert! hg using 1 |
| funext x |
| simp [Complex.norm_exp, ← Complex.ofReal_pow, ← Complex.ofReal_mul] |
|
|
| theorem Admissible.integrable_exp_neg {d : ℕ} {V : Point d → ℝ} |
| (hV : Admissible V) : Integrable (fun x => Real.exp (-V x)) := by |
| apply (integrable_gaussian_envelope d (b := 1 / 2) (by norm_num)).mono' |
| ((Real.continuous_exp.comp hV.smooth.continuous.neg).aestronglyMeasurable) |
| exact Filter.Eventually.of_forall fun x => by |
| dsimp only [Function.comp_apply, Pi.neg_apply] |
| rw [Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)] |
| apply Real.exp_le_exp.mpr |
| have := (hV.quadratic_bounds x).1 |
| linarith |
|
|
| theorem Admissible.partition_ne_top {d : ℕ} {V : Point d → ℝ} |
| (hV : Admissible V) : partition V ≠ ⊤ := by |
| exact (lintegral_ofReal_ne_top_iff_integrable |
| hV.integrable_exp_neg.aestronglyMeasurable |
| (Filter.Eventually.of_forall fun x => (Real.exp_pos (-V x)).le)).2 |
| hV.integrable_exp_neg |
|
|
| theorem Admissible.partition_pos {d : ℕ} {V : Point d → ℝ} |
| (hV : Admissible V) : 0 < partition V := by |
| have hm : Measurable (gibbsDensity V) := |
| (ENNReal.continuous_ofReal.comp (Real.continuous_exp.comp hV.smooth.continuous.neg)).measurable |
| rw [partition, lintegral_pos_iff_support hm] |
| have hs : Function.support (gibbsDensity V) = Set.univ := by |
| ext x |
| simp [Function.mem_support, gibbsDensity, not_le_of_gt (Real.exp_pos (-V x))] |
| rw [hs] |
| exact isOpen_univ.measure_pos volume Set.univ_nonempty |
|
|
| theorem Admissible.isProbabilityMeasure_gibbs {d : ℕ} {V : Point d → ℝ} |
| (hV : Admissible V) : IsProbabilityMeasure (gibbs V) := by |
| constructor |
| rw [gibbs, Measure.smul_apply, withDensity_apply _ MeasurableSet.univ, |
| Measure.restrict_univ] |
| exact ENNReal.inv_mul_cancel hV.partition_pos.ne' hV.partition_ne_top |
|
|
| end LogConcaveSampling |
|
|
| end UpperProof |
| end |
| end |
| end |
|
|
| end OAI |
|
|
