| import OAI.Probability.ProjectionMoments.GaussianDensity |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Set Filter InnerProductSpace |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| noncomputable section |
| namespace ProjectionMoments |
| attribute [fun_prop] measurable_lowerDensity |
|
|
| section Rotations |
| variable (E : Type*) [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] |
| |
| instance rotationLaw_probability : IsProbabilityMeasure (rotationLaw E) := by |
| constructor |
| simp only [rotationLaw, Measure.smul_apply, smul_eq_mul] |
| exact ENNReal.inv_mul_cancel ((ne_of_gt (isOpen_univ.measure_pos (Measure.haar : Measure (Rotation E)) Set.univ_nonempty))) (measure_ne_top _ _) |
| |
| instance rotationLaw_haar : (rotationLaw E).IsHaarMeasure := by |
| unfold rotationLaw |
| apply Measure.IsHaarMeasure.smul _ |
| · exact ENNReal.inv_ne_zero.mpr (measure_ne_top _ _) |
| · exact ENNReal.inv_ne_top.mpr (ne_of_gt (isOpen_univ.measure_pos (Measure.haar : Measure (Rotation E)) Set.univ_nonempty)) |
| |
| instance rotationLaw_right : (rotationLaw E).IsMulRightInvariant := by |
| constructor |
| intro Q |
| let μ := (rotationLaw E).map (fun O => O * Q) |
| have hprob : IsProbabilityMeasure μ := inferInstance |
| have he := Measure.isMulInvariant_eq_smul_of_compactSpace μ (rotationLaw E) |
| have hc := congrArg (fun ν : Measure (Rotation E) => ν Set.univ) he |
| simp only [Measure.smul_apply, measure_univ, ENNReal.smul_def, smul_eq_mul, mul_one] at hc |
| have hc' : Measure.haarScalarFactor μ (rotationLaw E) = 1 := |
| ENNReal.coe_injective hc.symm |
| simpa [hc'] using he |
| |
| variable {E} |
| |
| lemma rotation_transitive {ι : Type*} [Fintype ι] {u v : ι → E} |
| (hu : Orthonormal ℝ u) (hv : Orthonormal ℝ v) : |
| ∃ O : Rotation E, ∀ i, (O : E →L[ℝ] E) (u i) = v i := by |
| classical |
| let U := Submodule.span ℝ (Set.range u) |
| let V := Submodule.span ℝ (Set.range v) |
| let bu : OrthonormalBasis ι ℝ U := (Module.Basis.span hu.linearIndependent).toOrthonormalBasis |
| (by convert! orthonormal_span hu using 1; ext i; simp) |
| let bv : OrthonormalBasis ι ℝ V := (Module.Basis.span hv.linearIndependent).toOrthonormalBasis |
| (by convert! orthonormal_span hv using 1; ext i; simp) |
| let e : U ≃ₗᵢ[ℝ] V := bu.repr.trans bv.repr.symm |
| let L : U →ₗᵢ[ℝ] E := V.subtypeₗᵢ.comp e.toLinearIsometry |
| let O : E ≃ₗᵢ[ℝ] E := L.extend.toLinearIsometryEquiv rfl |
| refine ⟨Unitary.linearIsometryEquiv.symm O, ?_⟩ |
| intro i |
| change O (u i) = v i |
| change L.extend (u i) = v i |
| have he : e (bu i) = bv i := by |
| simp only [e, LinearIsometryEquiv.trans_apply, OrthonormalBasis.repr_self, |
| OrthonormalBasis.repr_symm_single] |
| have hbui : (bu i : E) = u i := by simp [bu, Module.Basis.span_apply] |
| have hbvi : (bv i : E) = v i := by simp [bv, Module.Basis.span_apply] |
| rw [← hbui, LinearIsometry.extend_apply] |
| change (e (bu i) : E) = _ |
| rw [he, hbvi] |
| |
| variable [MeasurableSpace E] [BorelSpace E] |
| |
| lemma measurable_rotateRows {ι : Type*} [Fintype ι] : |
| Measurable (fun z : Rotation E × (ι → E) => rotateRows z.1 z.2) := by |
| apply Continuous.measurable |
| apply continuous_pi |
| intro i |
| exact (continuous_subtype_val.comp continuous_fst).clm_apply (continuous_apply i |>.comp continuous_snd) |
| |
| @[fun_prop] lemma measurable_rotateRows_left {ι : Type*} [Fintype ι] (v : ι → E) : |
| Measurable (fun O : Rotation E => rotateRows O v) := |
| measurable_rotateRows.comp (measurable_id.prodMk measurable_const) |
| |
| @[fun_prop] lemma measurable_rotateRows_right {ι : Type*} [Fintype ι] (O : Rotation E) : |
| Measurable (fun v : ι → E => rotateRows O v) := |
| measurable_rotateRows.comp (measurable_const.prodMk measurable_id) |
| |
| omit [MeasurableSpace E] [BorelSpace E] in |
| lemma rotateRows_mul [MeasurableSpace E] [BorelSpace E] {ι : Type*} (O Q : Rotation E) (v : ι → E) : |
| rotateRows (O*Q) v = rotateRows O (rotateRows Q v) := rfl |
| |
| lemma rotationLaw_orbit_eq {ι : Type*} [Fintype ι] {u v : ι → E} |
| (hu : Orthonormal ℝ u) (hv : Orthonormal ℝ v) : |
| (rotationLaw E).map (fun O => rotateRows O u) = |
| (rotationLaw E).map (fun O => rotateRows O v) := by |
| obtain ⟨Q, hQ⟩ := rotation_transitive hu hv |
| have he : rotateRows Q u = v := funext hQ |
| have hm : Measurable (fun O : Rotation E => rotateRows O u) := |
| measurable_rotateRows.comp (measurable_id.prodMk measurable_const) |
| rw [← he] |
| conv_lhs => rw [← (measurePreserving_mul_right (rotationLaw E) Q).map_eq] |
| rw [Measure.map_map hm (by fun_prop)] |
| rfl |
| |
| lemma gaussianRows_rotation_invariant (m : ℕ) (O : Rotation E) : |
| (Measure.pi (fun _ : Fin m => stdGaussian E)).map (rotateRows O) = |
| Measure.pi (fun _ : Fin m => stdGaussian E) := by |
| change (Measure.pi (fun _ : Fin m => stdGaussian E)).map |
| (fun v i => O.val (v i)) = _ |
| rw [Measure.pi_map_pi (f := fun _ : Fin m => (O.val : E →L[ℝ] E)) |
| (fun _ => O.val.continuous.measurable.aemeasurable)] |
| congr 1 |
| funext j |
| exact stdGaussian_map (Unitary.linearIsometryEquiv O) |
| |
| end Rotations |
| |
| section Triangular |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] |
| [MeasurableSpace E] [BorelSpace E] |
| |
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in |
| @[simp] lemma coordinateMap_apply [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] {m : ℕ} (A : Fin m → E) (x : E) (i : Fin m) : |
| coordinateMap A x i = ⟪x, A i⟫ := by |
| change WithLp.ofLp (rowMap A x) i = _ |
| rw [rowMap_apply] |
| |
| def rowJacobian {m : ℕ} (A : Fin m → E) : ℝ := |
| ∏ i, ‖gramSchmidt ℝ A i‖ |
| |
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in |
| lemma rowJacobian_pos [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] {m : ℕ} {A : Fin m → E} (hA : LinearIndependent ℝ A) : |
| 0 < rowJacobian A := Finset.prod_pos (fun i _ => norm_pos_iff.mpr (gramSchmidt_ne_zero i hA)) |
| |
| lemma rows_factor {m : ℕ} (A : Fin m → E) (hA : LinearIndependent ℝ A) : |
| ∃ u : Fin m → E, Orthonormal ℝ u ∧ |
| ∃ T : (Fin m → ℝ) ≃L[ℝ] (Fin m → ℝ), |
| (∀ x, coordinateMap A x = T (coordinateMap u x)) ∧ |
| (volume : Measure (Fin m → ℝ)).map T = |
| (ENNReal.ofReal (rowJacobian A))⁻¹ • volume := by |
| let u := gramSchmidtNormed ℝ A |
| let R : Matrix (Fin m) (Fin m) ℝ := |
| Matrix.diagonal (fun i => ‖gramSchmidt ℝ A i‖) * NoiselessRegression.gsUpper m A |
| have hu : Orthonormal ℝ u := gramSchmidtNormed_orthonormal hA |
| have hn (i : Fin m) : ‖gramSchmidt ℝ A i‖ ≠ 0 := |
| norm_ne_zero_iff.mpr (gramSchmidt_ne_zero i hA) |
| have hexp (j : Fin m) : ∑ i, R i j • u i = A j := by |
| rw [← NoiselessRegression.gsUpper_expansion m A j] |
| apply Finset.sum_congr rfl |
| intro i _ |
| simp only [R, u, Matrix.diagonal_mul, gramSchmidtNormed, smul_smul] |
| congr 1 |
| simp [hn i, mul_comm] |
| have hdet : R.transpose.det = rowJacobian A := by |
| dsimp only [R, rowJacobian] |
| rw [Matrix.det_transpose, Matrix.det_mul, Matrix.det_diagonal, |
| NoiselessRegression.gsUpper_det, mul_one] |
| have hd : R.transpose.det ≠ 0 := by rw [hdet]; exact (rowJacobian_pos hA).ne' |
| let T := (R.transpose.toLinearEquiv' (Matrix.invertibleOfIsUnitDet R.transpose (isUnit_iff_ne_zero.mpr hd))).toContinuousLinearEquiv |
| refine ⟨u, hu, T, ?_, ?_⟩ |
| · intro x |
| ext j |
| rw [coordinateMap_apply, ← hexp j] |
| change ⟪x, ∑ i, R i j • u i⟫ = Matrix.mulVec R.transpose (coordinateMap u x) j |
| simp only [inner_sum, inner_smul_right, Matrix.mulVec, dotProduct, |
| Matrix.transpose_apply, coordinateMap_apply] |
| · change (volume : Measure (Fin m → ℝ)).map (Matrix.toLin' R.transpose) = _ |
| rw [Real.map_matrix_volume_pi_eq_smul_volume_pi hd, |
| abs_of_pos (inv_pos.mpr (by rw [hdet]; exact rowJacobian_pos hA)), hdet, |
| ENNReal.ofReal_inv_of_pos (rowJacobian_pos hA)] |
| |
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in |
| lemma norm_rowMap_le [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] {m : ℕ} {u : Fin m → E} (hu : Orthonormal ℝ u) : |
| ‖rowMap u‖ ≤ 1 := by |
| apply (rowMap u).opNorm_le_bound zero_le_one |
| intro x |
| rw [one_mul] |
| have h := hu.sum_inner_products_le (x := x) (s := Finset.univ) |
| apply (sq_le_sq₀ (norm_nonneg (rowMap u x)) (norm_nonneg x)).mp |
| rw [EuclideanSpace.real_norm_sq_eq] |
| simpa only [rowMap_apply, Real.norm_eq_abs, sq_abs, |
| WithLp.ofLp_toLp, real_inner_comm] using h |
| |
| omit [MeasurableSpace E] [BorelSpace E] in |
| lemma rowJacobian_le [MeasurableSpace E] [BorelSpace E] {m : ℕ} (A : Fin m → E) : |
| rowJacobian A ≤ ∏ i, ‖A i‖ := by |
| apply Finset.prod_le_prod₀ (fun i _ => norm_nonneg _) (fun i _ => ?_) |
| rw [NoiselessRegression.norm_gramSchmidt_eq_infDist] |
| simpa only [dist_zero_right] using |
| Metric.infDist_le_dist_of_mem (x := A i) (Submodule.zero_mem (Submodule.span ℝ (A '' Set.Iio i))) |
| |
| lemma coordinateMap_rotateRows {m : ℕ} (O : Rotation E) (A : Fin m → E) (x : E) : |
| coordinateMap (rotateRows O A) x = |
| coordinateMap A ((Unitary.linearIsometryEquiv O).symm x) := by |
| ext i |
| simp only [coordinateMap_apply, rotateRows] |
| calc |
| _ = ⟪(Unitary.linearIsometryEquiv O) (A i), x⟫ := real_inner_comm _ _ |
| _ = ⟪A i, (Unitary.linearIsometryEquiv O).symm x⟫ := |
| LinearIsometryEquiv.inner_map_eq_flip _ _ _ |
| _ = _ := real_inner_comm _ _ |
| |
| end Triangular |
| |
| section CoordinateDensity |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] |
| [MeasurableSpace E] [BorelSpace E] |
| |
| @[fun_prop] lemma measurable_coordinateDensity (ν : Measure E) [SFinite ν] (m : ℕ) : |
| Measurable (coordinateDensity ν m) := by |
| exact (measurable_lowerDensity ν m).comp (by fun_prop) |
| |
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in |
| lemma rowMap_eq_toLp_coordinateMap [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] {m : ℕ} (A : Fin m → E) : |
| (rowMap A : E → Label m) = (WithLp.toLp 2) ∘ coordinateMap A := rfl |
| |
| lemma coordinateDensity_is_density (ν : Measure E) [IsFiniteMeasure ν] (m : ℕ) |
| (A : Fin m → E) (hA : ν.map (coordinateMap A) ≪ (volume : Measure (Fin m → ℝ))) : |
| volume.withDensity (fun y => coordinateDensity ν m (A,y)) = ν.map (coordinateMap A) := by |
| have hr : ν.map (rowMap A) ≪ (volume : Measure (Label m)) := by |
| rw [rowMap_eq_toLp_coordinateMap, ← Measure.map_map (by fun_prop) (by fun_prop), |
| ← (PiLp.volume_preserving_toLp (Fin m)).map_eq] |
| exact hA.map (by fun_prop) |
| have h := congrArg (fun μ : Measure (Label m) => μ.map (MeasurableEquiv.toLp 2 (Fin m → ℝ)).symm) |
| (lowerDensity_is_density ν m A hr) |
| rw [map_withDensity_equiv _ _ _ (by fun_prop), |
| (EuclideanSpace.volume_preserving_symm_measurableEquiv_toLp (Fin m)).map_eq, |
| Measure.map_map (by fun_prop) (by fun_prop)] at h |
| exact h |
| |
| def labelMoment (ν : Measure E) (m n : ℕ) (A : Fin m → E) : ℝ≥0∞ := |
| ∫⁻ y, coordinateDensity ν m (A,y)^(n+1) |
| |
| @[fun_prop] lemma measurable_labelMoment (ν : Measure E) [SFinite ν] (m n : ℕ) : |
| Measurable (labelMoment ν m n) := by |
| exact Measurable.lintegral_prod_right (by fun_prop) |
| |
| lemma labelMoment_factor (ν : Measure E) [IsFiniteMeasure ν] {m n : ℕ} |
| (A u : Fin m → E) (T : (Fin m → ℝ) ≃L[ℝ] (Fin m → ℝ)) |
| (hf : ∀ x, coordinateMap A x = T (coordinateMap u x)) |
| (c : ℝ≥0∞) (hc0 : c ≠ 0) (hct : c ≠ ∞) |
| (hT : (volume : Measure (Fin m → ℝ)).map T = c • volume) |
| (hu : ν.map (coordinateMap u) ≪ (volume : Measure (Fin m → ℝ))) : |
| labelMoment ν m n A = c^n * labelMoment ν m n u := by |
| have he : ν.map (coordinateMap A) = (ν.map (coordinateMap u)).map T := by |
| rw [Measure.map_map (by fun_prop) (by fun_prop)] |
| congr 1 |
| exact funext hf |
| have ha : ν.map (coordinateMap A) ≪ (volume : Measure (Fin m → ℝ)) := by |
| rw [he] |
| have h := hu.map T.continuous.measurable |
| rw [hT] at h |
| exact h.trans Measure.smul_absolutelyContinuous |
| apply density_moment_equiv volume T.toHomeomorph.toMeasurableEquiv c hc0 hct hT |
| (by fun_prop) (by fun_prop) |
| rw [coordinateDensity_is_density ν m A ha, coordinateDensity_is_density ν m u hu, he] |
| rfl |
| |
| end CoordinateDensity |
| |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| |
| instance frameLaw_probability {m : ℕ} (u : Fin m → E) : IsProbabilityMeasure (frameLaw u) := |
| inferInstanceAs (IsProbabilityMeasure ((rotationLaw E).map (fun O => rotateRows O u))) |
| |
| lemma frameLaw_eq {m : ℕ} {u v : Fin m → E} (hu : Orthonormal ℝ u) (hv : Orthonormal ℝ v) : |
| frameLaw u = frameLaw v := rotationLaw_orbit_eq hu hv |
| |
| def orbitMoment (ν : Measure E) (m n : ℕ) (A : Fin m → E) : ℝ≥0∞ := |
| ∫⁻ O, labelMoment ν m n (rotateRows O A) ∂rotationLaw E |
| |
| @[fun_prop] lemma measurable_orbitMoment (ν : Measure E) [SFinite ν] (m n : ℕ) : |
| Measurable (orbitMoment ν m n) := by |
| apply Measurable.lintegral_prod_right |
| exact (measurable_labelMoment ν m n).comp (measurable_rotateRows.comp measurable_swap) |
| |
| lemma orbitMoment_eq_frame (ν : Measure E) [SFinite ν] (m n : ℕ) (u : Fin m → E) : |
| orbitMoment ν m n u = ∫⁻ A, labelMoment ν m n A ∂frameLaw u := by |
| rw [frameLaw, lintegral_map (measurable_labelMoment ν m n) (measurable_rotateRows_left u)] |
| rfl |
| |
| lemma orbitMoment_factor (ν : Measure E) [IsFiniteMeasure ν] {m n : ℕ} |
| (u : Fin m → E) (hu : Orthonormal ℝ u) |
| (hac : ∀ᵐ A ∂frameLaw u, ν.map (coordinateMap A) ≪ (volume : Measure (Fin m → ℝ))) |
| (A : Fin m → E) (hA : LinearIndependent ℝ A) : |
| orbitMoment ν m n A = (ENNReal.ofReal (rowJacobian A))⁻¹ ^ n * orbitMoment ν m n u := by |
| obtain ⟨v, hv, T, hT, hvol⟩ := rows_factor A hA |
| have hacv : ∀ᵐ O ∂rotationLaw E, |
| ν.map (coordinateMap (rotateRows O v)) ≪ (volume : Measure (Fin m → ℝ)) := by |
| apply ae_of_ae_map (p := fun B : Fin m → E => ν.map (coordinateMap B) ≪ (volume : Measure (Fin m → ℝ))) |
| (measurable_rotateRows_left v).aemeasurable |
| change ∀ᵐ B ∂frameLaw v, _ |
| rwa [← frameLaw_eq hu hv] |
| have hi : orbitMoment ν m n A = |
| (ENNReal.ofReal (rowJacobian A))⁻¹ ^ n * orbitMoment ν m n v := by |
| unfold orbitMoment |
| rw [← lintegral_const_mul _ (by fun_prop)] |
| apply lintegral_congr_ae |
| filter_upwards [hacv] with O hO |
| apply labelMoment_factor ν (rotateRows O A) (rotateRows O v) T |
| (fun x => ?_) ((ENNReal.ofReal (rowJacobian A))⁻¹) (by simp) |
| (ENNReal.inv_ne_top.mpr (ENNReal.ofReal_ne_zero_iff.mpr (rowJacobian_pos hA))) hvol hO |
| rw [coordinateMap_rotateRows, coordinateMap_rotateRows, hT] |
| rw [hi, orbitMoment_eq_frame, ← frameLaw_eq hu hv, ← orbitMoment_eq_frame] |
| |
| lemma gaussian_lintegral_orbitMoment (ν : Measure E) [SFinite ν] (m n : ℕ) : |
| ∫⁻ A, orbitMoment ν m n A ∂Measure.pi (fun _ => stdGaussian E) = |
| ∫⁻ A, labelMoment ν m n A ∂Measure.pi (fun _ => stdGaussian E) := by |
| unfold orbitMoment |
| rw [lintegral_lintegral_swap (by |
| exact ((measurable_labelMoment ν m n).comp (measurable_rotateRows.comp measurable_swap)).aemeasurable)] |
| have hi (O : Rotation E) : |
| ∫⁻ A, labelMoment ν m n (rotateRows O A) ∂Measure.pi (fun _ => stdGaussian E) = |
| ∫⁻ A, labelMoment ν m n A ∂Measure.pi (fun _ => stdGaussian E) := by |
| rw [← lintegral_map (measurable_labelMoment ν m n) (measurable_rotateRows_right O), |
| gaussianRows_rotation_invariant] |
| simp_rw [hi] |
| simp |
| |
| lemma gaussian_labelMoment_bound {ν : Measure E} [IsFiniteMeasure ν] |
| {a : ℝ} (hν : NoiselessRegression.HasLocalMassBound ν a) |
| (hsupport : ν.support ⊆ Metric.closedBall 0 1) |
| (m n : ℕ) (hmargin : (n : ℝ) + m ≤ a) : |
| ∫⁻ A, labelMoment ν m n A ∂Measure.pi (fun _ => stdGaussian E) ≤ |
| ν Set.univ * (NoiselessRegression.replicaConstant ν a m)^n := by |
| have he (A : Fin m → E) : labelMoment ν m n A = |
| ∫⁻ y : Label m, lowerDensity ν m (A,y)^(n+1) := |
| (PiLp.volume_preserving_toLp (Fin m)).lintegral_comp |
| (show Measurable (fun y : Label m => lowerDensity ν m (A,y)^(n+1)) by fun_prop) |
| simp_rw [he] |
| rw [← lintegral_prod _ (show AEMeasurable (fun z : (Fin m → E) × Label m => lowerDensity ν m z^(n+1)) _ by fun_prop)] |
| exact lowerDensity_integrated_moment hν hsupport m n hmargin |
| |
| theorem frame_gaussian_comparison (ν : Measure E) [IsFiniteMeasure ν] |
| {m n : ℕ} (hm : m ≤ Module.finrank ℝ E) (hd : 0 < Module.finrank ℝ E) |
| (u : Fin m → E) (hu : Orthonormal ℝ u) |
| (hac : ∀ᵐ A ∂frameLaw u, ν.map (coordinateMap A) ≪ (volume : Measure (Fin m → ℝ))) : |
| orbitMoment ν m n u ≤ |
| (2 : ℝ≥0∞)^m * ENNReal.ofReal (Real.sqrt (2 * Module.finrank ℝ E))^(m*n) * |
| ∫⁻ A, labelMoment ν m n A ∂Measure.pi (fun _ => stdGaussian E) := by |
| let γ : Measure (Fin m → E) := Measure.pi (fun _ => stdGaussian E) |
| let t : ℝ := Real.sqrt (2 * Module.finrank ℝ E) |
| let G : Set (Fin m → E) := Set.univ.pi (fun _ => Metric.closedBall (0 : E) t) |
| have ht : 0 < t := Real.sqrt_pos.mpr (by exact_mod_cast (show 0 < 2 * Module.finrank ℝ E by omega)) |
| have hG : MeasurableSet G := MeasurableSet.univ_pi (fun _ => measurableSet_closedBall) |
| have hGmass : (2 : ℝ≥0∞)⁻¹^m ≤ γ G := by |
| rw [show γ G = ∏ _ : Fin m, stdGaussian E (Metric.closedBall 0 t) from Measure.pi_pi _ _] |
| simpa only [Finset.prod_const, Finset.card_univ, Fintype.card_fin] using |
| Finset.prod_le_prod (s := Finset.univ) (fun (_ : Fin m) _ => gaussian_norm_ball_mass (E := E) hd) |
| let B : ℝ≥0∞ := ENNReal.ofReal t ^ m |
| have hB0 : B ≠ 0 := pow_ne_zero _ (ENNReal.ofReal_ne_zero_iff.mpr ht) |
| have hBt : B ≠ ∞ := by simp [B] |
| have hJ (A : Fin m → E) (hA : A ∈ G) : ENNReal.ofReal (rowJacobian A) ≤ B := by |
| have hnorm (i : Fin m) : ‖A i‖ ≤ t := by |
| simpa only [Metric.mem_closedBall, dist_zero_right] using hA i (Set.mem_univ i) |
| have h := (rowJacobian_le A).trans (Finset.prod_le_prod₀ (fun i _ => norm_nonneg _) (fun i _ => hnorm i)) |
| simp only [Finset.prod_const, Finset.card_univ, Fintype.card_fin] at h |
| simpa only [B, ENNReal.ofReal_pow ht.le] using ENNReal.ofReal_le_ofReal h |
| have hlow : B⁻¹^n * orbitMoment ν m n u * γ G ≤ |
| ∫⁻ A, orbitMoment ν m n A ∂γ := by |
| calc |
| _ = ∫⁻ A in G, B⁻¹^n * orbitMoment ν m n u ∂γ := (setLIntegral_const _ _).symm |
| _ ≤ ∫⁻ A in G, orbitMoment ν m n A ∂γ := by |
| apply setLIntegral_mono_ae' hG |
| filter_upwards [gaussian_rows_ae_linearIndependent m hm] with A hA |
| intro hAG |
| rw [orbitMoment_factor ν u hu hac A hA] |
| exact mul_le_mul' (pow_le_pow_left' (ENNReal.inv_le_inv.mpr (hJ A hAG)) n) le_rfl |
| _ ≤ ∫⁻ A, orbitMoment ν m n A ∂γ := lintegral_mono' Measure.restrict_le_self (fun _ => le_rfl) |
| have hlow' : ((2 : ℝ≥0∞)⁻¹^m * B⁻¹^n) * orbitMoment ν m n u ≤ |
| ∫⁻ A, labelMoment ν m n A ∂γ := by |
| rw [← gaussian_lintegral_orbitMoment ν m n] |
| exact (show ((2 : ℝ≥0∞)⁻¹^m * B⁻¹^n) * orbitMoment ν m n u ≤ |
| B⁻¹^n * orbitMoment ν m n u * γ G from by |
| simpa only [mul_comm, mul_left_comm, mul_assoc] using |
| mul_le_mul' hGmass (le_rfl : B⁻¹^n * orbitMoment ν m n u ≤ B⁻¹^n * orbitMoment ν m n u)).trans hlow |
| have hc0 : (2 : ℝ≥0∞)⁻¹^m * B⁻¹^n ≠ 0 := by simp [hBt] |
| have hct : (2 : ℝ≥0∞)⁻¹^m * B⁻¹^n ≠ ∞ := |
| ENNReal.mul_ne_top (by finiteness) (by finiteness) |
| have h := mul_le_mul' (le_rfl : ((2 : ℝ≥0∞)⁻¹^m * B⁻¹^n)⁻¹ ≤ ((2 : ℝ≥0∞)⁻¹^m * B⁻¹^n)⁻¹) hlow' |
| rw [← mul_assoc, ENNReal.inv_mul_cancel hc0 hct, one_mul] at h |
| have he : ((2 : ℝ≥0∞)⁻¹^m * B⁻¹^n)⁻¹ = (2 : ℝ≥0∞)^m * ENNReal.ofReal t^(m*n) := by |
| rw [ENNReal.mul_inv (Or.inl (by simp)) (Or.inl (by finiteness)), |
| ← ENNReal.inv_pow, ← ENNReal.inv_pow, inv_inv, inv_inv] |
| simp only [B, ← pow_mul] |
| rw [he] at h |
| exact h |
| |
| end ProjectionMoments |
| end |
| |
| end OAI |
| |
