| import OAI.Geometry.LatticeCovering.Covering |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open Set Metric MeasureTheory MeasureTheory.Measure Module |
| open scoped ENNReal NNReal BigOperators |
| noncomputable section |
| open Set Metric MeasureTheory MeasureTheory.Measure Module |
| open scoped Pointwise ENNReal NNReal BigOperators |
| noncomputable section |
|
|
| namespace SingleLatticeCovering.Sections |
| open Set Module MeasureTheory |
| open scoped BigOperators Pointwise |
|
|
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
|
|
|
|
|
|
| lemma affine_section_of_ball_projection {D : ℕ} (hD : 0 < D) |
| (b : Basis (Fin D) ℝ F) (hunit : ∀ i, ‖b i‖ ≤ 1) |
| (hcoord : ∀ y : F, ∀ i, |b.repr y i| ≤ ‖y‖) |
| {K : Set (E × F)} (hconv : Convex ℝ K) {R : ℝ} (hR : 0 < R) |
| (hproj : ∀ v : F, ‖v‖ ≤ 6*(D : ℝ)*R → ∃ x : E, (x,v) ∈ K) : |
| ∃ T : F →ᵃ[ℝ] E, ∀ y : F, ‖y‖ ≤ 2*R → (T y,y) ∈ K := by |
| classical |
| have hDr : (0 : ℝ) < D := by exact_mod_cast hD |
| let c : ℝ := 4*R*D |
| have hc : 0 < c := by dsimp [c]; positivity |
| let v₀ : F := ∑ i : Fin D, (-2*R) • b i |
| let v : Fin D → F := fun i => v₀+c • b i |
| have hv₀ : ‖v₀‖ ≤ 2*R*D := by |
| calc |
| _ ≤ ∑ i : Fin D, ‖(-2*R) • b i‖ := norm_sum_le _ _ |
| _ ≤ ∑ i : Fin D, 2*R := by |
| apply Finset.sum_le_sum; intro i hi |
| rw [norm_smul,Real.norm_eq_abs,abs_mul,abs_of_nonneg hR.le] |
| norm_num |
| nlinarith [hunit i] |
| _ = _ := by simp; ring |
| have hvi : ∀ i, ‖v i‖ ≤ 6*(D : ℝ)*R := by |
| intro i |
| calc |
| _ ≤ ‖v₀‖+‖c • b i‖ := norm_add_le _ _ |
| _ ≤ 2*R*D+c := add_le_add hv₀ (by rw [norm_smul,Real.norm_of_nonneg hc.le]; nlinarith [hunit i]) |
| _ = _ := by dsimp [c]; ring |
| obtain ⟨x₀,hx₀⟩ := hproj v₀ (by nlinarith) |
| choose x hx using fun i => hproj (v i) (hvi i) |
| let lam : F → Fin D → ℝ := fun y i => (b.repr y i+2*R)/c |
| let L : F →ₗ[ℝ] E := ∑ i : Fin D, (b.coord i).smulRight (c⁻¹ • (x i-x₀)) |
| let t₀ : E := x₀+∑ i : Fin D, (2*R/c) • (x i-x₀) |
| let T : F →ᵃ[ℝ] E := L.toAffineMap+AffineMap.const ℝ F t₀ |
| have hT : ∀ y, T y=x₀+∑ i : Fin D, lam y i • (x i-x₀) := by |
| intro y |
| dsimp [T,L,t₀,lam] |
| simp only [ LinearMap.sum_apply,LinearMap.smulRight_apply,Basis.coord_apply,smul_smul] |
| rw [add_comm _ (x₀+_),add_assoc]; congr 1 |
| rw [←Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl; intro i hi |
| rw [←add_smul] |
| congr 1; field_simp; ring |
| refine ⟨T,fun y hy => ?_⟩ |
| have hlam0 : ∀ i, 0 ≤ lam y i := by |
| intro i |
| have hh := (abs_le.mp ((hcoord y i).trans hy)).1 |
| exact div_nonneg (by linarith) hc.le |
| have hlamsum : ∑ i : Fin D, lam y i ≤ 1 := by |
| calc |
| _ ≤ ∑ i : Fin D, 4*R/c := by |
| apply Finset.sum_le_sum; intro i hi |
| apply div_le_div_of_nonneg_right _ hc.le |
| have hh := (abs_le.mp ((hcoord y i).trans hy)).2 |
| linarith |
| _ = 1 := by simp [c]; field_simp |
| let w : Option (Fin D) → ℝ := fun o => o.elim (1-∑ i,lam y i) (lam y) |
| let z : Option (Fin D) → E × F := fun o => o.elim (x₀,v₀) (fun i => (x i,v i)) |
| have hw0 : ∀ o ∈ (Finset.univ : Finset (Option (Fin D))), 0 ≤ w o := by |
| intro o ho; cases o with |
| | none => exact sub_nonneg.mpr hlamsum |
| | some i => exact hlam0 i |
| have hw1 : ∑ o : Option (Fin D), w o=1 := by simp [w,Fintype.sum_option] |
| have hz : ∀ o ∈ (Finset.univ : Finset (Option (Fin D))), z o ∈ K := by |
| intro o ho; cases o with |
| | none => exact hx₀ |
| | some i => exact hx i |
| have hmem := hconv.sum_mem hw0 hw1 hz |
| have he : ∑ o : Option (Fin D), w o • z o=(T y,y) := by |
| rw [Fintype.sum_option] |
| dsimp only [w,z,Option.elim] |
| apply Prod.ext |
| · simp only [Prod.fst_add,Prod.fst_sum,Prod.smul_fst] |
| change (1-∑ i,lam y i) • x₀+∑ i,lam y i • x i=T y |
| rw [hT] |
| simp only [smul_sub,Finset.sum_sub_distrib,←Finset.sum_smul] |
| module |
| · simp only [Prod.snd_add,Prod.snd_sum,Prod.smul_snd] |
| change (1-∑ i,lam y i) • v₀+∑ i,lam y i • v i=y |
| dsimp only [v] |
| simp only [smul_add,smul_smul,Finset.sum_add_distrib,←Finset.sum_smul] |
| have hh : ∀ i, lam y i*c=b.repr y i+2*R := by intro i; dsimp [lam]; field_simp |
| simp_rw [hh,add_smul] |
| rw [Finset.sum_add_distrib,b.sum_repr] |
| have hsum : v₀+(∑ i : Fin D, (2*R) • b i)=0 := by |
| dsimp only [v₀] |
| rw [←Finset.sum_add_distrib] |
| simp only [←add_smul,neg_mul,neg_add_cancel,zero_smul,Finset.sum_const_zero] |
| calc |
| _ = y+(v₀+∑ i : Fin D, (2*R) • b i) := by module |
| _ = y := by rw [hsum,add_zero] |
| rwa [he] at hmem |
|
|
|
|
| end SingleLatticeCovering.Sections |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Sections |
| open Set Metric MeasureTheory MeasureTheory.Measure Module |
| open scoped Pointwise ENNReal NNReal BigOperators |
|
|
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| [FiniteDimensional ℝ E] [FiniteDimensional ℝ F] |
| [MeasurableSpace E] [BorelSpace E] [MeasurableSpace F] [BorelSpace F] |
|
|
|
|
|
|
| def gaussian (F : Type*) [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F] |
| (y : F) : ℝ := (Real.sqrt (2*Real.pi))^(-(finrank ℝ F : ℤ))*Real.exp (-‖y‖^2/2) |
|
|
| lemma gaussian_pos {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F] [MeasurableSpace F] [BorelSpace F] (y : F) : 0 < gaussian F y := by |
| dsimp [gaussian] |
| exact mul_pos (zpow_pos (Real.sqrt_pos.mpr (by positivity)) _) (Real.exp_pos _) |
|
|
|
|
|
|
| lemma gaussian_near {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F] [MeasurableSpace F] [BorelSpace F] {R : ℝ} (hR : 0 ≤ R) {m : ℕ} (hm : 0 < m) |
| {a y : F} (ha : ‖a‖ ≤ R) (hy : ‖y‖ ≤ R) |
| (hya : dist y a ≤ R/(m : ℝ)^2) (hsmall : R^2/(m : ℝ)^2 ≤ 1) : |
| Real.exp (-1)*gaussian F y ≤ gaussian F a ∧ |
| gaussian F a ≤ Real.exp 1*gaussian F y := by |
| have hm0 : (0 : ℝ) < m := by exact_mod_cast hm |
| have hdist : |‖a‖-‖y‖| ≤ R/(m : ℝ)^2 := |
| (abs_norm_sub_norm_le a y).trans (by simpa only [dist_comm,dist_eq_norm] using hya) |
| have hsq : |‖a‖^2-‖y‖^2| ≤ 2 := by |
| have he : ‖a‖^2-‖y‖^2=(‖a‖-‖y‖)*(‖a‖+‖y‖) := by ring |
| rw [he,abs_mul,abs_of_nonneg (add_nonneg (norm_nonneg _) (norm_nonneg _))] |
| calc |
| _ ≤ (R/(m : ℝ)^2)*(2*R) := mul_le_mul hdist (by linarith) (by positivity) (by positivity) |
| _ = 2*(R^2/(m : ℝ)^2) := by ring |
| _ ≤ 2 := by linarith |
| have hp := abs_le.mp hsq |
| have hlow : -1+-‖y‖^2/2 ≤ -‖a‖^2/2 := by linarith |
| have hupp : -‖a‖^2/2 ≤ 1+-‖y‖^2/2 := by linarith |
| have hb : 0 ≤ (Real.sqrt (2*Real.pi))^(-(finrank ℝ F : ℤ)) := by positivity |
| constructor |
| · have hh := mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr hlow) hb |
| simpa only [Real.exp_add,gaussian,mul_left_comm] using hh |
| · have hh := mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr hupp) hb |
| simpa only [Real.exp_add,gaussian,mul_left_comm] using hh |
|
|
|
|
|
|
|
|
| theorem finite_section_labels |
| (μ : Measure E) [IsAddHaarMeasure μ] (ν : Measure F) [IsAddHaarMeasure ν] |
| {K : Set (E × F)} (hK : IsCompact K) (hconv : Convex ℝ K) |
| {R V : ℝ} (hR : 0 < R) (hV : 0 < V) (hm : 2 ≤ finrank ℝ E) |
| (hcenter : ∀ z : F, ‖z‖ ≤ 2*R → (0,z) ∈ K) |
| (hlower : ∀ y : F, ‖y‖ ≤ R → V*gaussian F y/2 ≤ (μ (fiber K y)).toReal) |
| (hsmall : R^2/(finrank ℝ E : ℝ)^2 ≤ 1) : |
| ∃ S : Finset F, (S.card : ℝ) ≤ (3*(finrank ℝ E : ℝ)^2)^(finrank ℝ F) ∧ |
| ∃ J : F → Set E, (∀ a ∈ S, IsCompact (J a) ∧ Convex ℝ (J a) ∧ (0 : E) ∈ J a ∧ |
| (μ (J a)).toReal=V*gaussian F a/8) ∧ |
| ∀ y : F, ‖y‖ ≤ R → ∃ a ∈ S, J a ⊆ fiber K y ∧ |
| (Real.exp (-1)/8)*V*gaussian F y ≤ (μ (J a)).toReal ∧ |
| (μ (J a)).toReal ≤ (Real.exp 1/8)*V*gaussian F y := by |
| classical |
| obtain ⟨S,hSc,hSn,hnet⟩ := ball_finite_net ν hR (show 1 ≤ finrank ℝ E by omega) |
| let d : ℝ := 1-(finrank ℝ E : ℝ)^(-2 : ℤ) |
| have hn2 : (2 : ℝ) ≤ finrank ℝ E := by exact_mod_cast hm |
| have hd : 0 ≤ d := by |
| dsimp [d]; norm_num only [zpow_neg, zpow_ofNat] |
| have hh : 1 ≤ (finrank ℝ E : ℝ)^2 := by nlinarith |
| exact sub_nonneg.mpr ((inv_le_one₀ (by positivity)).mpr hh) |
| have hdata : ∀ a ∈ S, ∃ Ja : Set E, IsCompact Ja ∧ Convex ℝ Ja ∧ (0 : E) ∈ Ja ∧ |
| Ja ⊆ d • fiber K a ∧ (μ Ja).toReal=V*gaussian F a/8 := by |
| intro a ha |
| have haR := hSn a ha |
| have hzero : (0 : E) ∈ fiber K a := hcenter a (by linarith) |
| have hzero' : (0 : E) ∈ d • fiber K a := ⟨0,hzero,smul_zero _⟩ |
| apply prescribed_volume μ (by omega) ((fiber_compact hK a).smul d) ((fiber_convex hconv a).smul d) hzero' |
| (by positivity [gaussian_pos a]) |
| rw [μ.addHaar_smul_of_nonneg hd,ENNReal.toReal_mul,ENNReal.toReal_ofReal (pow_nonneg hd _)] |
| have hh := shrink_power_half hm |
| have hv := hlower a haR |
| have hgp := gaussian_pos a |
| have hhalf : (1/2 : ℝ)*(V*gaussian F a/2) ≤ d^finrank ℝ E*(μ (fiber K a)).toReal := |
| mul_le_mul hh hv (by positivity) (pow_nonneg hd _) |
| nlinarith |
| have hex : ∀ a : F, ∃ Ja : Set E, a ∈ S → IsCompact Ja ∧ Convex ℝ Ja ∧ (0 : E) ∈ Ja ∧ |
| Ja ⊆ d • fiber K a ∧ (μ Ja).toReal=V*gaussian F a/8 := by |
| intro a |
| by_cases ha : a ∈ S |
| · exact ⟨(hdata a ha).choose,fun _ => (hdata a ha).choose_spec⟩ |
| · exact ⟨∅,fun hh => (ha hh).elim⟩ |
| choose J hJ using hex |
| refine ⟨S,hSc,J,?_,?_⟩ |
| · intro a ha; exact ⟨(hJ a ha).1,(hJ a ha).2.1,(hJ a ha).2.2.1,(hJ a ha).2.2.2.2⟩ |
| · intro y hy |
| obtain ⟨a,ha,hya⟩ := hnet y hy |
| have hsub := nearby_fiber_inclusion hconv hR.le (show 1 ≤ finrank ℝ E by omega) hcenter (hSn a ha) hya |
| have hg := gaussian_near hR.le (show 0 < finrank ℝ E by omega) (hSn a ha) hy hya hsmall |
| refine ⟨a,ha,(hJ a ha).2.2.2.1.trans hsub,?_,?_⟩ <;> |
| rw [(hJ a ha).2.2.2.2] |
| · nlinarith [mul_le_mul_of_nonneg_left hg.1 hV.le] |
| · nlinarith [mul_le_mul_of_nonneg_left hg.2 hV.le] |
|
|
|
|
| end SingleLatticeCovering.Sections |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Sections |
| open Set MeasureTheory MeasureTheory.Measure Module |
| open scoped Pointwise ENNReal BigOperators |
|
|
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
|
|
|
|
|
|
| def sectionShear (T : F →ᵃ[ℝ] E) : (E × F) ≃ᵃ[ℝ] (E × F) := |
| AffineEquiv.ofBijective (φ := ((AffineMap.fst : (E × F) →ᵃ[ℝ] E)-T.comp AffineMap.snd).prod |
| AffineMap.snd) (by |
| constructor |
| · rintro ⟨x,y⟩ ⟨x',y'⟩ h |
| have hy : y=y' := congrArg Prod.snd h |
| subst y' |
| have hx : x-T y=x'-T y := congrArg Prod.fst h |
| exact Prod.ext (by simpa using congrArg (fun z => z+T y) hx) rfl |
| · rintro ⟨x,y⟩ |
| refine ⟨(x+T y,y),?_⟩ |
| change (x+T y-T y,y)=(x,y) |
| simp) |
|
|
| @[simp] lemma sectionShear_apply (T : F →ᵃ[ℝ] E) (x : E) (y : F) : |
| sectionShear T (x,y)=(x-T y,y) := rfl |
|
|
| lemma fiber_sectionShear (T : F →ᵃ[ℝ] E) (K : Set (E × F)) (y : F) : |
| fiber (sectionShear T '' K) y=(fun x => x-T y) '' fiber K y := by |
| ext x; constructor |
| · rintro ⟨⟨u,v⟩,hK,he⟩ |
| have hv : v=y := congrArg Prod.snd he |
| subst v |
| exact ⟨u,hK,congrArg Prod.fst he⟩ |
| · rintro ⟨u,hu,rfl⟩ |
| exact ⟨(u,y),hu,rfl⟩ |
|
|
| variable [FiniteDimensional ℝ E] [FiniteDimensional ℝ F] |
| [MeasurableSpace E] [BorelSpace E] [MeasurableSpace F] [BorelSpace F] |
|
|
| lemma fiber_sectionShear_measure {E : Type*} {F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ E] [FiniteDimensional ℝ F] [MeasurableSpace E] [BorelSpace E] [MeasurableSpace F] [BorelSpace F] (μ : Measure E) [IsAddHaarMeasure μ] |
| (T : F →ᵃ[ℝ] E) (K : Set (E × F)) (y : F) : |
| μ (fiber (sectionShear T '' K) y)=μ (fiber K y) := by |
| rw [fiber_sectionShear] |
| simp only [sub_eq_add_neg,Set.image_add_right,measure_preimage_add_right] |
|
|
| lemma sectionShear_measure (μ : Measure E) [IsAddHaarMeasure μ] |
| (ν : Measure F) [IsAddHaarMeasure ν] |
| (T : F →ᵃ[ℝ] E) {K : Set (E × F)} (hK : IsCompact K) : |
| (μ.prod ν) (sectionShear T '' K)=(μ.prod ν) K := by |
| have hc := (sectionShear T).toAffineMap.continuous_of_finiteDimensional |
| have hK' : IsCompact (sectionShear T '' K) := hK.image hc |
| rw [Measure.prod_apply_symm hK'.measurableSet,Measure.prod_apply_symm hK.measurableSet] |
| apply lintegral_congr |
| intro y |
| exact fiber_sectionShear_measure μ T K y |
|
|
|
|
|
|
| lemma convex_interior_of_measure_pos (μ : Measure E) [IsAddHaarMeasure μ] |
| {J : Set E} (hconv : Convex ℝ J) (hpos : 0 < (μ J).toReal) : |
| (interior J).Nonempty := by |
| apply hconv.interior_nonempty_iff_affineSpan_eq_top.mpr |
| by_contra h |
| have hn : μ J=0 := measure_mono_null (subset_affineSpan ℝ J) (μ.addHaar_affineSubspace _ h) |
| rw [hn,ENNReal.toReal_zero] at hpos |
| exact (lt_irrefl 0) hpos |
|
|
|
|
|
|
| theorem centered_affine_image {D : ℕ} (hD : 0 < D) |
| (b : Basis (Fin D) ℝ F) (hunit : ∀ i, ‖b i‖ ≤ 1) |
| (hcoord : ∀ y : F, ∀ i, |b.repr y i| ≤ ‖y‖) |
| (μ : Measure E) [IsAddHaarMeasure μ] (ν : Measure F) [IsAddHaarMeasure ν] |
| {K : Set (E × F)} (hK : IsCompact K) (hconv : Convex ℝ K) |
| {R : ℝ} (hR : 0 < R) |
| (hproj : ∀ v : F, ‖v‖ ≤ 6*(D : ℝ)*R → ∃ x : E, (x,v) ∈ K) : |
| ∃ e : (E × F) ≃ᵃ[ℝ] (E × F), IsCompact (e '' K) ∧ Convex ℝ (e '' K) ∧ |
| (μ.prod ν) (e '' K)=(μ.prod ν) K ∧ |
| (∀ y, μ (fiber (e '' K) y)=μ (fiber K y)) ∧ |
| (∀ y : F, ‖y‖ ≤ 2*R → (0,y) ∈ e '' K) := by |
| obtain ⟨T,hT⟩ := affine_section_of_ball_projection hD b hunit hcoord hconv hR hproj |
| refine ⟨sectionShear T,hK.image (sectionShear T).toAffineMap.continuous_of_finiteDimensional, |
| hconv.affine_image (sectionShear T).toAffineMap, |
| sectionShear_measure μ ν T hK,fun y => fiber_sectionShear_measure μ T K y,?_⟩ |
| intro y hy |
| refine ⟨(T y,y),hT y hy,?_⟩ |
| simp |
|
|
|
|
| end SingleLatticeCovering.Sections |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Sections |
| open Set MeasureTheory MeasureTheory.Measure Filter Topology |
| open scoped ENNReal |
|
|
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
|
|
|
|
|
|
| lemma eventually_fiber_subset {E : Type*} {F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F] {K : Set (E × F)} (hK : IsCompact K) |
| {y : F} {U : Set E} (hU : IsOpen U) (hyU : fiber K y ⊆ U) : |
| ∀ᶠ z in 𝓝 y, fiber K z ⊆ U := by |
| let A : Set F := Prod.snd '' (K ∩ Prod.fst ⁻¹' Uᶜ) |
| have hA : IsClosed A := ((hK.inter_right (hU.isClosed_compl.preimage continuous_fst)).image continuous_snd).isClosed |
| have hy : y ∈ Aᶜ := by |
| rintro ⟨⟨x,z⟩,⟨hx,hxU⟩,he⟩ |
| change z=y at he |
| subst z |
| exact hxU (hyU hx) |
| filter_upwards [hA.isOpen_compl.mem_nhds hy] with z hz |
| intro x hx |
| by_contra hxU |
| exact hz ⟨(x,z),⟨hx,hxU⟩,rfl⟩ |
|
|
| lemma upperSemicontinuous_fiber_measure [MeasurableSpace E] [BorelSpace E] |
| (μ : Measure E) [OuterRegular μ] {K : Set (E × F)} (hK : IsCompact K) : |
| UpperSemicontinuous (fun y : F => μ (fiber K y)) := by |
| intro y r hyr |
| obtain ⟨U,hfU,hU,hμU⟩ := (fiber K y).exists_isOpen_lt_of_lt r hyr |
| filter_upwards [eventually_fiber_subset hK hU hfU] with z hz |
| exact (measure_mono hz).trans_lt hμU |
|
|
|
|
|
|
| lemma lower_bound_everywhere_of_ae {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [MeasurableSpace F] [BorelSpace F] |
| (ν : Measure F) [IsOpenPosMeasure ν] |
| {f g : F → ℝ≥0∞} (hf : UpperSemicontinuous f) (hg : Continuous g) |
| {U : Set F} (hU : IsOpen U) (hae : ∀ᵐ y ∂ν, y ∈ U → g y ≤ f y) : |
| ∀ y ∈ U, g y ≤ f y := by |
| intro y hy |
| by_contra h |
| have hfg : f y < g y := lt_of_not_ge h |
| obtain ⟨q,hfq,hqg⟩ := exists_between hfg |
| let V := U ∩ (f ⁻¹' Iio q) ∩ (g ⁻¹' Ioi q) |
| have hV : IsOpen V := (hU.inter (hf.isOpen_preimage q)).inter (isOpen_Ioi.preimage hg) |
| have hyV : y ∈ V := ⟨⟨hy,hfq⟩,hqg⟩ |
| obtain ⟨z,hz,hzV⟩ := (ν.dense_of_ae hae).exists_mem_open hV ⟨y,hyV⟩ |
| exact (not_lt_of_ge (hz hzV.1.1)) (hzV.1.2.trans hzV.2) |
|
|
|
|
|
|
|
|
| theorem canonical_marginal_lower [MeasurableSpace E] [BorelSpace E] |
| [MeasurableSpace F] [BorelSpace F] |
| (μ : Measure E) [OuterRegular μ] (ν : Measure F) [IsOpenPosMeasure ν] |
| {K : Set (E × F)} (hK : IsCompact K) {g : F → ℝ≥0∞} (hg : Continuous g) |
| {S : ℝ} (hae : ∀ᵐ y ∂ν, ‖y‖ < S → g y ≤ μ (fiber K y)) : |
| ∀ y : F, ‖y‖ < S → g y ≤ μ (fiber K y) := by |
| exact lower_bound_everywhere_of_ae ν (upperSemicontinuous_fiber_measure μ hK) hg |
| (isOpen_lt continuous_norm continuous_const) hae |
|
|
|
|
| end SingleLatticeCovering.Sections |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Sections |
| open Set Metric MeasureTheory MeasureTheory.Measure Module |
| open scoped Pointwise ENNReal BigOperators |
|
|
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| [FiniteDimensional ℝ E] [FiniteDimensional ℝ F] |
| [MeasurableSpace E] [BorelSpace E] [MeasurableSpace F] [BorelSpace F] |
|
|
|
|
|
|
|
|
|
|
| theorem gaussian_marginal_to_sections {D : ℕ} (hD : 0 < D) |
| (b : Basis (Fin D) ℝ F) (hunit : ∀ i, ‖b i‖ ≤ 1) |
| (hcoord : ∀ y : F, ∀ i, |b.repr y i| ≤ ‖y‖) |
| (μ : Measure E) [IsAddHaarMeasure μ] (ν : Measure F) [IsAddHaarMeasure ν] |
| {K : Set (E × F)} (hK : IsCompact K) (hconv : Convex ℝ K) |
| {R : ℝ} (hR : 0 < R) (hV : 0 < ((μ.prod ν) K).toReal) |
| (hm : 2 ≤ finrank ℝ E) |
| (hlower : ∀ y : F, ‖y‖ ≤ 6*(D : ℝ)*R → |
| ((μ.prod ν) K).toReal*gaussian F y/2 ≤ (μ (fiber K y)).toReal) |
| (hsmall : R^2/(finrank ℝ E : ℝ)^2 ≤ 1) : |
| ∃ e : (E × F) ≃ᵃ[ℝ] (E × F), IsCompact (e '' K) ∧ Convex ℝ (e '' K) ∧ |
| (μ.prod ν) (e '' K)=(μ.prod ν) K ∧ |
| ∃ S : Finset F, (S.card : ℝ) ≤ (3*(finrank ℝ E : ℝ)^2)^D ∧ |
| ∃ J : F → Set E, |
| (∀ a ∈ S, IsCompact (J a) ∧ Convex ℝ (J a) ∧ (interior (J a)).Nonempty) ∧ |
| ∀ y : F, ‖y‖ ≤ R → ∃ a ∈ S, J a ⊆ fiber (e '' K) y ∧ |
| (Real.exp (-1)/8)*((μ.prod ν) (e '' K)).toReal*gaussian F y ≤ (μ (J a)).toReal ∧ |
| (μ (J a)).toReal ≤ (Real.exp 1/8)*((μ.prod ν) (e '' K)).toReal*gaussian F y := by |
| have hDr : (1 : ℝ) ≤ D := by exact_mod_cast (show 1 ≤ D by omega) |
| obtain ⟨e,heK,heconv,heμ,hef,hezero⟩ := centered_affine_image hD b hunit hcoord μ ν hK hconv hR (by |
| intro y hy |
| have hp : 0 < (μ (fiber K y)).toReal := (by positivity [gaussian_pos y] : |
| 0 < ((μ.prod ν) K).toReal*gaussian F y/2).trans_le (hlower y hy) |
| by_contra hn |
| push Not at hn |
| have hempty : fiber K y=∅ := Set.eq_empty_iff_forall_notMem.mpr hn |
| rw [hempty,measure_empty,ENNReal.toReal_zero] at hp |
| exact (lt_irrefl 0) hp) |
| obtain ⟨S,hSc,J,hJ,hlabels⟩ := finite_section_labels μ ν heK heconv hR hV hm hezero (by |
| intro y hy |
| rw [hef] |
| exact hlower y (hy.trans (by nlinarith))) hsmall |
| have hdim : finrank ℝ F=D := by simpa using Module.finrank_eq_card_basis b |
| refine ⟨e,heK,heconv,heμ,S,by simpa only [hdim] using hSc,J,?_,?_⟩ |
| · intro a ha |
| refine ⟨(hJ a ha).1,(hJ a ha).2.1,convex_interior_of_measure_pos μ (hJ a ha).2.1 ?_⟩ |
| rw [(hJ a ha).2.2.2] |
| positivity [gaussian_pos a] |
| · intro y hy |
| simpa only [heμ] using hlabels y hy |
|
|
|
|
| end SingleLatticeCovering.Sections |
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Sections |
| open MeasureTheory |
| open scoped BigOperators |
|
|
| lemma gaussian_toLp {D : ℕ} (y : Fin D → ℝ) : |
| gaussian (EuclideanSpace ℝ (Fin D)) (WithLp.toLp 2 y)=Folded.gamma y := by |
| classical |
| unfold gaussian Folded.gamma Folded.gamma1 |
| rw [finrank_euclideanSpace_fin,EuclideanSpace.real_norm_sq_eq] |
| rw [Finset.prod_div_distrib,Finset.prod_const,Finset.card_univ,Fintype.card_fin] |
| rw [← Real.exp_sum,zpow_neg,zpow_natCast] |
| rw [div_eq_mul_inv,mul_comm] |
| congr 2 |
| simp only [div_eq_mul_inv,Finset.sum_mul,Finset.sum_neg_distrib,neg_mul] |
|
|
| end SingleLatticeCovering.Sections |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Sections |
| open MeasureTheory LatticeGeometry |
| open scoped BigOperators |
|
|
| lemma appendEquiv_measurePreserving (m D : ℕ) : |
| MeasurePreserving (appendEquiv m D) |
| ((volume : Measure (Fin m → ℝ)).prod (volume : Measure (Fin D → ℝ))) volume := by |
| have h := (volume_preserving_arrowCongr' (finSumFinEquiv (m := m) (n := D)) |
| (MeasurableEquiv.refl ℝ) (MeasurePreserving.id volume)).comp |
| (volume_measurePreserving_sumPiEquivProdPi_symm (fun _ : Fin m ⊕ Fin D => ℝ)) |
| have he : (fun t : (Fin m → ℝ) × (Fin D → ℝ) => |
| (MeasurableEquiv.arrowCongr' finSumFinEquiv (MeasurableEquiv.refl ℝ)) |
| ((MeasurableEquiv.sumPiEquivProdPi (fun _ : Fin m ⊕ Fin D => ℝ)).symm t))= |
| appendEquiv m D := by |
| funext t i |
| refine Fin.addCases ?_ ?_ i <;> intro j <;> |
| simp [MeasurableEquiv.arrowCongr',MeasurableEquiv.sumPiEquivProdPi, |
| Equiv.arrowCongr',appendEquiv,Fin.appendEquiv] |
| exact he ▸ h |
|
|
| def flatten (m D : ℕ) : ((Fin m → ℝ) × EuclideanSpace ℝ (Fin D)) ≃ₗ[ℝ] (Fin (m+D) → ℝ) := |
| ((LinearEquiv.refl ℝ (Fin m → ℝ)).prodCongr (WithLp.linearEquiv 2 ℝ (Fin D → ℝ))).trans |
| (appendEquiv m D) |
|
|
| @[simp] lemma flatten_apply (m D : ℕ) (x : Fin m → ℝ) (y : EuclideanSpace ℝ (Fin D)) : |
| flatten m D (x,y)=Fin.append x (WithLp.ofLp y) := rfl |
|
|
| lemma flatten_measurePreserving (m D : ℕ) : |
| MeasurePreserving (flatten m D) volume volume := |
| (appendEquiv_measurePreserving m D).comp |
| ((MeasurePreserving.id (volume : Measure (Fin m → ℝ))).prod |
| (PiLp.volume_preserving_ofLp (Fin D))) |
|
|
| lemma flatten_volume (m D : ℕ) {K : Set ((Fin m → ℝ) × EuclideanSpace ℝ (Fin D))} |
| (hK : IsCompact K) : volume (flatten m D '' K)=volume K := by |
| have h := (flatten_measurePreserving m D).measure_preimage |
| ((hK.image (flatten m D).toContinuousLinearEquiv.continuous).measurableSet.nullMeasurableSet) |
| change volume ((flatten m D) ⁻¹' ((flatten m D) '' K))=volume ((flatten m D) '' K) at h |
| rw [(flatten m D).injective.preimage_image] at h |
| exact h.symm |
|
|
| end SingleLatticeCovering.Sections |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Sections |
| open MeasureTheory Set |
| open scoped BigOperators |
|
|
|
|
|
|
| def coordinateFiber {m D : ℕ} (K : Set (Fin (m+D) → ℝ)) (y : Fin D → ℝ) : |
| Set (Fin m → ℝ) := {x | Fin.append x y ∈ K} |
|
|
| lemma flatten_fiber {m D : ℕ} (K : Set (Fin (m+D) → ℝ)) (y : EuclideanSpace ℝ (Fin D)) : |
| fiber ((flatten m D).symm '' K) y=coordinateFiber K (WithLp.ofLp y) := by |
| ext x |
| change (x,y) ∈ (flatten m D).symm '' K ↔ _ |
| constructor |
| · rintro ⟨z,hz,hzxy⟩ |
| change flatten m D (x,y) ∈ K |
| rw [←hzxy,(flatten m D).apply_symm_apply] |
| exact hz |
| · intro hx |
| exact ⟨flatten m D (x,y),hx,(flatten m D).symm_apply_apply _⟩ |
|
|
|
|
|
|
| theorem coordinate_marginal_to_labels {m D : ℕ} (hm : 2 ≤ m) (hD : 0 < D) |
| {K : Set (Fin (m+D) → ℝ)} (hK : IsCompact K) (hconv : Convex ℝ K) |
| (hV : 0 < (volume K).toReal) {R : ℝ} (hR : 0 < R) |
| (hsmall : R^2/(m : ℝ)^2 ≤ 1) |
| (hlower : ∀ y : Fin D → ℝ, ‖WithLp.toLp 2 y‖ ≤ 6*(D : ℝ)*R → |
| (volume K).toReal*Folded.gamma y/2 ≤ (volume (coordinateFiber K y)).toReal) : |
| ∃ e : (Fin (m+D) → ℝ) ≃ᵃ[ℝ] (Fin (m+D) → ℝ), |
| IsCompact (e '' K) ∧ Convex ℝ (e '' K) ∧ volume (e '' K)=volume K ∧ |
| ∃ S : Finset (EuclideanSpace ℝ (Fin D)), (S.card : ℝ) ≤ (3*(m : ℝ)^2)^D ∧ |
| ∃ J : EuclideanSpace ℝ (Fin D) → Set (Fin m → ℝ), |
| (∀ a ∈ S, IsCompact (J a) ∧ Convex ℝ (J a) ∧ (interior (J a)).Nonempty) ∧ |
| ∀ y : Fin D → ℝ, (∑ j, (y j)^2) ≤ R^2 → ∃ a ∈ S, |
| (∀ x ∈ J a, Fin.append x y ∈ e '' K) ∧ |
| (Real.exp (-1)/8)*(volume (e '' K)).toReal*Folded.gamma y ≤ (volume (J a)).toReal ∧ |
| (volume (J a)).toReal ≤ (Real.exp 1/8)*(volume (e '' K)).toReal*Folded.gamma y := by |
| let f := flatten m D |
| let Kp : Set ((Fin m → ℝ) × EuclideanSpace ℝ (Fin D)) := f.symm '' K |
| have hKp : IsCompact Kp := hK.image f.symm.toContinuousLinearEquiv.continuous |
| have hconvp : Convex ℝ Kp := hconv.linear_image f.symm.toLinearMap |
| have hflat : f '' Kp=K := by dsimp [Kp]; exact f.image_symm_image K |
| have hvolp : volume Kp=volume K := by rw [←flatten_volume m D hKp]; exact congrArg volume hflat |
| let b := EuclideanSpace.basisFun (Fin D) ℝ |
| have hunit : ∀ i, ‖b.toBasis i‖ ≤ 1 := by intro i; exact (b.orthonormal.1 i).le |
| have hcoord : ∀ y : EuclideanSpace ℝ (Fin D), ∀ i, |b.toBasis.repr y i| ≤ ‖y‖ := by |
| intro y i |
| rw [OrthonormalBasis.coe_toBasis_repr_apply] |
| simpa only [Real.norm_eq_abs,b,EuclideanSpace.basisFun_repr] using PiLp.norm_apply_le y i |
| obtain ⟨e,heK,heconv,hevol,S,hSc,J,hJ,hlabels⟩ := gaussian_marginal_to_sections hD b.toBasis hunit hcoord |
| (volume : Measure (Fin m → ℝ)) (volume : Measure (EuclideanSpace ℝ (Fin D))) hKp hconvp hR |
| (by simpa only [←Measure.volume_eq_prod,hvolp] using hV) |
| (by simpa using hm) (by |
| intro y hy |
| have hh := hlower y.ofLp (by simpa using hy) |
| simpa only [←Measure.volume_eq_prod,hvolp,Kp,f,flatten_fiber,←gaussian_toLp,WithLp.toLp_ofLp] using hh) |
| (by simpa using hsmall) |
| let e' : (Fin (m+D) → ℝ) ≃ᵃ[ℝ] (Fin (m+D) → ℝ) := |
| (f.symm.toAffineEquiv.trans e).trans f.toAffineEquiv |
| have he'image : e' '' K=f '' (e '' Kp) := by |
| change (fun x => f (e (f.symm x))) '' K = _ |
| simp only [Kp,Set.image_image] |
| have hevol' : volume (e '' Kp)=volume Kp := by simpa only [←Measure.volume_eq_prod] using hevol |
| have he'vol : volume (e' '' K)=volume K := by |
| rw [he'image,flatten_volume m D heK] |
| exact hevol'.trans hvolp |
| refine ⟨e',?_,?_,he'vol,S,?_,J,hJ,?_⟩ |
| · rw [he'image]; exact heK.image f.toContinuousLinearEquiv.continuous |
| · rw [he'image]; exact heconv.linear_image f.toLinearMap |
| · simpa using hSc |
| · intro y hy |
| have hynorm : ‖WithLp.toLp 2 y‖ ≤ R := by |
| apply (sq_le_sq₀ (norm_nonneg _) hR.le).mp |
| simpa only [EuclideanSpace.real_norm_sq_eq] using hy |
| obtain ⟨a,ha,hsub,hl,hu⟩ := hlabels (WithLp.toLp 2 y) hynorm |
| refine ⟨a,ha,?_,?_,?_⟩ |
| · intro x hx |
| rw [he'image] |
| exact ⟨(x,WithLp.toLp 2 y),hsub hx,rfl⟩ |
| · rw [←gaussian_toLp,he'vol,←hvolp] |
| simpa only [←Measure.volume_eq_prod,hevol'] using hl |
| · rw [←gaussian_toLp,he'vol,←hvolp] |
| simpa only [←Measure.volume_eq_prod,hevol'] using hu |
|
|
|
|
| end SingleLatticeCovering.Sections |
|
|
| end |
| end |
|
|
| section |
|
|
|
|
|
|
| noncomputable section |
| open Real Filter Topology Asymptotics |
|
|
| end |
| end |
| end |
|
|
| end OAI |
|
|
