| import OAI.Geometry.LatticeCovering.GaussianMoments |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
|
|
| namespace SingleLatticeCovering.GaussianProjection |
| open MeasureTheory ProbabilityTheory Set Filter |
| open SingleLatticeCovering.Isotropization |
| open scoped ENNReal RealInnerProductSpace BigOperators ComplexConjugate |
|
|
| lemma gaussian_matrix_char_average {n k : ℕ} (μ : Measure (E n)) [IsFiniteMeasure μ] |
| (a : ℝ) (t : E k) : |
| (∫ g : MatrixSpace n k, charFun μ (a•rowApply g t) ∂stdGaussian (MatrixSpace n k))= |
| (radialGaussianAverage μ (a*‖t‖) : ℂ) := by |
| have hm : Measurable (fun g : MatrixSpace n k => rowApply g t) := |
| (continuous_rowApply.comp (continuous_id.prodMk continuous_const)).measurable |
| have hi := integral_map (μ := stdGaussian (MatrixSpace n k)) hm.aemeasurable |
| (f := fun x : E n => charFun μ (a•x)) (by fun_prop) |
| rw [←hi,rowApply_gaussian_law,integral_map (by fun_prop) (by fun_prop)] |
| simp only [smul_smul] |
| exact gaussian_char_average μ _ |
|
|
| lemma matrix_phase_char_integrable {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) (y : E k) : |
| Integrable (fun p : MatrixSpace n k × E k => phase r y p.2*charFun μ ((-r*s)•rowApply p.1 p.2)) |
| ((stdGaussian (MatrixSpace n k)).prod (stdGaussian (E k))) := by |
| apply (integrable_const (1:ℝ)).mono' (by |
| have hc := continuous_rowApply (n := n) (k := k) |
| unfold phase |
| fun_prop) |
| exact Filter.Eventually.of_forall (fun p => by |
| simpa only [norm_mul,norm_phase,one_mul] using norm_charFun_le_one ((-r*s)•rowApply p.1 p.2)) |
|
|
| lemma radialSmoothedModel_eq_average {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) (y : E k) : radialSmoothedModel μ s r y= |
| Complex.ofReal (∫ g : MatrixSpace n k, smoothedProjection μ s r g y ∂stdGaussian (MatrixSpace n k)) := by |
| have H := integral_integral_swap (f := fun g t => phase r y t*charFun μ ((-r*s)•rowApply g t)) (matrix_phase_char_integrable μ s r y) |
| simp only [←smoothedProjection_fourier,integral_const_mul,gaussian_matrix_char_average, |
| integral_complex_ofReal] at H |
| exact H.symm |
|
|
| noncomputable def radialSmoothedDensity {n k : ℕ} (μ : Measure (E n)) (s r : ℝ) (y : E k) : ℝ := |
| (radialSmoothedModel μ s r y).re |
|
|
| lemma radialSmoothedDensity_nonneg {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) (y : E k) : 0 ≤ radialSmoothedDensity μ s r y := by |
| rw [radialSmoothedDensity,radialSmoothedModel_eq_average,Complex.ofReal_re] |
| exact integral_nonneg (fun g => integral_nonneg (fun x => (Real.exp_pos _).le)) |
|
|
| lemma radialSmoothedDensity_cast {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) (y : E k) : (radialSmoothedDensity μ s r y : ℂ)=radialSmoothedModel μ s r y := by |
| simp only [radialSmoothedDensity,radialSmoothedModel_eq_average,Complex.ofReal_re] |
|
|
| lemma radialSmoothedModel_invariant {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) (U : E k ≃ₗᵢ[ℝ] E k) (y : E k) : |
| radialSmoothedModel μ s r (U y)=radialSmoothedModel μ s r y := by |
| have hm : Measurable U := U.continuous.measurable |
| have H := integral_map (μ := stdGaussian (E k)) hm.aemeasurable |
| (f := fun t : E k => phase r (U y) t*(radialGaussianAverage μ ((-r*s)*‖t‖) : ℂ)) (by |
| have hc := continuous_radialGaussianAverage μ |
| unfold phase |
| fun_prop) |
| rw [stdGaussian_map U] at H |
| have he (t : E k) : phase r (U y) (U t)=phase r y t := by |
| simp only [phase,U.inner_map_map] |
| simp only [he,U.norm_map] at H |
| exact H |
|
|
| lemma radialSmoothedDensity_norm_eq {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) {y z : E k} (h : ‖y‖=‖z‖) : |
| radialSmoothedDensity μ s r y=radialSmoothedDensity μ s r z := by |
| have H := radialSmoothedModel_invariant μ s r (Submodule.reflection (ℝ ∙ (y-z))ᗮ) y |
| rw [Submodule.reflection_sub h] at H |
| exact congrArg Complex.re H.symm |
|
|
| lemma smoothedProjection_real_uniform_error {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) (g : MatrixSpace n k) (y : E k) : |
| |smoothedProjection μ s r g y-radialSmoothedDensity μ s r y| ≤ |
| matrixSmoothingError μ (-r*s) g := by |
| have H := smoothedProjection_uniform_error μ s r g y |
| rw [←radialSmoothedDensity_cast,←Complex.ofReal_sub,Complex.norm_real,Real.norm_eq_abs] at H |
| exact H |
|
|
| lemma continuous_smoothedProjection {n k : ℕ} (μ : Measure (E n)) [IsFiniteMeasure μ] |
| (s r : ℝ) : Continuous (fun p : MatrixSpace n k × E k => smoothedProjection μ s r p.1 p.2) := by |
| apply continuous_of_dominated (bound := fun _ => (1:ℝ)) |
| · intro p |
| have hc : Continuous (fun x : E n => colApply p.1 x) := continuous_colApply.comp (continuous_const.prodMk continuous_id) |
| fun_prop |
| · intro p |
| exact Filter.Eventually.of_forall (fun x => by |
| simpa only [Real.norm_eq_abs] using gaussianKernel_bounded r (p.2-s•colApply p.1 x)) |
| · exact integrable_const _ |
| · apply Filter.Eventually.of_forall |
| intro x |
| have hc : Continuous (fun g : MatrixSpace n k => colApply g x) := continuous_colApply.comp (continuous_id.prodMk continuous_const) |
| fun_prop |
|
|
| lemma smoothedProjection_le_one {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) (g : MatrixSpace n k) (y : E k) : smoothedProjection μ s r g y ≤ 1 := by |
| have hi : Integrable (fun x : E n => Real.exp (-r^2*‖y-s•colApply g x‖^2/2)) μ := by |
| apply (integrable_const (1:ℝ)).mono' (by |
| have hc : Continuous (fun x : E n => colApply g x) := continuous_colApply.comp (continuous_const.prodMk continuous_id) |
| fun_prop) |
| exact Filter.Eventually.of_forall (fun x => by simpa only [Real.norm_eq_abs] using gaussianKernel_bounded r (y-s•colApply g x)) |
| calc |
| _ ≤ ∫ _ : E n, (1:ℝ) ∂μ := integral_mono hi (integrable_const _) (fun x => (le_abs_self _).trans (gaussianKernel_bounded r _)) |
| _ = 1 := by simp |
|
|
| section ContinuousProjection |
| attribute [local irreducible] smoothedProjection |
|
|
| lemma continuous_smoothedProjection_y {n k : ℕ} (μ : Measure (E n)) [IsFiniteMeasure μ] |
| (s r : ℝ) (g : MatrixSpace n k) : Continuous (smoothedProjection μ s r g) := by |
| have hp : Continuous (fun y : E k => (g,y)) := continuous_const.prodMk continuous_id |
| exact (continuous_smoothedProjection μ s r).comp hp |
|
|
| lemma continuous_smoothedProjection_g {n k : ℕ} (μ : Measure (E n)) [IsFiniteMeasure μ] |
| (s r : ℝ) (y : E k) : Continuous (fun g : MatrixSpace n k => smoothedProjection μ s r g y) := by |
| have hp : Continuous (fun g : MatrixSpace n k => (g,y)) := continuous_id.prodMk continuous_const |
| exact (continuous_smoothedProjection μ s r).comp hp |
|
|
| end ContinuousProjection |
|
|
| lemma norm_smoothedProjection_le {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) (g : MatrixSpace n k) (y : E k) : ‖smoothedProjection μ s r g y‖ ≤ 1 := by |
| rw [Real.norm_eq_abs,abs_of_nonneg (show 0 ≤ smoothedProjection μ s r g y from integral_nonneg (fun _ => (Real.exp_pos _).le))] |
| exact smoothedProjection_le_one μ s r g y |
|
|
| lemma continuous_radialSmoothedDensity {n k : ℕ} (μ : Measure (E n)) [IsProbabilityMeasure μ] |
| (s r : ℝ) : Continuous (radialSmoothedDensity (k := k) μ s r) := by |
| have he : radialSmoothedDensity (k := k) μ s r = fun y => |
| ∫ g : MatrixSpace n k, smoothedProjection μ s r g y ∂stdGaussian (MatrixSpace n k) := by |
| ext y |
| simp only [radialSmoothedDensity,radialSmoothedModel_eq_average,Complex.ofReal_re] |
| rw [he] |
| apply continuous_of_dominated (bound := fun _ => (1:ℝ)) |
| · intro y |
| exact (continuous_smoothedProjection_g μ s r y).aestronglyMeasurable |
| · intro y |
| exact Filter.Eventually.of_forall (fun g => norm_smoothedProjection_le μ s r g y) |
| · exact integrable_const _ |
| · apply Filter.Eventually.of_forall |
| intro g |
| exact continuous_smoothedProjection_y μ s r g |
|
|
|
|
|
|
| end SingleLatticeCovering.GaussianProjection |
| noncomputable section |
| namespace SingleLatticeCovering.GaussianDensity |
| open MeasureTheory ProbabilityTheory Set Filter GaussianFourier |
| open scoped ENNReal RealInnerProductSpace ComplexConjugate |
| abbrev E (k : ℕ) := EuclideanSpace ℝ (Fin k) |
|
|
| def normalizer (k : ℕ) (b : ℝ) : ℝ := (Real.pi/b)^((k:ℝ)/2) |
| def density {k : ℕ} (b : ℝ) (y : E k) : ℝ := (normalizer k b)⁻¹*Real.exp (-b*‖y‖^2) |
| def law (k : ℕ) (b : ℝ) : Measure (E k) := |
| volume.withDensity (fun y => ENNReal.ofReal (density b y)) |
|
|
| lemma normalizer_pos (k : ℕ) {b : ℝ} (hb : 0 < b) : 0 < normalizer k b := by |
| unfold normalizer |
| positivity |
| lemma density_pos {k : ℕ} {b : ℝ} (hb : 0 < b) (y : E k) : 0 < density b y := by |
| unfold density |
| exact mul_pos (inv_pos.mpr (normalizer_pos k hb)) (Real.exp_pos _) |
| lemma continuous_density (k : ℕ) (b : ℝ) : Continuous (density (k := k) b) := by |
| unfold density |
| fun_prop |
| lemma integrable_kernel {k : ℕ} {b : ℝ} (hb : 0 < b) : |
| Integrable (fun y : E k => Real.exp (-b*‖y‖^2)) volume := by |
| have H := integrable_cexp_neg_mul_sq_norm_add (V := E k) (b := (b:ℂ)) hb 0 (0:E k) |
| have H' := H.re |
| simpa only [zero_mul,add_zero,←Complex.ofReal_pow,←Complex.ofReal_mul,←Complex.ofReal_neg, |
| RCLike.re_to_complex, Complex.exp_ofReal_re] using H' |
| lemma integral_kernel {k : ℕ} {b : ℝ} (hb : 0 < b) : |
| (∫ y : E k, Real.exp (-b*‖y‖^2))=normalizer k b := by |
| simpa only [normalizer,finrank_euclideanSpace_fin] using integral_rexp_neg_mul_sq_norm (V := E k) hb |
| lemma integrable_density {k : ℕ} {b : ℝ} (hb : 0 < b) : Integrable (density (k := k) b) volume := |
| (integrable_kernel hb).const_mul _ |
| lemma integral_density {k : ℕ} {b : ℝ} (hb : 0 < b) : (∫ y : E k, density b y)=1 := by |
| unfold density |
| rw [integral_const_mul,integral_kernel hb,inv_mul_cancel₀ (ne_of_gt (normalizer_pos k hb))] |
| lemma law_probability (k : ℕ) {b : ℝ} (hb : 0 < b) : IsProbabilityMeasure (law k b) := by |
| constructor |
| rw [law,withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ] |
| rw [←ofReal_integral_eq_lintegral_ofReal (integrable_density hb) |
| (Filter.Eventually.of_forall (fun y => (density_pos hb y).le)),integral_density hb] |
| norm_num |
|
|
| lemma integral_law {k : ℕ} {b : ℝ} (hb : 0 < b) {F : Type*} |
| [NormedAddCommGroup F] [NormedSpace ℝ F] (f : E k → F) : |
| (∫ y, f y ∂law k b) = ∫ y, density b y • f y := by |
| have H := integral_withDensity_eq_integral_toReal_smul (μ := (volume : Measure (E k))) |
| (f := fun y => ENNReal.ofReal (density b y)) (g := f) |
| ((ENNReal.continuous_ofReal.comp (continuous_density k b)).measurable) |
| (Filter.Eventually.of_forall (fun y => ENNReal.ofReal_lt_top)) |
| simpa only [law,ENNReal.toReal_ofReal (density_pos hb _).le] using H |
|
|
| lemma charFun_law {k : ℕ} {b : ℝ} (hb : 0 < b) (t : E k) : |
| charFun (law k b) t=Complex.exp (-(‖t‖:ℂ)^2/(4*b)) := by |
| rw [charFun_apply,integral_law hb] |
| have he (y : E k) : density b y • Complex.exp (⟪y,t⟫*Complex.I)= |
| ((normalizer k b)⁻¹:ℂ)*Complex.exp (-(b:ℂ)*‖y‖^2+Complex.I*⟪t,y⟫) := by |
| rw [density,Complex.real_smul] |
| push_cast |
| rw [mul_assoc,←Complex.exp_add,real_inner_comm y t] |
| congr 2 |
| ring |
| simp_rw [he] |
| rw [integral_const_mul,integral_cexp_neg_mul_sq_norm_add (V := E k) (b := (b:ℂ)) hb Complex.I t] |
| have hc : (Real.pi/(b:ℂ))^((Module.finrank ℝ (E k):ℂ)/2)=(normalizer k b:ℂ) := by |
| rw [normalizer,finrank_euclideanSpace_fin,←Complex.ofReal_div,Complex.ofReal_cpow (by positivity)] |
| push_cast |
| rfl |
| have hn : (normalizer k b:ℂ) ≠ 0 := by exact_mod_cast ne_of_gt (normalizer_pos k hb) |
| rw [hc,←mul_assoc,inv_mul_cancel₀ hn,one_mul] |
| congr 1 |
| rw [Complex.I_sq] |
| ring |
|
|
| lemma stdGaussian_eq_law (k : ℕ) : stdGaussian (E k)=law k (1/2) := by |
| let := law_probability k (show (0:ℝ) < 1/2 by norm_num) |
| apply Measure.ext_of_charFun |
| funext t |
| rw [charFun_stdGaussian,charFun_law (by norm_num)] |
| congr 1 |
| push_cast |
| ring |
|
|
|
|
| end SingleLatticeCovering.GaussianDensity |
|
|
| namespace SingleLatticeCovering.GaussianDensity |
| open MeasureTheory ProbabilityTheory Set Filter GaussianFourier |
| open scoped ENNReal RealInnerProductSpace |
|
|
| lemma density_mul_exp {k : ℕ} (b t : ℝ) (y : E k) : |
| density b y*Real.exp (t*‖y‖^2)=(normalizer k b)⁻¹*Real.exp (-(b-t)*‖y‖^2) := by |
| unfold density |
| rw [mul_assoc,←Real.exp_add] |
| congr 2 |
| ring |
|
|
| lemma integrable_exp_norm_sq {k : ℕ} {b t : ℝ} (hb : 0 < b) (ht : t < b) : |
| Integrable (fun y : E k => Real.exp (t*‖y‖^2)) (law k b) := by |
| have H := integrable_withDensity_iff_integrable_smul' (μ := (volume : Measure (E k))) |
| (f := fun y => ENNReal.ofReal (density b y)) (g := fun y => Real.exp (t*‖y‖^2)) |
| ((ENNReal.continuous_ofReal.comp (continuous_density k b)).measurable) |
| (Filter.Eventually.of_forall (fun y => ENNReal.ofReal_lt_top)) |
| apply H.mpr |
| simp only [ENNReal.toReal_ofReal (density_pos hb _).le,smul_eq_mul,density_mul_exp] |
| exact (integrable_kernel (sub_pos.mpr ht)).const_mul _ |
|
|
| lemma integral_exp_norm_sq {k : ℕ} {b t : ℝ} (hb : 0 < b) (ht : t < b) : |
| (∫ y : E k, Real.exp (t*‖y‖^2) ∂law k b)=(normalizer k b)⁻¹*normalizer k (b-t) := by |
| rw [integral_law hb] |
| simp only [smul_eq_mul,density_mul_exp] |
| rw [integral_const_mul,integral_kernel (sub_pos.mpr ht)] |
|
|
| lemma normalizer_eq_exp (k : ℕ) {b : ℝ} (hb : 0 < b) : |
| normalizer k b=Real.exp (((k:ℝ)/2)*(Real.log Real.pi-Real.log b)) := by |
| unfold normalizer |
| rw [Real.rpow_def_of_pos (div_pos Real.pi_pos hb),Real.log_div Real.pi_ne_zero (ne_of_gt hb)] |
| congr 1 |
| ring |
|
|
| lemma stdGaussian_laplace_norm_sq {k : ℕ} {a : ℝ} (ha : a < 1) : |
| (∫ y : E k, Real.exp (a*‖y‖^2/2) ∂stdGaussian (E k))= |
| Real.exp (-((k:ℝ)/2)*Real.log (1-a)) := by |
| rw [stdGaussian_eq_law] |
| have he (y : E k) : a*‖y‖^2/2=(a/2)*‖y‖^2 := by ring |
| simp_rw [he] |
| rw [integral_exp_norm_sq (by norm_num) (by linarith), |
| normalizer_eq_exp k (by norm_num),normalizer_eq_exp k (by linarith), |
| ←Real.exp_neg,←Real.exp_add] |
| have hl : Real.log ((1:ℝ)/2-a/2)=Real.log ((1:ℝ)/2)+Real.log (1-a) := by |
| rw [show (1:ℝ)/2-a/2=(1/2)*(1-a) by ring,Real.log_mul (by norm_num) (by linarith)] |
| rw [hl] |
| congr 1 |
| ring |
|
|
| lemma stdGaussian_integrable_exp_norm_sq {k : ℕ} {a : ℝ} (ha : a < 1) : |
| Integrable (fun y : E k => Real.exp (a*‖y‖^2/2)) (stdGaussian (E k)) := by |
| rw [stdGaussian_eq_law] |
| have he (y : E k) : a*‖y‖^2/2=(a/2)*‖y‖^2 := by ring |
| simp_rw [he] |
| exact integrable_exp_norm_sq (by norm_num) (by linarith) |
|
|
|
|
| end SingleLatticeCovering.GaussianDensity |
|
|
| namespace SingleLatticeCovering.GaussianDensity |
| open MeasureTheory ProbabilityTheory Set Filter GaussianFourier |
| open scoped ENNReal RealInnerProductSpace Topology |
|
|
| lemma integral_real_quadratic {k : ℕ} {b : ℝ} (hb : 0 < b) (c : ℝ) (w : E k) : |
| (∫ y : E k, Real.exp (-b*‖y‖^2+c*⟪w,y⟫))= |
| normalizer k b*Real.exp (c^2*‖w‖^2/(4*b)) := by |
| have H := integral_cexp_neg_mul_sq_norm_add (V := E k) (b := (b:ℂ)) hb (c:ℂ) w |
| have hc : (Real.pi/(b:ℂ))^((Module.finrank ℝ (E k):ℂ)/2)=(normalizer k b:ℂ) := by |
| rw [normalizer,finrank_euclideanSpace_fin,←Complex.ofReal_div,Complex.ofReal_cpow (by positivity)] |
| push_cast |
| rfl |
| rw [hc] at H |
| apply Complex.ofReal_injective |
| rw [←integral_complex_ofReal] |
| convert H using 1 <;> push_cast <;> rfl |
|
|
| lemma normalizer_ratio_half (k : ℕ) {v : ℝ} (hv : 0 < v) : |
| (normalizer k (1/2))⁻¹*normalizer k (v/2)=Real.exp (-((k:ℝ)/2)*Real.log v) := by |
| rw [normalizer_eq_exp k (by norm_num),normalizer_eq_exp k (by positivity),←Real.exp_neg,←Real.exp_add] |
| have hh : Real.log (v/2)= Real.log ((1:ℝ)/2)+Real.log v := by |
| rw [show v/2=(1/2)*v by ring,Real.log_mul (by norm_num) (ne_of_gt hv)] |
| rw [hh] |
| congr 1 |
| ring |
|
|
| lemma gaussian_convolution_kernel {k : ℕ} (a r : ℝ) (y : E k) : |
| (∫ z : E k, Real.exp (-r^2*‖y-a•z‖^2/2) ∂stdGaussian (E k))= |
| Real.exp (-((k:ℝ)/2)*Real.log (1+r^2*a^2)-r^2*‖y‖^2/(2*(1+r^2*a^2))) := by |
| have hv : 0 < 1+r^2*a^2 := by positivity |
| rw [stdGaussian_eq_law,integral_law (by norm_num)] |
| have he (z : E k) : density (1/2) z • Real.exp (-r^2*‖y-a•z‖^2/2)= |
| ((normalizer k (1/2))⁻¹*Real.exp (-r^2*‖y‖^2/2))* |
| Real.exp (-((1+r^2*a^2)/2)*‖z‖^2+(r^2*a)*⟪y,z⟫) := by |
| rw [density,smul_eq_mul,mul_assoc,←Real.exp_add,mul_assoc,←Real.exp_add] |
| congr 2 |
| rw [norm_sub_sq_real,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,inner_smul_right] |
| ring |
| simp_rw [he] |
| rw [integral_const_mul,integral_real_quadratic (show 0 < (1+r^2*a^2)/2 by positivity)] |
| have hre : ((normalizer k (1/2))⁻¹*Real.exp (-r^2*‖y‖^2/2))* |
| (normalizer k ((1+r^2*a^2)/2)*Real.exp ((r^2*a)^2*‖y‖^2/(4*((1+r^2*a^2)/2))))= |
| ((normalizer k (1/2))⁻¹*normalizer k ((1+r^2*a^2)/2))* |
| (Real.exp (-r^2*‖y‖^2/2)*Real.exp ((r^2*a)^2*‖y‖^2/(4*((1+r^2*a^2)/2)))) := by ring |
| rw [hre,normalizer_ratio_half k hv,←Real.exp_add,←Real.exp_add] |
| congr 1 |
| field_simp |
| ring |
|
|
|
|
| end SingleLatticeCovering.GaussianDensity |
|
|
| namespace SingleLatticeCovering.GaussianProjection |
| open MeasureTheory ProbabilityTheory Set Filter GaussianDensity |
| open SingleLatticeCovering.Isotropization |
| open scoped ENNReal RealInnerProductSpace Topology |
|
|
| lemma colApply_gaussian_law {n k : ℕ} (x : Isotropization.E n) : |
| (stdGaussian (MatrixSpace n k)).map (fun g => colApply g x)= |
| (stdGaussian (Isotropization.E k)).map (fun y => ‖x‖•y) := by |
| have hm : Measurable (fun g : MatrixSpace n k => colApply g x) := |
| (continuous_colApply.comp (continuous_id.prodMk continuous_const)).measurable |
| apply Measure.ext_of_charFun |
| funext t |
| rw [charFun_apply,integral_map hm.aemeasurable (by fun_prop), |
| charFun_apply,integral_map (by fun_prop) (by fun_prop)] |
| have he (g : MatrixSpace n k) : ⟪colApply g x,t⟫=⟪g,tensor x t⟫ := by |
| rw [inner_colApply] |
| exact (real_inner_comm _ _).trans (inner_rowApply g x t) |
| have he' (y : Isotropization.E k) : (‖x‖*⟪y,t⟫ : ℝ)=⟪y,‖x‖•t⟫ := by rw [inner_smul_right] |
| simp only [he,inner_smul_left,conj_trivial,he',←charFun_apply,charFun_stdGaussian] |
| congr 1 |
| rw [←Complex.ofReal_pow,←Complex.ofReal_pow,norm_tensor_sq,norm_smul, |
| Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _),mul_pow] |
|
|
| lemma kernel_normalization {k : ℕ} {r : ℝ} (hr : r ≠ 0) (a : ℝ) (y : Isotropization.E k) : |
| (normalizer k (r^2/2))⁻¹* |
| Real.exp (-((k:ℝ)/2)*Real.log (1+r^2*a^2)-r^2*‖y‖^2/(2*(1+r^2*a^2)))= |
| density (1/(2*(a^2+1/r^2))) y := by |
| have hr2 : 0 < r^2 := sq_pos_of_ne_zero hr |
| have hv : 0 < a^2+1/r^2 := by positivity |
| have hv' : 0 < 1+r^2*a^2 := by positivity |
| have hb : 0 < 1/(2*(a^2+1/r^2)) := by positivity |
| have hlog : Real.log (1/(2*(a^2+1/r^2)))= |
| Real.log (r^2/2)-Real.log (1+r^2*a^2) := by |
| rw [←Real.log_div (by positivity) (ne_of_gt hv')] |
| congr 1 |
| field_simp |
| ring |
| rw [density,normalizer_eq_exp k (by positivity),normalizer_eq_exp k hb, |
| ←Real.exp_neg,←Real.exp_neg,←Real.exp_add,←Real.exp_add,hlog] |
| congr 1 |
| field_simp |
| ring |
|
|
| lemma radialSmoothedDensity_mixture {n k : ℕ} (μ : Measure (Isotropization.E n)) |
| [IsProbabilityMeasure μ] (s r : ℝ) (y : Isotropization.E k) : |
| radialSmoothedDensity μ s r y= |
| ∫ x, Real.exp (-((k:ℝ)/2)*Real.log (1+r^2*(s*‖x‖)^2)- |
| r^2*‖y‖^2/(2*(1+r^2*(s*‖x‖)^2))) ∂μ := by |
| have hj : Integrable (fun p : MatrixSpace n k × Isotropization.E n => |
| Real.exp (-r^2*‖y-s•colApply p.1 p.2‖^2/2)) ((stdGaussian (MatrixSpace n k)).prod μ) := by |
| apply (integrable_const (1:ℝ)).mono' (by |
| have hc := continuous_colApply (n := n) (k := k) |
| fun_prop) |
| exact Filter.Eventually.of_forall (fun p => by |
| simpa only [Real.norm_eq_abs] using gaussianKernel_bounded r (y-s•colApply p.1 p.2)) |
| rw [radialSmoothedDensity,radialSmoothedModel_eq_average,Complex.ofReal_re] |
| unfold smoothedProjection |
| rw [integral_integral_swap hj] |
| apply integral_congr_ae |
| apply Filter.Eventually.of_forall |
| intro x |
| have hm : Measurable (fun g : MatrixSpace n k => colApply g x) := |
| (continuous_colApply.comp (continuous_id.prodMk continuous_const)).measurable |
| dsimp only |
| rw [←integral_map (μ := stdGaussian (MatrixSpace n k)) hm.aemeasurable (f := fun z => Real.exp (-r^2*‖y-s•z‖^2/2)) (by fun_prop), |
| colApply_gaussian_law,integral_map (by fun_prop) (by fun_prop)] |
| simp only [smul_smul] |
| exact gaussian_convolution_kernel _ _ _ |
|
|
| lemma normalized_radialSmoothedDensity_mixture {n k : ℕ} (μ : Measure (Isotropization.E n)) |
| [IsProbabilityMeasure μ] (s : ℝ) {r : ℝ} (hr : r ≠ 0) (y : Isotropization.E k) : |
| (normalizer k (r^2/2))⁻¹*radialSmoothedDensity μ s r y= |
| ∫ x, density (1/(2*((s*‖x‖)^2+1/r^2))) y ∂μ := by |
| rw [radialSmoothedDensity_mixture,←integral_const_mul] |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall (fun x => kernel_normalization hr _ _) |
|
|
|
|
| end SingleLatticeCovering.GaussianProjection |
|
|
|
|
|
|
|
|
|
|
| open MeasureTheory Filter Set |
| open scoped Topology |
| noncomputable section |
|
|
|
|
|
|
| namespace SingleLatticeCovering.Prekopa |
| open MeasureTheory Set Filter |
| open SingleLatticeCovering.SharpYoung |
| open scoped ENNReal |
|
|
| lemma weighted_transport_inequality {u v a b : ℝ} |
| (hu : 0 < u) (hv : 0 < v) (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a+b=1) : |
| u ≤ (a+b*(u/v))*(u^a*v^b) := by |
| have hgm : (u/v)^b ≤ a+b*(u/v) := by |
| simpa only [Real.one_rpow,one_mul,mul_one] using |
| Real.geom_mean_le_arith_mean2_weighted ha hb (show (0:ℝ) ≤ 1 by norm_num) |
| (div_pos hu hv).le hab |
| have he : (u/v)^b*(u^a*v^b)=u := by |
| rw [Real.div_rpow hu.le hv.le] |
| have hpow : v^b ≠ 0 := (Real.rpow_pos_of_pos hv _).ne' |
| calc |
| u^b/v^b*(u^a*v^b) = u^a*u^b := by field_simp |
| _ = u^(a+b) := (Real.rpow_add hu _ _).symm |
| _ = u := by rw [hab,Real.rpow_one] |
| calc |
| u = (u/v)^b*(u^a*v^b) := he.symm |
| _ ≤ (a+b*(u/v))*(u^a*v^b) := mul_le_mul_of_nonneg_right hgm (by positivity) |
|
|
|
|
|
|
|
|
| theorem positive_probability_lintegral (f g : PositiveDensity) {h : ℝ → ℝ} |
| {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a+b=1) |
| (hh : ∀ x y, f x ^ a * g y ^ b ≤ h (a*x+b*y)) : |
| 1 ≤ ∫⁻ z, ENNReal.ofReal (h z) := by |
| let T : ℝ → ℝ := densityTransport f g |
| let W : ℝ → ℝ := fun x => a*x+b*T x |
| let W' : ℝ → ℝ := fun x => a+b*(f x/g (T x)) |
| have hT : StrictMono T := (densityTransport f g).strictMono |
| have hW : StrictMono W := by |
| intro x y hxy |
| exact add_lt_add (mul_lt_mul_of_pos_left hxy ha) |
| (mul_lt_mul_of_pos_left (hT hxy) hb) |
| have hd (x : ℝ) : HasDerivAt W (W' x) x := by |
| simpa only [W,W',T,id_eq,Pi.add_def,mul_one] using |
| ((hasDerivAt_id x).const_mul a).add ((densityTransport_hasDerivAt f g x).const_mul b) |
| have hp (x : ℝ) : 0 < W' x := by |
| dsimp [W']; exact add_pos ha (mul_pos hb (div_pos (f.positive x) (g.positive _))) |
| have hi : (∫⁻ x, ENNReal.ofReal (f x))=1 := by |
| rw [←ofReal_integral_eq_lintegral_ofReal f.integrable |
| (Filter.Eventually.of_forall fun x => (f.positive x).le),f.integral_one] |
| norm_num |
| calc |
| 1 = ∫⁻ x, ENNReal.ofReal (f x) := hi.symm |
| _ ≤ ∫⁻ x, ENNReal.ofReal |W' x| *ENNReal.ofReal (h (W x)) := by |
| apply lintegral_mono |
| intro x |
| change ENNReal.ofReal (f x) ≤ ENNReal.ofReal |W' x| * ENNReal.ofReal (h (W x)) |
| rw [abs_of_pos (hp x),←ENNReal.ofReal_mul (hp x).le] |
| apply ENNReal.ofReal_le_ofReal |
| exact (weighted_transport_inequality (f.positive x) (g.positive (T x)) ha.le hb.le hab).trans |
| (mul_le_mul_of_nonneg_left (hh x (T x)) (hp x).le) |
| _ = ∫⁻ z in W '' univ, ENNReal.ofReal (h z) := by |
| symm |
| simpa using lintegral_image_eq_lintegral_abs_deriv_mul MeasurableSet.univ |
| (fun x _ => (hd x).hasDerivWithinAt) hW.injective.injOn (fun z => ENNReal.ofReal (h z)) |
| _ ≤ ∫⁻ z, ENNReal.ofReal (h z) := |
| lintegral_mono' Measure.restrict_le_self (le_refl _) |
|
|
|
|
| end SingleLatticeCovering.Prekopa |
|
|
| namespace SingleLatticeCovering.Prekopa |
| open MeasureTheory Set Filter |
| open SingleLatticeCovering.SharpYoung SingleLatticeCovering.SimplexYoung |
| open scoped ENNReal |
|
|
|
|
|
|
| theorem positive_integral {f g h : ℝ → ℝ} |
| (fc : Continuous f) (gc : Continuous g) (fp : ∀ x, 0 < f x) (gp : ∀ x, 0 < g x) |
| (fi : Integrable f volume) (gi : Integrable g volume) (hi : Integrable h volume) |
| (hn : ∀ x, 0 ≤ h x) {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a+b=1) |
| (hfg : ∀ x y, f x^a*g y^b ≤ h (a*x+b*y)) : |
| (∫ x, f x)^a*(∫ y, g y)^b ≤ ∫ z, h z := by |
| let F := normalizePositiveDensity f fc fp fi |
| let G := normalizePositiveDensity g gc gp gi |
| let M := (∫ x, f x)^a*(∫ y, g y)^b |
| have hfpos := integral_pos_of_continuous_density fp fi |
| have hgpos := integral_pos_of_continuous_density gp gi |
| have hM : 0 < M := mul_pos (Real.rpow_pos_of_pos hfpos _) (Real.rpow_pos_of_pos hgpos _) |
| have hh : ∀ x y, F x^a*G y^b ≤ (h (a*x+b*y))/M := by |
| intro x y |
| dsimp [F,G,normalizePositiveDensity,M] |
| rw [Real.div_rpow (fp x).le hfpos.le,Real.div_rpow (gp y).le hgpos.le, |
| div_mul_div_comm] |
| exact div_le_div_of_nonneg_right (hfg x y) hM.le |
| have hineq := positive_probability_lintegral F G (h := fun z => h z/M) ha hb hab hh |
| rw [←ofReal_integral_eq_lintegral_ofReal (hi.div_const M) |
| (Filter.Eventually.of_forall (fun z => div_nonneg (hn z) hM.le)),integral_div] at hineq |
| have ht : (1:ℝ) ≤ (∫ z, h z)/M := by |
| exact (ENNReal.ofReal_le_ofReal_iff (div_nonneg (integral_nonneg hn) hM.le)).mp (by simpa using hineq) |
| have := (le_div_iff₀ hM).mp ht |
| simpa only [one_mul] using this |
|
|
|
|
| end SingleLatticeCovering.Prekopa |
|
|
| namespace SingleLatticeCovering.Prekopa |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology BigOperators |
|
|
| abbrev RV (d : ℕ) := Fin d → ℝ |
|
|
| def gaussianKernel (d : ℕ) (c : ℝ) (x : RV d) : ℝ := |
| Real.exp (-c*∑ i, (x i)^2) |
|
|
| lemma gaussianKernel_prod (d : ℕ) (c : ℝ) (x : RV d) : |
| gaussianKernel d c x = ∏ i, Real.exp (-c*(x i)^2) := by |
| rw [gaussianKernel,Finset.mul_sum,Real.exp_sum] |
|
|
| lemma gaussianKernel_pos (d : ℕ) (c : ℝ) (x : RV d) : 0 < gaussianKernel d c x := Real.exp_pos _ |
|
|
| lemma gaussianKernel_le_one (d : ℕ) {c : ℝ} (hc : 0 ≤ c) (x : RV d) : |
| gaussianKernel d c x ≤ 1 := by |
| apply Real.exp_le_one_iff.mpr |
| exact mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr hc) (Finset.sum_nonneg (fun _ _ => sq_nonneg _)) |
|
|
| lemma continuous_gaussianKernel (d : ℕ) (c : ℝ) : Continuous (gaussianKernel d c) := by |
| unfold gaussianKernel |
| fun_prop |
|
|
| lemma integrable_gaussianKernel (d : ℕ) {c : ℝ} (hc : 0 < c) : |
| Integrable (gaussianKernel d c) volume := by |
| have H : Integrable (fun x : RV d => ∏ i, Real.exp (-c*(x i)^2)) volume := |
| Integrable.fintype_prod (fun _ : Fin d => integrable_exp_neg_mul_sq hc) |
| have he : gaussianKernel d c = (fun x : RV d => ∏ i, Real.exp (-c*(x i)^2)) := |
| funext (gaussianKernel_prod d c) |
| rw [he] |
| exact H |
|
|
| lemma integral_gaussianKernel (d : ℕ) (c : ℝ) : |
| (∫ x, gaussianKernel d c x) = (Real.sqrt (Real.pi/c))^d := by |
| simp_rw [gaussianKernel_prod] |
| rw [integral_fintype_prod_volume_eq_prod (fun _ : Fin d => fun t : ℝ => Real.exp (-c*t^2))] |
| simp only [integral_gaussian,Finset.prod_const,Finset.card_univ,Fintype.card_fin] |
|
|
| lemma gaussianKernel_cons (d : ℕ) (c t : ℝ) (y : RV d) : |
| gaussianKernel (d+1) c (Fin.cons t y)=Real.exp (-c*t^2)*gaussianKernel d c y := by |
| simp only [gaussianKernel,Fin.sum_univ_succ,Fin.cons_zero,Fin.cons_succ,mul_add,Real.exp_add] |
|
|
|
|
|
|
| def GaussianBound {d : ℕ} (f : RV d → ℝ) : Prop := |
| ∃ A c : ℝ, 0 < A ∧ 0 < c ∧ ∀ x, |f x| ≤ A*gaussianKernel d c x |
|
|
| lemma GaussianBound.integrable {d : ℕ} {f : RV d → ℝ} |
| (hf : GaussianBound f) (hc : Continuous f) : Integrable f volume := by |
| obtain ⟨A,c,hA,hc',hb⟩ := hf |
| apply ((integrable_gaussianKernel d hc').const_mul A).mono' hc.aestronglyMeasurable |
| exact Filter.Eventually.of_forall (fun x => by simpa only [Real.norm_eq_abs] using hb x) |
|
|
| lemma gaussian_slice_dominant {d : ℕ} {f : RV (d+1) → ℝ} {A c : ℝ} |
| (hA : 0 ≤ A) (hc : 0 ≤ c) (hbound : ∀ x, |f x| ≤ A*gaussianKernel (d+1) c x) |
| (y : RV d) (t : ℝ) : |f (Fin.cons t y)| ≤ A*Real.exp (-c*t^2) := by |
| calc |
| _ ≤ A*gaussianKernel (d+1) c (Fin.cons t y) := hbound _ |
| _ = (A*Real.exp (-c*t^2))*gaussianKernel d c y := by rw [gaussianKernel_cons,mul_assoc] |
| _ ≤ A*Real.exp (-c*t^2) := mul_le_of_le_one_right (by positivity) (gaussianKernel_le_one d hc y) |
|
|
| lemma GaussianBound.integrable_slice {d : ℕ} {f : RV (d+1) → ℝ} |
| (hf : GaussianBound f) (hc : Continuous f) (y : RV d) : |
| Integrable (fun t : ℝ => f (Fin.cons t y)) volume := by |
| obtain ⟨A,c,hA,hc',hb⟩ := hf |
| apply ((integrable_exp_neg_mul_sq hc').const_mul A).mono' |
| (hc.comp (continuous_id.finCons continuous_const)).aestronglyMeasurable |
| exact Filter.Eventually.of_forall (fun t => by |
| simpa only [Real.norm_eq_abs,Function.comp_def,id_eq] using gaussian_slice_dominant hA.le hc'.le hb y t) |
|
|
| def marginalOne {d : ℕ} (f : RV (d+1) → ℝ) (y : RV d) : ℝ := |
| ∫ t, f (Fin.cons t y) |
|
|
| lemma GaussianBound.continuous_marginalOne {d : ℕ} {f : RV (d+1) → ℝ} |
| (hf : GaussianBound f) (hc : Continuous f) : Continuous (marginalOne f) := by |
| obtain ⟨A,c,hA,hc',hb⟩ := hf |
| apply continuous_of_dominated |
| (bound := fun t : ℝ => A*Real.exp (-c*t^2)) |
| · intro y |
| exact (hc.comp (continuous_id.finCons continuous_const)).aestronglyMeasurable |
| · intro y |
| exact Filter.Eventually.of_forall (fun t => by |
| simpa only [Real.norm_eq_abs,Function.comp_def,id_eq] using gaussian_slice_dominant hA.le hc'.le hb y t) |
| · exact (integrable_exp_neg_mul_sq hc').const_mul A |
| · exact Filter.Eventually.of_forall (fun t => hc.comp (continuous_const.finCons continuous_id)) |
|
|
| lemma marginalOne_positive {d : ℕ} {f : RV (d+1) → ℝ} |
| (hf : GaussianBound f) (hc : Continuous f) (hp : ∀ x, 0 < f x) (y : RV d) : |
| 0 < marginalOne f y := |
| SingleLatticeCovering.SimplexYoung.integral_pos_of_continuous_density |
| (fun t => hp (Fin.cons t y)) (hf.integrable_slice hc y) |
|
|
| lemma GaussianBound.for_marginalOne {d : ℕ} {f : RV (d+1) → ℝ} |
| (hf : GaussianBound f) (hc : Continuous f) : GaussianBound (marginalOne f) := by |
| obtain ⟨A,c,hA,hc',hb⟩ := hf |
| have hg : GaussianBound f := ⟨A,c,hA,hc',hb⟩ |
| refine ⟨A*Real.sqrt (Real.pi/c),c,mul_pos hA (Real.sqrt_pos.mpr (div_pos Real.pi_pos hc')),hc',?_⟩ |
| intro y |
| have hi := hg.integrable_slice hc y |
| calc |
| |marginalOne f y| ≤ ∫ t, |f (Fin.cons t y)| := by |
| simpa only [Real.norm_eq_abs,marginalOne] using norm_integral_le_integral_norm (fun t => f (Fin.cons t y)) |
| _ ≤ ∫ t, (A*gaussianKernel d c y)*Real.exp (-c*t^2) := by |
| apply integral_mono hi.norm ((integrable_exp_neg_mul_sq hc').const_mul _) |
| intro t |
| calc |
| _ ≤ A*gaussianKernel (d+1) c (Fin.cons t y) := hb _ |
| _ = _ := by rw [gaussianKernel_cons]; ring |
| _ = (A*Real.sqrt (Real.pi/c))*gaussianKernel d c y := by |
| rw [integral_const_mul,integral_gaussian] |
| ring |
|
|
| lemma integral_marginalOne {d : ℕ} {f : RV (d+1) → ℝ} (hi : Integrable f volume) : |
| (∫ y, marginalOne f y) = ∫ x, f x := by |
| have hm := (volume_preserving_piFinSuccAbove (fun _ : Fin (d+1) => ℝ) 0).symm |
| have he := hm.integral_comp' f |
| have hj := (hm.integrable_comp hi.aestronglyMeasurable).mpr hi |
| simp only [MeasurableEquiv.piFinSuccAbove_symm_apply,Fin.insertNthEquiv_zero,Function.comp_def] at he hj |
| rw [←he] |
| exact (integral_prod_symm (fun p : ℝ × RV d => f (Fin.cons p.1 p.2)) hj).symm |
|
|
|
|
| end SingleLatticeCovering.Prekopa |
|
|
|
|
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
