| import Mathlib |
| import OAI.Probability.SKBarriers.Scalar.VectorHierarchy |
| import OAI.Probability.SKBarriers.Scalar.ScalarTiltedExpectation |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory ProbabilityTheory Set |
| namespace SK.Analytic |
| attribute [local instance 2000] parameterNormedGroup parameterNormedSpace |
|
|
| section Generic |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| omit [NormedAddCommGroup E] [NormedSpace ℝ E] in |
| theorem gaussianStep_half_double (m : ℝ) (f : E × ℝ → ℝ) : |
| gaussianStep (m/2) (fun z => 2*f z)=fun x => 2*gaussianStep m f x := by |
| funext x |
| by_cases hm : m=0 |
| · subst m |
| simp only [zero_div,gaussianStep,ite_true,integral_const_mul] |
| · have hm2 : m/2≠0 := div_ne_zero hm (by norm_num) |
| simp only [gaussianStep,ite_eq_right hm,ite_eq_right hm2,positiveGaussianLogStep] |
| simp only [show ∀ y, m/2*(2*f (x,y))=m*f (x,y) by intro y; ring] |
| ring |
|
|
| omit [NormedAddCommGroup E] [NormedSpace ℝ E] in |
| theorem gaussianAverage_half_double (m : ℝ) (f g : E × ℝ → ℝ) : |
| gaussianAverage (m/2) (fun z => 2*f z) g=gaussianAverage m f g := by |
| unfold gaussianAverage gaussianStepLaw |
| simp only [show ∀ z : E × ℝ, m/2*(2*f z)=m*f z by intro z; ring] |
|
|
| omit [NormedAddCommGroup E] [NormedSpace ℝ E] in |
| theorem gaussianAverage_add_prefix (m : ℝ) (f g : E × ℝ → ℝ) (c : E → ℝ) : |
| gaussianAverage m (fun z => f z+c z.1) g=gaussianAverage m f g := by |
| funext x |
| have htilt : (gaussianReal 0 1).tilted (fun y => m*(f (x,y)+c x))= |
| (gaussianReal 0 1).tilted (fun y => m*f (x,y)) := by |
| have H := tilted_tilted (μ:=gaussianReal 0 1) |
| (f:=fun _ : ℝ => m*c x) (integrable_const _) (fun y => m*f (x,y)) |
| rw [tilted_const] at H |
| rw [H] |
| congr 1 |
| funext y |
| simp only [Pi.add_apply] |
| ring |
| exact congrArg (fun μ => ∫ y, g (x,y) ∂μ) htilt |
|
|
| def vectorStepAverage (m : ℝ) (v : E) (f g : E → ℝ) : E → ℝ := |
| gaussianAverage m (fun z : E × ℝ => f (z.1+z.2 • v)) (fun z => g (z.1+z.2 • v)) |
| end Generic |
|
|
| def pairIndependentStep (m v : ℝ) (f : ℝ × ℝ → ℝ) : ℝ × ℝ → ℝ := |
| vectorStep m (v,0) (vectorStep m (0,v) f) |
|
|
| def pairIndependentAverage (m v : ℝ) (f g : ℝ × ℝ → ℝ) : ℝ × ℝ → ℝ := |
| vectorStepAverage m (v,0) (vectorStep m (0,v) f) (vectorStepAverage m (0,v) f g) |
|
|
| theorem vectorStep_pair_right {f g : ℝ → ℝ} (hg : BoundedDerivs g) (m v : ℝ) : |
| vectorStep m (0,v) (fun p : ℝ × ℝ => f p.1+g p.2)= |
| fun p => f p.1+scalarStep m v g p.2 := by |
| let L : ((ℝ × ℝ) × ℝ) →L[ℝ] ℝ := |
| (ContinuousLinearMap.snd ℝ ℝ ℝ).comp (ContinuousLinearMap.fst ℝ (ℝ × ℝ) ℝ)+ |
| v • ContinuousLinearMap.snd ℝ (ℝ × ℝ) ℝ |
| have hL : (fun z : (ℝ × ℝ) × ℝ => g (z.1.2+v*z.2))=g ∘ L := rfl |
| have H := gaussianStep_add_prefix (hL.symm ▸ hg.compCLM L) (fun p : ℝ × ℝ => f p.1) m |
| have he : (fun z : (ℝ × ℝ) × ℝ => |
| (fun p : ℝ × ℝ => f p.1+g p.2) (z.1+z.2 • (0,v)))= |
| fun z => g (z.1.2+v*z.2)+f z.1.1 := by |
| funext z |
| simp only [Prod.fst_add,Prod.snd_add,Prod.smul_fst,Prod.smul_snd,smul_eq_mul,mul_zero,add_zero,mul_comm z.2 v,add_comm] |
| rw [← hL] at H |
| rw [vectorStep,he,H] |
| funext p |
| rw [add_comm] |
| rfl |
|
|
| theorem vectorStep_pair_left {f g : ℝ → ℝ} (hf : BoundedDerivs f) (m v : ℝ) : |
| vectorStep m (v,0) (fun p : ℝ × ℝ => f p.1+g p.2)= |
| fun p => scalarStep m v f p.1+g p.2 := by |
| let L : ((ℝ × ℝ) × ℝ) →L[ℝ] ℝ := |
| (ContinuousLinearMap.fst ℝ ℝ ℝ).comp (ContinuousLinearMap.fst ℝ (ℝ × ℝ) ℝ)+ |
| v • ContinuousLinearMap.snd ℝ (ℝ × ℝ) ℝ |
| have hL : (fun z : (ℝ × ℝ) × ℝ => f (z.1.1+v*z.2))=f ∘ L := rfl |
| have H := gaussianStep_add_prefix (hL.symm ▸ hf.compCLM L) (fun p : ℝ × ℝ => g p.2) m |
| have he : (fun z : (ℝ × ℝ) × ℝ => |
| (fun p : ℝ × ℝ => f p.1+g p.2) (z.1+z.2 • (v,0)))= |
| fun z => f (z.1.1+v*z.2)+g z.1.2 := by |
| funext z |
| simp only [Prod.fst_add,Prod.snd_add,Prod.smul_fst,Prod.smul_snd,smul_eq_mul,mul_zero,add_zero,mul_comm z.2 v] |
| rw [← hL] at H |
| rw [vectorStep,he,H] |
| rfl |
|
|
| theorem pairIndependentStep_separate {f g : ℝ → ℝ} |
| (hf : BoundedDerivs f) (hg : BoundedDerivs g) (m v : ℝ) : |
| pairIndependentStep m v (fun p => f p.1+g p.2)= |
| fun p => scalarStep m v f p.1+scalarStep m v g p.2 := by |
| rw [pairIndependentStep,vectorStep_pair_right hg,vectorStep_pair_left hf] |
|
|
| theorem vectorStepAverage_pair_right (f g a b : ℝ → ℝ) (m v : ℝ) : |
| vectorStepAverage m (0,v) (fun p : ℝ × ℝ => f p.1+g p.2) |
| (fun p => a p.1*b p.2)=fun p => a p.1*scalarStepAverage m v g b p.2 := by |
| have he : (fun z : (ℝ × ℝ) × ℝ => |
| (fun p : ℝ × ℝ => f p.1+g p.2) (z.1+z.2 • (0,v)))= |
| fun z => g (z.1.2+v*z.2)+f z.1.1 := by |
| funext z |
| simp only [Prod.fst_add,Prod.snd_add,Prod.smul_fst,Prod.smul_snd,smul_eq_mul,mul_zero,add_zero,mul_comm z.2 v,add_comm] |
| rw [vectorStepAverage,he,gaussianAverage_add_prefix m (fun z : (ℝ × ℝ) × ℝ => g (z.1.2+v*z.2)) _ (fun p => f p.1)] |
| funext p |
| simp only [gaussianAverage,gaussianStepLaw,Prod.fst_add,Prod.snd_add,Prod.smul_fst,Prod.smul_snd,smul_eq_mul, |
| mul_zero,add_zero,integral_const_mul,scalarStepAverage,mul_comm _ v] |
|
|
| theorem vectorStepAverage_pair_left (f g a b : ℝ → ℝ) (m v : ℝ) : |
| vectorStepAverage m (v,0) (fun p : ℝ × ℝ => f p.1+g p.2) |
| (fun p => a p.1*b p.2)=fun p => scalarStepAverage m v f a p.1*b p.2 := by |
| have he : (fun z : (ℝ × ℝ) × ℝ => |
| (fun p : ℝ × ℝ => f p.1+g p.2) (z.1+z.2 • (v,0)))= |
| fun z => f (z.1.1+v*z.2)+g z.1.2 := by |
| funext z |
| simp only [Prod.fst_add,Prod.snd_add,Prod.smul_fst,Prod.smul_snd,smul_eq_mul,mul_zero,add_zero,mul_comm z.2 v] |
| rw [vectorStepAverage,he,gaussianAverage_add_prefix m (fun z : (ℝ × ℝ) × ℝ => f (z.1.1+v*z.2)) _ (fun p => g p.2)] |
| funext p |
| simp only [gaussianAverage,gaussianStepLaw,Prod.fst_add,Prod.snd_add,Prod.smul_fst,Prod.smul_snd,smul_eq_mul, |
| mul_zero,add_zero,integral_mul_const,scalarStepAverage,mul_comm _ v] |
|
|
| theorem pairIndependentAverage_product {f g : ℝ → ℝ} (hg : BoundedDerivs g) |
| (a b : ℝ → ℝ) (m v : ℝ) : |
| pairIndependentAverage m v (fun p => f p.1+g p.2) (fun p => a p.1*b p.2)= |
| fun p => scalarStepAverage m v f a p.1*scalarStepAverage m v g b p.2 := by |
| rw [pairIndependentAverage,vectorStep_pair_right hg,vectorStepAverage_pair_right, |
| vectorStepAverage_pair_left] |
|
|
| theorem vectorStep_pair_diagonal (F : ℝ × ℝ → ℝ) (f : ℝ → ℝ) |
| (h : ∀ x, F (x,x)=2*f x) (m v x : ℝ) : |
| vectorStep (m/2) (v,v) F (x,x)=2*scalarStep m v f x := by |
| simp only [vectorStep,gaussianStep,positiveGaussianLogStep,Prod.mk_add_mk,Prod.smul_mk, |
| smul_eq_mul,h,mul_comm _ v] |
| by_cases hm : m=0 |
| · simp [hm,integral_const_mul,scalarStep,gaussianStep] |
| · have hm2 : m/2≠0 := div_ne_zero hm (by norm_num) |
| simp only [ite_eq_right hm2,scalarStep,gaussianStep,positiveGaussianLogStep,ite_eq_right hm] |
| simp only [show ∀ y, m/2*(2*f (x+v*y))=m*f (x+v*y) by intro y; ring] |
| ring |
|
|
| theorem vectorStepAverage_pair_diagonal (F G : ℝ × ℝ → ℝ) (f g : ℝ → ℝ) |
| (h : ∀ x, F (x,x)=2*f x) (hg : ∀ x, G (x,x)=g x) (m v x : ℝ) : |
| vectorStepAverage (m/2) (v,v) F G (x,x)=scalarStepAverage m v f g x := by |
| change (∫ y, G (x+y*v,x+y*v) ∂(gaussianReal 0 1).tilted |
| (fun y => (m/2)*F (x+y*v,x+y*v)))= |
| ∫ y, g (x+v*y) ∂(gaussianReal 0 1).tilted (fun y => m*f (x+v*y)) |
| simp only [h,hg,mul_comm _ v] |
| simp only [show ∀ y, m/2*(2*f (x+v*y))=m*f (x+v*y) by intro y; ring] |
|
|
| end SK.Analytic |
|
|
| end |
| end |
|
|
| end OAI |
|
|
