| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.RandomFields.PolygonApproxIdentity |
| import OAI.GroupTheory.SimpleAmenable.RandomFields.AffineDensityDerivative |
|
|
| namespace OAI |
|
|
| section |
| section |
| open scoped symmDiff |
| namespace SimpleAmenable |
| open scoped commutatorElement |
| open scoped commutatorElement |
| section NoiseContinuity |
| open Classical Matrix MeasureTheory |
|
|
| @[fun_prop] theorem noiseTensor_continuous {ι : Type*} [Fintype ι] |
| {f : ℝ → ℝ} (hf : Continuous f) : Continuous (noiseTensor (fun _ : ι => f)) := by |
| unfold noiseTensor |
| fun_prop |
|
|
| @[fun_prop] theorem noiseGradientCoordinate_continuous {ι : Type*} [Fintype ι] |
| {f : ℝ → ℝ} (hf : ContDiff ℝ 1 f) (i : ι) : Continuous (noiseGradientCoordinate f i) := by |
| have hd : Continuous (deriv f) := hf.continuous_deriv (by norm_num) |
| have hc := hf.continuous |
| unfold noiseGradientCoordinate |
| fun_prop |
|
|
| @[fun_prop] theorem affineNoiseGenerator_continuous_comp {ι X : Type*} [Fintype ι] |
| [TopologicalSpace X] {f : ℝ → ℝ} (hf : ContDiff ℝ 1 f) |
| {L : X → Matrix ι ι ℝ} {v x : X → ι → ℝ} |
| (hL : Continuous L) (hv : Continuous v) (hx : Continuous x) : |
| Continuous (fun z => affineNoiseGenerator f (L z) (v z) (x z)) := by |
| simp only [affineNoiseGenerator_eq] |
| have hF := (noiseTensor_continuous hf.continuous).comp hx |
| have hg (i : ι) := (noiseGradientCoordinate_continuous hf i).comp hx |
| unfold Matrix.trace Matrix.diag Matrix.mulVec dotProduct |
| fun_prop |
|
|
| @[fun_prop] theorem affineNoiseRoot_continuous {ι : Type*} [Fintype ι] |
| {f : ℝ → ℝ} (hf : Continuous f) (A : Matrix ι ι ℝ) (a : ι → ℝ) : |
| Continuous (affineNoiseRoot f A a) := by |
| unfold affineNoiseRoot |
| apply Continuous.div_const |
| exact (noiseTensor_continuous hf).comp (by fun_prop) |
|
|
| local instance {ι : Type*} : MeasurableSpace (Matrix ι ι ℝ) := |
| inferInstanceAs (MeasurableSpace (ι → ι → ℝ)) |
|
|
| local instance {ι : Type*} [Fintype ι] : BorelSpace (Matrix ι ι ℝ) := |
| inferInstanceAs (BorelSpace (ι → ι → ℝ)) |
|
|
| theorem matrix_inverse_measurable {ι : Type*} [Fintype ι] |
| {X : Type*} [MeasurableSpace X] {A : X → Matrix ι ι ℝ} |
| (hA : Measurable A) : Measurable (fun x => (A x)⁻¹) := by |
| have hd := continuous_id.matrix_det.measurable.comp hA |
| have ha := continuous_id.matrix_adjugate.measurable.comp hA |
| simp only [Matrix.inv_def,Ring.inverse_eq_inv] |
| exact hd.inv.smul ha |
|
|
| theorem matrix_inverse_continuousAt {ι : Type*} [Fintype ι] |
| {X : Type*} [TopologicalSpace X] {A : X → Matrix ι ι ℝ} {x : X} |
| (hA : ContinuousAt A x) (hn : (A x).det≠0) : ContinuousAt (fun y => (A y)⁻¹) x := by |
| apply (continuousAt_matrix_inv (A x) ?_).comp hA |
| convert! (continuousAt_inv₀ hn) using 1 |
| ext x |
| exact Ring.inverse_eq_inv x |
|
|
| end NoiseContinuity |
|
|
| section CovarianceResolvent |
| open Classical Matrix |
|
|
| noncomputable def matrixHSNorm {ι : Type*} [Fintype ι] (A : Matrix ι ι ℝ) : ℝ := |
| Real.sqrt (∑i,∑j,A i j^2) |
|
|
| theorem matrixHSNorm_nonneg {ι : Type*} [Fintype ι] (A : Matrix ι ι ℝ) : |
| 0≤ matrixHSNorm A := Real.sqrt_nonneg _ |
|
|
| theorem matrixHSNorm_sq {ι : Type*} [Fintype ι] (A : Matrix ι ι ℝ) : |
| matrixHSNorm A^2=∑i,∑j,A i j^2 := |
| Real.sq_sqrt (Finset.sum_nonneg (fun i _ => Finset.sum_nonneg (fun j _ => sq_nonneg (A i j)))) |
|
|
| theorem finiteL2Norm_matrix_mulVec {ι : Type*} [Fintype ι] |
| (A : Matrix ι ι ℝ) (x : ι → ℝ) : |
| finiteL2Norm (A*ᵥx)≤ matrixHSNorm A*finiteL2Norm x := by |
| apply (sq_le_sq₀ (finiteL2Norm_nonneg _) (mul_nonneg (matrixHSNorm_nonneg _) (finiteL2Norm_nonneg _))).mp |
| rw [mul_pow,matrixHSNorm_sq,finiteL2Norm_sq,finiteL2Norm_sq,Finset.sum_mul] |
| apply Finset.sum_le_sum |
| intro i _ |
| exact Finset.sum_mul_sq_le_sq_mul_sq Finset.univ (fun j => A i j) x |
|
|
| theorem matrixHSNorm_inverse_contraction {ι : Type*} [Fintype ι] |
| (B D : Matrix ι ι ℝ) (hB : B.PosSemidef) : |
| matrixHSNorm ((1+B)⁻¹*D)≤ matrixHSNorm D := by |
| apply (sq_le_sq₀ (matrixHSNorm_nonneg _) (matrixHSNorm_nonneg _)).mp |
| rw [matrixHSNorm_sq,matrixHSNorm_sq,Finset.sum_comm,Finset.sum_comm (f:=fun i j => D i j^2)] |
| apply Finset.sum_le_sum |
| intro j _ |
| have h := pow_le_pow_left₀ (finiteL2Norm_nonneg _) (finiteL2Norm_inverse_contraction B hB (fun i => D i j)) 2 |
| simpa only [finiteL2Norm_sq,Matrix.mul_apply,Matrix.mulVec,dotProduct] using h |
|
|
| noncomputable def covarianceSegment {ι : Type*} [Fintype ι] |
| (B C : Matrix ι ι ℝ) (t : ℝ) : Matrix ι ι ℝ := (1-t) • B+t • C |
|
|
| theorem covarianceSegment_posSemidef {ι : Type*} [Fintype ι] |
| (B C : Matrix ι ι ℝ) (hB : B.PosSemidef) (hC : C.PosSemidef) |
| {t : ℝ} (ht : t∈Set.Icc (0:ℝ) 1) : (covarianceSegment B C t).PosSemidef := |
| (hB.smul (sub_nonneg.mpr ht.2)).add (hC.smul ht.1) |
|
|
| theorem covarianceSegment_affine {ι : Type*} [Fintype ι] |
| (B C : Matrix ι ι ℝ) (t : ℝ) : 1+covarianceSegment B C t=(1+B)+t • (C-B) := by |
| unfold covarianceSegment |
| module |
|
|
| theorem covarianceSegment_inverse_signal {ι : Type*} [Fintype ι] |
| (B C : Matrix ι ι ℝ) (hB : B.PosSemidef) (hC : C.PosSemidef) |
| (h : ι → ℝ) {t : ℝ} (ht : t∈Set.Icc (0:ℝ) 1) : |
| finiteL2Norm ((1+covarianceSegment B C t)⁻¹*ᵥh)≤ |
| (1+matrixHSNorm (C-B))*finiteL2Norm ((1+B)⁻¹*ᵥh) := by |
| let P := covarianceSegment B C t |
| let x := (1+B)⁻¹*ᵥh |
| let y := (1+P)⁻¹*ᵥ((C-B)*ᵥx) |
| have hP := covarianceSegment_posSemidef B C hB hC ht |
| have hx : (1+B)*ᵥx=h := by |
| rw [Matrix.mulVec_mulVec,Matrix.mul_nonsing_inv _ (one_add_psd_isUnit_det B hB),Matrix.one_mulVec] |
| have he : (1+P)*ᵥx=h+t • ((C-B)*ᵥx) := by |
| rw [show 1+P=(1+B)+t • (C-B) from covarianceSegment_affine B C t, |
| Matrix.add_mulVec,Matrix.smul_mulVec,hx] |
| have hi := congrArg (fun v => (1+P)⁻¹*ᵥv) he |
| rw [Matrix.mulVec_mulVec,Matrix.nonsing_inv_mul _ (one_add_psd_isUnit_det P hP), |
| Matrix.one_mulVec,Matrix.mulVec_add,Matrix.mulVec_smul] at hi |
| have hv : (1+P)⁻¹*ᵥh=x-t • y := by |
| exact eq_sub_of_add_eq (Eq.symm hi) |
| rw [hv] |
| calc |
| _ ≤ finiteL2Norm x+finiteL2Norm (t • y) := finiteL2Norm_sub _ _ |
| _ = finiteL2Norm x+t*finiteL2Norm y := by rw [finiteL2Norm_smul,abs_of_nonneg ht.1] |
| _ ≤ finiteL2Norm x+finiteL2Norm y := by |
| exact add_le_add le_rfl (mul_le_of_le_one_left (finiteL2Norm_nonneg y) ht.2) |
| _ ≤ finiteL2Norm x+matrixHSNorm (C-B)*finiteL2Norm x := by |
| apply add_le_add le_rfl |
| exact (finiteL2Norm_inverse_contraction P hP _).trans (finiteL2Norm_matrix_mulVec _ _) |
| _ = _ := by ring |
|
|
| end CovarianceResolvent |
|
|
| section RootPathEnergy |
| open Classical MeasureTheory Set |
|
|
| theorem square_integral_le_integral_square {X : Type*} [MeasurableSpace X] |
| (μ : Measure X) [IsProbabilityMeasure μ] {f : X → ℝ} |
| (hf : Integrable f μ) (hf2 : Integrable (fun x => f x^2) μ) : |
| (∫x,f x ∂μ)^2≤∫x,f x^2 ∂μ := by |
| let c := ∫x,f x ∂μ |
| have hz : 0≤∫x,(f x)^2-2*c*f x+c^2 ∂μ := by |
| apply integral_nonneg |
| intro x |
| change (0:ℝ)≤f x^2-2*c*f x+c^2 |
| nlinarith [sq_nonneg (f x-c)] |
| have hs : Integrable (fun x => f x^2-2*c*f x) μ := hf2.sub (hf.const_mul (2*c)) |
| rw [integral_add hs (integrable_const _),integral_sub hf2 (hf.const_mul (2*c)), |
| integral_const_mul,integral_const] at hz |
| simp only [probReal_univ,one_smul] at hz |
| change 0≤(∫x,f x^2 ∂μ)-2*c*c+c^2 at hz |
| change c^2≤∫x,f x^2 ∂μ |
| nlinarith |
|
|
| theorem unitInterval_probability : IsProbabilityMeasure |
| ((volume : Measure ℝ).restrict (Ioc 0 1)) := by |
| constructor |
| simp |
|
|
| theorem rootPath_energy_distance {X : Type*} [MeasurableSpace X] |
| (μ : Measure X) [SFinite μ] (R D : ℝ → X → ℝ) (C : ℝ) |
| (hDmeas : Measurable (Function.uncurry D)) |
| (hderiv : ∀t∈Icc (0:ℝ) 1,∀x,HasDerivAt (fun s => R s x) (D t x) t) |
| (hDcont : ∀x,ContinuousOn (fun t => D t x) (Icc (0:ℝ) 1)) |
| (hDint : ∀t∈Icc (0:ℝ) 1,Integrable (fun x => D t x^2) μ) |
| (henergy : ∀t∈Icc (0:ℝ) 1,(∫x,D t x^2 ∂μ)≤C) |
| (hRint : Integrable (fun x => (R 1 x-R 0 x)^2) μ) : |
| (∫x,(R 1 x-R 0 x)^2 ∂μ)≤C := by |
| let ν := (volume : Measure ℝ).restrict (Ioc 0 1) |
| let : IsProbabilityMeasure ν := unitInterval_probability |
| have ht : ∀ᵐt∂ν,t∈Icc (0:ℝ) 1 := by |
| filter_upwards [ae_restrict_mem measurableSet_Ioc] with t ht |
| exact ⟨ht.1.le,ht.2⟩ |
| have hmeas : AEStronglyMeasurable (fun p : ℝ×X => D p.1 p.2^2) (ν.prod μ) := |
| (hDmeas.pow_const 2).aestronglyMeasurable |
| have heint : Integrable (fun t => ∫x,D t x^2 ∂μ) ν := by |
| apply (integrable_const C).mono' hmeas.integral_prod_right' |
| filter_upwards [ht] with t ht |
| rw [Real.norm_eq_abs,abs_of_nonneg (integral_nonneg (fun _ => sq_nonneg _))] |
| exact henergy t ht |
| have hj : Integrable (fun p : ℝ×X => D p.1 p.2^2) (ν.prod μ) := by |
| apply (integrable_prod_iff hmeas).mpr |
| constructor |
| · filter_upwards [ht] with t ht |
| exact hDint t ht |
| · simpa only [Real.norm_eq_abs,abs_sq] using heint |
| have hpoint (x : X) : (R 1 x-R 0 x)^2≤∫t,D t x^2 ∂ν := by |
| have hd : IntervalIntegrable (fun t => D t x) volume 0 1 := |
| (hDcont x).intervalIntegrable_of_Icc (by norm_num) |
| have hd2 : IntervalIntegrable (fun t => D t x^2) volume 0 1 := |
| ((hDcont x).pow 2).intervalIntegrable_of_Icc (by norm_num) |
| have hf := intervalIntegral.integral_eq_sub_of_hasDerivAt |
| (fun t ht => hderiv t (by simpa only [uIcc_of_le (by norm_num : (0:ℝ)≤1)] using ht) x) hd |
| have hc := square_integral_le_integral_square ν hd.1 hd2.1 |
| rw [intervalIntegral.integral_of_le (by norm_num : (0:ℝ)≤1)] at hf |
| rw [← hf] |
| exact hc |
| calc |
| _ ≤ ∫x,∫t,D t x^2 ∂ν ∂μ := integral_mono hRint hj.integral_prod_right hpoint |
| _ = ∫t,∫x,D t x^2 ∂μ ∂ν := (integral_integral_swap hj).symm |
| _ ≤ ∫_t,C ∂ν := integral_mono_ae heint (integrable_const _) (by |
| filter_upwards [ht] with t ht |
| exact henergy t ht) |
| _ = C := by simp |
|
|
| end RootPathEnergy |
|
|
| end SimpleAmenable |
| end |
| end |
|
|
| end OAI |
|
|
