| import Mathlib |
| import OAI.Analysis.HardSphere.Bridges.BridgeResidual |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
| noncomputable section |
| open MeasureTheory MeasureTheory.Measure Set Filter |
| open scoped ENNReal NNReal Topology BigOperators |
| namespace HardSphere.GaussianPacking |
| abbrev Point := Fin 3 → ℝ |
| def square (x : Point) : ℝ := ∑j,x j^2 |
| def kernel (b : ℝ) (x : Point) : ℝ := Real.exp (-b*square x) |
| def cube (q : Point) (δ : ℝ) : Set Point := Icc (fun j ↦ q j-δ) (fun j ↦ q j+δ) |
|
|
| lemma kernel_product (b : ℝ) (x : Point) : kernel b x=∏j,Real.exp (-b*x j^2) := by |
| rw [kernel,square,Finset.mul_sum,Real.exp_sum] |
|
|
| lemma kernel_integrable {b : ℝ} (hb : 0<b) : Integrable (kernel b) volume := by |
| rw [show kernel b = (fun x : Point ↦ ∏j,Real.exp (-b*x j^2)) from funext (kernel_product b)] |
| exact Integrable.fintype_prod (fun _ ↦ integrable_exp_neg_mul_sq hb) |
|
|
| lemma kernel_integral (b : ℝ) : (∫x,kernel b x)=(Real.sqrt (Real.pi/b))^3 := by |
| simp only [kernel_product] |
| convert integral_fintype_prod_volume_eq_prod (fun (_ : Fin 3) (y : ℝ) ↦ Real.exp (-b*y^2)) using 1 |
| simp only [integral_gaussian,Finset.prod_const,Finset.card_univ,Fintype.card_fin] |
|
|
| lemma cube_real_volume (q : Point) {δ : ℝ} (hδ : 0≤δ) : volume.real (cube q δ)=(2*δ)^3 := by |
| rw [Measure.real,cube,Real.volume_Icc_pi_toReal (by intro j; dsimp; linarith)] |
| simp only [show ∀j,(q j+δ)-(q j-δ)=2*δ by intro j; ring,Finset.prod_const,Finset.card_univ,Fintype.card_fin] |
|
|
| lemma cube_coord {q y : Point} {δ : ℝ} (hy : y∈cube q δ) (j : Fin 3) : |
| |y j-q j|≤δ := by |
| rw [abs_le] |
| constructor <;> have h1:=hy.1 j <;> have h2:=hy.2 j <;> dsimp at * <;> linarith |
|
|
| lemma square_triangle (x y : Point) : square (x+y)≤2*square x+2*square y := by |
| simp only [square,Pi.add_apply] |
| rw [Finset.mul_sum, Finset.mul_sum, ←Finset.sum_add_distrib] |
| apply Finset.sum_le_sum |
| intro j hj |
| nlinarith [sq_nonneg (x j-y j)] |
|
|
| lemma square_le_of_coord {x : Point} {δ : ℝ} (hδ : 0≤δ) (hx : ∀j,|x j|≤δ) : |
| square x≤3*δ^2 := by |
| unfold square |
| calc |
| _ ≤ ∑_j : Fin 3,δ^2 := Finset.sum_le_sum (fun j _ ↦ by simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg _) hδ).mpr (hx j)) |
| _ = _ := by simp [Finset.sum_const] |
|
|
| lemma cube_kernel_lower {b δ : ℝ} (hb : 0≤b) (hδ : 0≤δ) (x q : Point) |
| {y : Point} (hy : y∈cube q δ) : |
| kernel b (x-q) ≤ Real.exp (3*b*δ^2)*kernel (b/2) (x-y) := by |
| have ht : square (x-y)≤2*square (x-q)+6*δ^2 := by |
| have he : x-y=(x-q)+(q-y) := by ext j; simp |
| rw [he] |
| apply (square_triangle _ _).trans |
| have hx : square (q-y)≤3*δ^2 := square_le_of_coord hδ (fun j ↦ by |
| simpa only [Pi.sub_apply,abs_sub_comm] using cube_coord hy j) |
| linarith |
| rw [kernel,kernel,←Real.exp_add] |
| apply Real.exp_le_exp.mpr |
| nlinarith [mul_le_mul_of_nonneg_left ht hb] |
|
|
| lemma cubes_disjoint {m : ℕ} (q : Fin m → Point) {ε δ : ℝ} (hε : 0<ε) (hδ : 0≤δ) |
| (hδε : 4*δ≤ε) (hsep : ∀i j,i≠j → ε^2 ≤ square (q i-q j)) : |
| Pairwise (fun i j ↦ Disjoint (cube (q i) δ) (cube (q j) δ)) := by |
| intro i j hij |
| apply disjoint_left.mpr |
| intro y hyi hyj |
| have hxy : square (q i-q j)≤3*(2*δ)^2 := square_le_of_coord (by positivity) (fun k ↦ by |
| have h1:=cube_coord hyi k |
| have h2:=cube_coord hyj k |
| rw [abs_le] at h1 h2 ⊢ |
| change -(2*δ)≤q i k-q j k ∧ q i k-q j k≤2*δ |
| constructor <;> linarith) |
| have he := hsep i j hij |
| have hd : (4*δ)^2≤ε^2 := (sq_le_sq₀ (by positivity) hε.le).mpr hδε |
| nlinarith [sq_pos_of_pos hε] |
|
|
| lemma kernel_translate_integrable {b : ℝ} (hb : 0 < b) (x : Point) : |
| Integrable (fun y ↦ kernel b (x-y)) volume := |
| (integrable_comp_sub_left (kernel b) x).mpr (kernel_integrable hb) |
|
|
| lemma sum_kernel_le {m : ℕ} (q : Fin m → Point) (x : Point) |
| {b ε δ : ℝ} (hb : 0 < b) (hε : 0 < ε) (hδ : 0 < δ) |
| (hδε : 4*δ ≤ ε) (hsep : ∀i j, i≠j → ε^2 ≤ square (q i-q j)) : |
| (∑i,kernel b (x-q i)) ≤ |
| Real.exp (3*b*δ^2)*(Real.sqrt (Real.pi/(b/2)))^3/(2*δ)^3 := by |
| have hi := kernel_translate_integrable (by positivity : 0 < b/2) x |
| have hp := cubes_disjoint q hε hδ.le hδε hsep |
| have hc (i : Fin m) : (2*δ)^3*kernel b (x-q i) ≤ |
| Real.exp (3*b*δ^2)*∫y in cube (q i) δ,kernel (b/2) (x-y) := by |
| have hn : (∫y in cube (q i) δ, kernel b (x-q i)) ≤ |
| ∫y in cube (q i) δ,Real.exp (3*b*δ^2)*kernel (b/2) (x-y) := by |
| apply integral_mono_ae (integrableOn_const (μ:=volume) (s:=cube (q i) δ) (C:=kernel b (x-q i)) (IsCompact.measure_lt_top isCompact_Icc).ne) |
| ((hi.const_mul _).integrableOn) |
| filter_upwards [ae_restrict_mem measurableSet_Icc] with y hy |
| exact cube_kernel_lower hb.le hδ.le x (q i) hy |
| simpa only [integral_const,measureReal_restrict_apply_univ,smul_eq_mul, |
| cube_real_volume _ hδ.le,integral_const_mul] using hn |
| have hs := Finset.sum_le_sum (fun i (_ : i∈Finset.univ) ↦ hc i) |
| rw [←Finset.mul_sum,←Finset.mul_sum] at hs |
| have heu : (∫y in ⋃i,cube (q i) δ,kernel (b/2) (x-y)) = ∑i,∫y in cube (q i) δ,kernel (b/2) (x-y) := |
| integral_iUnion_fintype (fun i ↦ (measurableSet_Icc : MeasurableSet (cube (q i) δ))) hp (fun _ ↦ hi.integrableOn) |
| rw [←heu] at hs |
| have hm : (∫y in ⋃i,cube (q i) δ,kernel (b/2) (x-y)) ≤ |
| (Real.sqrt (Real.pi/(b/2)))^3 := by |
| apply (integral_mono_measure Measure.restrict_le_self |
| (Eventually.of_forall (fun y ↦ (Real.exp_pos _).le)) hi).trans_eq |
| exact (integral_sub_left_eq_self (kernel (b/2)) volume x).trans (kernel_integral _) |
| have ht := hs.trans (mul_le_mul_of_nonneg_left hm (Real.exp_pos _).le) |
| exact (le_div_iff₀ (by positivity : 0 < (2*δ)^3)).mpr (by simpa only [mul_comm] using ht) |
|
|
| end HardSphere.GaussianPacking |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| open MeasureTheory MeasureTheory.Measure Set Filter ProbabilityTheory |
| open scoped ENNReal NNReal Topology BigOperators |
| namespace HardSphere.Bridge |
| open Wiener GaussianPacking |
| abbrev Noise := Fin 3 → C(Time,ℝ) |
| def law : Measure Noise := Measure.pi (fun _ ↦ bridgeLaw) |
| instance : IsProbabilityMeasure law := by unfold law; infer_instance |
|
|
| def eval (s : Time) (β : Noise) : Point := fun j ↦ β j s |
| def remainder (s : Time) (β : Noise) : Noise := fun j ↦ bridgeRemainder s (β j) |
| lemma eval_measurable (s : Time) : Measurable (eval s) := |
| Measurable.of_eval fun coordinate ↦ |
| (continuous_eval_const s).measurable.comp (measurable_pi_apply coordinate) |
| lemma remainder_measurable (s : Time) : Measurable (remainder s) := by unfold remainder; fun_prop |
|
|
| def variance (s : Time) : ℝ≥0 := Real.toNNReal ((s:ℝ)-(s:ℝ)^2) |
| lemma scalar_eval (s : Time) : bridgeLaw.map (fun β : C(Time,ℝ) ↦ β s)=gaussianReal 0 (variance s) := by |
| rw [bridgeLaw,Measure.map_map (continuous_eval_const s).measurable measurable_bridge] |
| exact (bridge_eval_law s).map_eq |
| lemma scalar_remainder (s : Time) : bridgeLaw.map (bridgeRemainder s)= |
| bridgeLaw.map (fun β ↦ Real.sqrt (1-(s:ℝ)) • β) := by |
| rw [bridgeLaw,Measure.map_map (bridgeRemainder s).continuous.measurable measurable_bridge] |
| exact bridgeRemainder_law s |
| lemma scalar_joint (s : Time) : bridgeLaw.map (fun β : C(Time,ℝ) ↦ (β s,bridgeRemainder s β))= |
| (gaussianReal 0 (variance s)).prod (bridgeLaw.map (fun β ↦ Real.sqrt (1-(s:ℝ)) • β)) := by |
| rw [bridgeLaw,Measure.map_map (by fun_prop) measurable_bridge] |
| simp only [Function.comp_def] |
| have hj := (bridgeRemainder_independent s).map_prod_eq_prod_map_map |
| (((continuous_eval_const s).measurable.comp measurable_bridge).aemeasurable) |
| (((bridgeRemainder s).continuous.measurable.comp measurable_bridge).aemeasurable) |
| simp only [Function.comp_def] at hj |
| rw [(bridge_eval_law s).map_eq,bridgeRemainder_law] at hj |
| exact hj |
|
|
| lemma eval_law (s : Time) : law.map (eval s)=Measure.pi (fun _ : Fin 3 ↦ gaussianReal 0 (variance s)) := by |
| unfold law eval |
| rw [Measure.pi_map_pi (fun _ ↦ (show Measurable (fun β : C(Time,ℝ) ↦ β s) from (continuous_eval_const s).measurable).aemeasurable)] |
| simp_rw [scalar_eval] |
| lemma remainder_law (s : Time) : law.map (remainder s)= |
| law.map (fun β : Noise ↦ fun j ↦ Real.sqrt (1-(s:ℝ)) • β j) := by |
| unfold law remainder |
| rw [Measure.pi_map_pi (fun _ ↦ (bridgeRemainder s).continuous.measurable.aemeasurable), |
| Measure.pi_map_pi (fun _ ↦ (show Measurable (fun β : C(Time,ℝ) ↦ Real.sqrt (1-(s:ℝ)) • β) from by fun_prop).aemeasurable)] |
| simp_rw [scalar_remainder] |
|
|
| lemma joint_law (s : Time) : law.map (fun β ↦ (eval s β,remainder s β))= |
| (Measure.pi (fun _ : Fin 3 ↦ gaussianReal 0 (variance s))).prod (law.map (remainder s)) := by |
| have hp := measurePreserving_arrowProdEquivProdArrow ℝ C(Time,ℝ) (Fin 3) |
| (fun _ ↦ gaussianReal 0 (variance s)) (fun _ ↦ bridgeLaw.map (fun β ↦ Real.sqrt (1-(s:ℝ)) • β)) |
| have he : law.map (fun β : Noise ↦ fun j ↦ (β j s,bridgeRemainder s (β j)))= |
| Measure.pi (fun _ : Fin 3 ↦ (gaussianReal 0 (variance s)).prod (bridgeLaw.map (fun β ↦ Real.sqrt (1-(s:ℝ)) • β))) := by |
| unfold law |
| rw [Measure.pi_map_pi (fun _ ↦ (show Measurable (fun β : C(Time,ℝ) ↦ (β s,bridgeRemainder s β)) from by fun_prop).aemeasurable)] |
| simp_rw [scalar_joint] |
| rw [remainder_law] |
| have her : law.map (fun β : Noise ↦ fun j ↦ Real.sqrt (1-(s:ℝ)) • β j)= |
| Measure.pi (fun _ : Fin 3 ↦ bridgeLaw.map (fun β ↦ Real.sqrt (1-(s:ℝ)) • β)) := by |
| unfold law |
| rw [Measure.pi_map_pi (fun _ ↦ (show Measurable (fun β : C(Time,ℝ) ↦ Real.sqrt (1-(s:ℝ)) • β) from by fun_prop).aemeasurable)] |
| rw [her,←hp.map_eq,←he,Measure.map_map hp.measurable (by fun_prop)] |
| rfl |
|
|
| lemma independent (s : Time) : IndepFun (eval s) (remainder s) law := |
| (indepFun_iff_map_prod_eq_prod_map_map (eval_measurable s).aemeasurable (remainder_measurable s).aemeasurable).mpr |
| (by rw [eval_law]; exact joint_law s) |
|
|
| end HardSphere.Bridge |
|
|
| end |
| end |
|
|
| end |
|
|
| end OAI |
|
|
