| import Mathlib |
| import OAI.Probability.LogConcave.LowerBounds.WeightedEvaluation |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Filter |
| open scoped ENNReal NNReal Topology |
|
|
| section LowerProof |
| open Matrix Topology TopologicalSpace ProbabilityTheory Classical WithLp |
| open scoped Matrix.Norms.Elementwise |
| open WithLp |
| open MeasureTheory ProbabilityTheory |
| open scoped ENNReal NNReal |
| open Matrix |
| open Polynomial |
| open scoped BigOperators |
|
|
| namespace LogConcaveSampling.LowerBound |
|
|
| theorem diagonalStatistic_eq_dotProduct {d : ℕ} (c u : Fin d → ℝ) : |
| diagonalStatistic c u = dotProduct u (Matrix.diagonal c *ᵥ u) := by |
| simp only [diagonalStatistic, Matrix.mulVec_diagonal, dotProduct] |
| apply Finset.sum_congr rfl |
| intro k _ |
| ring |
|
|
| theorem normStatistic_eq_dotProduct {d : ℕ} (u : Fin d → ℝ) : |
| diagonalStatistic (fun _ => 1) u = dotProduct u u := by |
| simp [diagonalStatistic, dotProduct, pow_two] |
|
|
| theorem separationThreshold_eq {d q : ℕ} (hd : 0 < d) : |
| 2 * blockTolerance d q * (2*d) = separationThreshold d q := by |
| have hdr : (0 : ℝ) < d := by exact_mod_cast hd |
| have hs := Real.sq_sqrt hdr.le |
| have hsn : Real.sqrt (d : ℝ) ≠ 0 := by positivity |
| unfold blockTolerance separationThreshold |
| field_simp |
| nlinarith |
|
|
| theorem algorithm_span_separation_bound {Ω : Type*} [MeasurableSpace Ω] |
| {P : Measure Ω} [IsProbabilityMeasure P] {d q : ℕ} |
| (hqd : 4*q+1 < 2*d) (ht : blockTolerance d q ≤ 1/2) |
| {rows : Ω → Fin d → Fin (q+1) → ℝ} |
| (hrows : HasLaw rows (gaussianRows d (q+1)) P) (U : Ω → Fin d → ℝ) |
| (hU : ∀ᵐ ω ∂P, U ω ∈ krylovSpace (rows ω)) : |
| P.real {ω | U ω ∈ separationEvent d q} ≤ 1/100 := by |
| obtain ⟨G,hG,hm,hgood⟩ := lower_span_statistic hqd ht |
| have hsub : {ω | U ω ∈ separationEvent d q} ≤ᵐ[P] {ω | rows ω ∈ Gᶜ} := by |
| filter_upwards [hU] with ω hu |
| intro hsep |
| change rows ω ∉ G |
| intro hg |
| have hstat := hgood (rows ω) hg (U ω) hu |
| rw [← diagonalStatistic_eq_dotProduct, ← normStatistic_eq_dotProduct] at hstat |
| have hn := hsep.1 |
| have hs := hsep.2 |
| have hbound : 2 * blockTolerance d q * diagonalStatistic (fun _ => 1) (U ω) ≤ |
| separationThreshold d q := by |
| rw [← separationThreshold_eq (by omega : 0 < d)] |
| exact mul_le_mul_of_nonneg_left hn (mul_nonneg (by norm_num) (blockTolerance_pos (q := q) (by omega : 0 < d)).le) |
| exact (not_lt_of_ge (hstat.trans hbound)) hs |
| have hmono := ENNReal.toReal_mono (measure_ne_top P {ω | rows ω ∈ Gᶜ}) |
| (measure_mono_ae hsub) |
| change P.real {ω | U ω ∈ separationEvent d q} ≤ P.real {ω | rows ω ∈ Gᶜ} at hmono |
| have hlaw : P.real {ω | rows ω ∈ Gᶜ} = (gaussianRows d (q+1)).real Gᶜ := |
| hrows.measureReal_eq hG.compl |
| rw [hlaw, measureReal_compl hG, probReal_univ] at hmono |
| linarith |
|
|
| end LogConcaveSampling.LowerBound |
|
|
| namespace LogConcaveSampling.LowerBound |
| open scoped RealInnerProductSpace |
| open Matrix WithLp |
|
|
| def spectrumOperator (d : ℕ) : Point d →L[ℝ] Point d := |
| Matrix.toEuclideanCLM (n := Fin d) (𝕜 := ℝ) (Matrix.diagonal (fun k : Fin d => eigenvalue d k)) |
|
|
| @[simp] theorem spectrumOperator_apply {d : ℕ} (x : Point d) (k : Fin d) : |
| spectrumOperator d x k = eigenvalue d k * x k := by |
| change (Matrix.diagonal (fun k : Fin d => eigenvalue d k) *ᵥ ofLp x) k = _ |
| exact Matrix.mulVec_diagonal _ _ _ |
|
|
| def quadraticOperator {d : ℕ} (O : Rotations d) : Point d →L[ℝ] Point d := |
| (rotationIsometry O).toContinuousLinearEquiv.toContinuousLinearMap.comp |
| ((spectrumOperator d).comp (rotationIsometry O).symm.toContinuousLinearEquiv.toContinuousLinearMap) |
|
|
| def quadraticPotential {d : ℕ} (O : Rotations d) (x : Point d) : ℝ := |
| inner ℝ x (quadraticOperator O x) / 2 |
|
|
| lemma spectrumOperator_symmetric (d : ℕ) : |
| (spectrumOperator d).toLinearMap.IsSymmetric := by |
| intro x y |
| change inner ℝ (spectrumOperator d x) y = inner ℝ x (spectrumOperator d y) |
| simp only [PiLp.inner_apply, Real.inner_apply, spectrumOperator_apply] |
| apply Finset.sum_congr rfl |
| intro k _ |
| ring |
|
|
| lemma quadraticOperator_symmetric {d : ℕ} (O : Rotations d) : |
| (quadraticOperator O).toLinearMap.IsSymmetric := by |
| intro x y |
| change inner ℝ ((rotationIsometry O) (spectrumOperator d ((rotationIsometry O).symm x))) y = |
| inner ℝ x ((rotationIsometry O) (spectrumOperator d ((rotationIsometry O).symm y))) |
| rw [← (rotationIsometry O).apply_symm_apply y, ← (rotationIsometry O).apply_symm_apply x] |
| simp only [LinearIsometryEquiv.symm_apply_apply, LinearIsometryEquiv.inner_map_map] |
| exact spectrumOperator_symmetric d _ _ |
|
|
| lemma quadraticOperator_bounds {d : ℕ} (O : Rotations d) (x : Point d) : |
| ‖x‖^2 ≤ inner ℝ x (quadraticOperator O x) ∧ |
| inner ℝ x (quadraticOperator O x) ≤ 2 * ‖x‖^2 := by |
| let y := (rotationIsometry O).symm x |
| have hinner : inner ℝ x (quadraticOperator O x) = |
| ∑ k : Fin d, eigenvalue d k * (y k)^2 := by |
| change inner ℝ x ((rotationIsometry O) (spectrumOperator d y)) = _ |
| rw [← (rotationIsometry O).apply_symm_apply x] |
| simp only [LinearIsometryEquiv.inner_map_map, PiLp.inner_apply, Real.inner_apply, |
| spectrumOperator_apply] |
| apply Finset.sum_congr rfl |
| intro k _ |
| dsimp [y] |
| ring |
| have hnorm : ‖x‖^2 = ∑ k : Fin d, (y k)^2 := by |
| rw [← (rotationIsometry O).symm.norm_map x, EuclideanSpace.norm_sq_eq] |
| simp only [Real.norm_eq_abs, sq_abs] |
| rfl |
| rw [hinner, hnorm, Finset.mul_sum] |
| constructor |
| · apply Finset.sum_le_sum |
| intro k _ |
| have hb := (eigenvalue_bounds d k).1 |
| nlinarith [sq_nonneg (y k)] |
| · apply Finset.sum_le_sum |
| intro k _ |
| exact mul_le_mul_of_nonneg_right (eigenvalue_bounds d k).2 (sq_nonneg _) |
|
|
| lemma quadraticPotential_hasGradientAt {d : ℕ} (O : Rotations d) (x : Point d) : |
| HasGradientAt (quadraticPotential O) (quadraticOperator O x) x := by |
| apply hasGradientAt_iff_hasFDerivAt.mpr |
| have hd := ((hasFDerivAt_id x).inner ℝ (quadraticOperator O).hasFDerivAt).const_smul (1 / 2 : ℝ) |
| convert! hd using 1 |
| · ext y |
| simp only [quadraticPotential, Pi.smul_apply, smul_eq_mul, id_eq] |
| ring |
| ext y |
| have hs := quadraticOperator_symmetric O x y |
| change inner ℝ (quadraticOperator O x) y = inner ℝ x (quadraticOperator O y) at hs |
| change inner ℝ (quadraticOperator O x) y = |
| (1 / 2 : ℝ) * (inner ℝ x (quadraticOperator O y) + inner ℝ y (quadraticOperator O x)) |
| rw [← hs, real_inner_comm y (quadraticOperator O x)] |
| ring |
|
|
| @[simp] theorem quadraticPotential_gradient {d : ℕ} (O : Rotations d) : |
| gradient (quadraticPotential O) = quadraticOperator O := |
| gradient_eq (quadraticPotential_hasGradientAt O) |
|
|
| theorem quadraticPotential_admissible {d : ℕ} (O : Rotations d) : |
| Admissible (quadraticPotential O) := by |
| refine ⟨?_, ?_, ?_, ?_⟩ |
| · exact (contDiff_id.inner ℝ (quadraticOperator O).contDiff).div_const 2 |
| · simp [quadraticPotential] |
| · simp |
| · intro x v |
| rw [quadraticPotential_gradient, (quadraticOperator O).fderiv] |
| exact quadraticOperator_bounds O v |
|
|
| theorem quadratic_firstOrderReply {d : ℕ} (O : Rotations d) (x : Point d) : |
| firstOrderReply (quadraticPotential O) x = |
| (inner ℝ x (quadraticOperator O x) / 2, quadraticOperator O x) := by |
| simp [firstOrderReply, quadraticPotential] |
|
|
| end LogConcaveSampling.LowerBound |
|
|
| end LowerProof |
| end |
| end |
| end |
|
|
| end OAI |
|
|
