| import OAI.Geometry.LatticeCovering.Rates |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
|
|
| namespace SingleLatticeCovering.Horizontal |
| open MeasureTheory Completion |
| open scoped ENNReal BigOperators |
|
|
|
|
|
|
| structure FullLattice (m : ℕ) where |
| module : Submodule ℤ (Fin m → ℝ) |
| discrete : DiscreteTopology module |
| full : IsZLattice ℝ module |
|
|
| attribute [instance] FullLattice.discrete FullLattice.full |
|
|
| namespace FullLattice |
|
|
| def hole {m : ℕ} (L : FullLattice m) (J : Set (Fin m → ℝ)) : ℝ≥0∞ := |
| torusMeasure m ((latticeProjection L.module '' J)ᶜ) |
|
|
| end FullLattice |
|
|
|
|
|
|
|
|
| theorem common_horizontal_from_mean {m : ℕ} {X α : Type*} [MeasurableSpace X] |
| (μ : Measure X) [IsProbabilityMeasure μ] (family : X → FullLattice m) |
| (J : α → Set (Fin m → ℝ)) (s : Finset α) (Dh CR η τ N : ℝ) |
| (hCR : 0 ≤ CR) (hDh : 0 < Dh) |
| (hcov : ∀ x, ZLattice.covolume (family x).module=Dh) |
| (hmeas : ∀ a ∈ s, Measurable (fun x => (family x).hole (J a))) |
| (hmean : ∀ a ∈ s, ∫⁻ x, (family x).hole (J a) ∂μ ≤ |
| ENNReal.ofReal (Real.exp (-(volume (J a)).toReal/Dh)+CR*Real.exp (-η))) |
| (hlo : ∀ a ∈ s, τ ≤ (volume (J a)).toReal/Dh) |
| (hhi : ∀ a ∈ s, (volume (J a)).toReal/Dh ≤ η) |
| (hcard : (s.card : ℝ) ≤ N) |
| (hcriterion : (1+CR)*N*Real.exp (-τ/2)<1) : |
| ∃ L : FullLattice m, ZLattice.covolume L.module=Dh ∧ |
| ∀ a ∈ s, L.hole (J a) ≤ ENNReal.ofReal (Real.exp (-((volume (J a)).toReal/Dh)/2)) := by |
| have _ := hDh |
| have hsum : (1+CR)*(∑ a ∈ s, Real.exp (-((volume (J a)).toReal/Dh)/2))<1 := by |
| apply lt_of_le_of_lt _ hcriterion |
| calc |
| _ ≤ (1+CR)*(∑ a ∈ s, Real.exp (-τ/2)) := mul_le_mul_of_nonneg_left |
| (Finset.sum_le_sum (fun a ha => Real.exp_le_exp.mpr (by linarith [hlo a ha]))) (by linarith) |
| _ = (1+CR)*(s.card : ℝ)*Real.exp (-τ/2) := by rw [Finset.sum_const, nsmul_eq_mul]; ring |
| _ ≤ _ := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hcard (by linarith)) (Real.exp_pos _).le |
| obtain ⟨x,hx⟩ := common_hole_sample μ s (fun a x => (family x).hole (J a)) |
| (fun a => (volume (J a)).toReal/Dh) CR η hCR hmeas hhi (by |
| intro a ha |
| simpa only [neg_div] using hmean a ha) hsum |
| exact ⟨family x,hcov x,hx⟩ |
|
|
|
|
| end SingleLatticeCovering.Horizontal |
|
|
| end |
| end |
|
|
| section |
|
|
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Assembly |
| open MeasureTheory Folded LatticeGeometry Completion Shear CoverGeometry Vertical Sections Horizontal |
| open scoped BigOperators Pointwise ENNReal |
|
|
|
|
|
|
|
|
|
|
|
|
| theorem sections_and_mean_cover {B : Block} (c : Chain B) {m : ℕ} |
| (hm : 2 ≤ m) (hD : 0 < c.fullDim) |
| (K : Set (Fin (m+c.fullDim) → ℝ)) (hK : IsCompact K) (hconv : Convex ℝ K) |
| (hV : 0 < (volume K).toReal) {R : ℝ} (hR : 0 < R) |
| (hrad : c.radiusSq+(B.terminalDim : ℝ) ≤ R^2) |
| (hsmall : R^2/(m : ℝ)^2 ≤ 1) |
| (hgauss : ∀ y : c.FullVec, ‖WithLp.toLp 2 y‖ ≤ 6*(c.fullDim : ℝ)*R → |
| (volume K).toReal*gamma y/2 ≤ (volume (coordinateFiber K y)).toReal) |
| (κ ρ ε τ A CR : ℝ) (hρ : 0 < ρ) (hτ : 0 ≤ τ) (hA : 0 < A) (hCR : 0 ≤ CR) |
| (hpat : ∀ y : c.FullVec, ∃ P : Finset c.FullVec, |
| P.Nonempty ∧ SuffixBinary P ∧ |
| (∀ l ∈ P, l ∈ c.fullRaw ∧ c.FullResidual y l ∧ c.det*gamma (y-c.fullLinear l) ≤ ε) ∧ |
| κ ≤ ∑ l ∈ P, c.det*gamma (y-c.fullLinear l)) |
| (hload : A+(2^c.fullDim : ℕ)*τ ≤ (Real.exp (-1)/8)*κ*ρ) |
| (hcap : (Real.exp 1/8)*ρ*ε ≤ FinalRates.eta m) |
| (hcriterion : (1+CR)*(3*(m : ℝ)^2)^c.fullDim*Real.exp (-τ/2)<1) |
| (hcount : ∀ {α : Type} (s : Finset α), (s.card : ℝ) ≤ (3*(m : ℝ)^2)^c.fullDim → |
| let Lstar := 2*((patternTotal c.alphabetSeq s c.fullDim : ℝ)+1) |
| 1 ≤ Lstar ∧ (patternTotal c.alphabetSeq s c.fullDim : ℝ)<Lstar ∧ |
| Real.exp ((2 : ℝ)^c.fullDim*Real.log Lstar-A/2) ≤ |
| 1/((m+c.fullDim : ℕ) : ℝ)^(2*(m+c.fullDim))) |
| {X : Type*} [MeasurableSpace X] (μ : Measure X) [IsProbabilityMeasure μ] |
| (family : X → FullLattice m) |
| (hcov : ∀ x, ZLattice.covolume (family x).module volume=(volume K).toReal/(ρ*c.det)) |
| (hmeas : ∀ J : Set (Fin m → ℝ), IsCompact J → Convex ℝ J → (interior J).Nonempty → |
| Measurable (fun x => (family x).hole J)) |
| (hmean : ∀ J : Set (Fin m → ℝ), IsCompact J → Convex ℝ J → (interior J).Nonempty → |
| (volume J).toReal/((volume K).toReal/(ρ*c.det)) ≤ FinalRates.eta m → |
| ∫⁻ x, (family x).hole J ∂μ ≤ |
| ENNReal.ofReal (Real.exp (-(volume J).toReal/((volume K).toReal/(ρ*c.det)))+ |
| CR*Real.exp (-FinalRates.eta m))) : |
| ∃ (Λ : Submodule ℤ (Fin (m+c.fullDim) → ℝ)) (_ : DiscreteTopology Λ), |
| IsZLattice ℝ Λ ∧ K+(Λ : Set (Fin (m+c.fullDim) → ℝ))=Set.univ ∧ |
| (volume K).toReal/ZLattice.covolume Λ volume ≤ Real.exp 1*ρ := by |
| classical |
| let Dh := (volume K).toReal/(ρ*c.det) |
| have hDh : 0 < Dh := div_pos hV (mul_pos hρ c.det_pos) |
| obtain ⟨e,heK,heconv,hevol,S,hSc,J,hJ,hsections⟩ := |
| coordinate_marginal_to_labels hm hD hK hconv hV hR hsmall hgauss |
| let α := {a // a ∈ S} |
| let J' : α → Set (Fin m → ℝ) := fun a => J a.val |
| let u : α → ℝ := fun a => (volume (J' a)).toReal/Dh |
| let s : Finset α := Finset.univ.filter (fun a => τ ≤ u a ∧ u a ≤ (Real.exp 1/8)*ρ*ε) |
| have hcard : (s.card : ℝ) ≤ (3*(m : ℝ)^2)^c.fullDim := by |
| have hh : s.card ≤ S.card := by |
| calc |
| s.card ≤ (Finset.univ : Finset α).card := Finset.card_le_card (Finset.filter_subset _ _) |
| _ = S.card := by simp [α] |
| exact (by exact_mod_cast hh : (s.card : ℝ) ≤ S.card).trans hSc |
| have hulo (a : α) (ha : a ∈ s) : τ ≤ u a := (Finset.mem_filter.mp ha).2.1 |
| have huhi (a : α) (ha : a ∈ s) : u a ≤ FinalRates.eta m := |
| ((Finset.mem_filter.mp ha).2.2).trans hcap |
| obtain ⟨L,hLc,hLhole⟩ := common_horizontal_from_mean μ family J' s Dh CR |
| (FinalRates.eta m) τ ((3*(m : ℝ)^2)^c.fullDim) hCR hDh hcov (by |
| intro a ha |
| exact hmeas (J' a) (hJ a.val a.property).1 (hJ a.val a.property).2.1 (hJ a.val a.property).2.2) |
| (by |
| intro a ha |
| exact hmean (J' a) (hJ a.val a.property).1 (hJ a.val a.property).2.1 |
| (hJ a.val a.property).2.2 (huhi a ha)) hulo huhi hcard hcriterion |
| let Lstar := 2*((patternTotal c.alphabetSeq s c.fullDim : ℝ)+1) |
| obtain ⟨hLstar,hcost,herror⟩ := hcount s hcard |
| have hV' : 0 < (volume (e '' K)).toReal := by rwa [hevol] |
| have hcov' : ZLattice.covolume L.module volume=(volume (e '' K)).toReal/(ρ*c.det) := by |
| rw [hevol]; exact hLc |
| obtain ⟨Λ,hd,hfull,hcover,hbound⟩ := labeled_chain_to_cover c (by omega) L.module (e '' K) |
| heK heconv hV' J' (fun a => (hJ a.val a.property).1) |
| κ ρ (Real.exp (-1)/8) (Real.exp 1/8) ε τ A Lstar hρ (by positivity) (by positivity) |
| hτ hA hcov' hpat (by |
| intro v hv |
| obtain ⟨a,ha,hin,hl,hu⟩ := hsections v (hv.trans hrad) |
| exact ⟨⟨a,ha⟩,hin,hl,hu⟩) (by |
| intro a hlo hhi |
| have ha : a ∈ s := by |
| apply Finset.mem_filter.mpr |
| refine ⟨Finset.mem_univ _,?_,?_⟩ |
| · simpa only [hLc] using hlo |
| · simpa only [hLc] using hhi |
| simpa only [FullLattice.hole,hLc] using hLhole a ha) hload hLstar (by |
| simpa only [hLc,s,u,patternTotal,Lstar] using hcost) (by |
| simpa only [Nat.cast_pow,Nat.cast_ofNat] using herror) |
| let := hd |
| let := hfull |
| exact pull_back_cover e K Λ hcover hbound |
|
|
|
|
| end SingleLatticeCovering.Assembly |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Inputs |
| open MeasureTheory Completion Horizontal Sections |
| open scoped ENNReal |
|
|
|
|
|
|
|
|
| structure MeanHoleModel (m : ℕ) (Dh CR : ℝ) where |
| Sample : Type |
| measurable : MeasurableSpace Sample |
| measure : @Measure Sample measurable |
| probability : @IsProbabilityMeasure Sample measurable measure |
| lattice : Sample → FullLattice m |
| covolume : ∀ x, ZLattice.covolume (lattice x).module volume=Dh |
| measurable_hole : letI := measurable |
| ∀ J : Set (Fin m → ℝ), IsCompact J → Convex ℝ J → (interior J).Nonempty → |
| Measurable (fun x => (lattice x).hole J) |
| mean : letI := measurable |
| ∀ J : Set (Fin m → ℝ), IsCompact J → Convex ℝ J → (interior J).Nonempty → |
| (volume J).toReal/Dh ≤ FinalRates.eta m → |
| ∫⁻ x, (lattice x).hole J ∂measure ≤ |
| ENNReal.ofReal (Real.exp (-(volume J).toReal/Dh)+CR*Real.exp (-FinalRates.eta m)) |
|
|
|
|
|
|
|
|
|
|
| def GaussianPositions (α β γ C₀ : ℝ) (n : ℕ) : Prop := |
| ∀ m D : ℕ, m+D=n → 0 < D → (D : ℝ) ≤ (n : ℝ)^α → |
| ∀ K : Set (Fin (m+D) → ℝ), IsCompact K → Convex ℝ K → (interior K).Nonempty → |
| ∃ e : (Fin (m+D) → ℝ) ≃ᵃ[ℝ] (Fin (m+D) → ℝ), |
| ∀ y : Fin D → ℝ, ‖WithLp.toLp 2 y‖ ≤ (n : ℝ)^β → |
| (1-C₀*(n : ℝ)^(-γ))*(volume (e '' K)).toReal*Folded.gamma y ≤ |
| (volume (coordinateFiber (e '' K) y)).toReal |
|
|
| end SingleLatticeCovering.Inputs |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.FinalRates |
| open Real Filter Topology |
|
|
|
|
| def sectionRadius (C : ℝ) (n : ℕ) : ℝ := (C+1)*((firstSize n : ℝ)+1) |
|
|
| lemma sectionRadius_pos {C : ℝ} (hC : 0 < C) (n : ℕ) : 0 < sectionRadius C n := by |
| dsimp [sectionRadius]; positivity |
|
|
| lemma radius_sq_bound {C b r : ℝ} (hC : 0 ≤ C) (hb : 0 ≤ b) |
| (hr : r ≤ C*(b*Real.log (b+1)+1)) : r ≤ ((C+1)*(b+1))^2 := by |
| have hl : Real.log (b+1) ≤ b := by simpa using Real.log_le_sub_one_of_pos (by linarith : 0 < b+1) |
| have hinner : b*Real.log (b+1)+1 ≤ (b+1)^2 := by nlinarith [mul_le_mul_of_nonneg_left hl hb] |
| calc |
| r ≤ C*(b*Real.log (b+1)+1) := hr |
| _ ≤ C*(b+1)^2 := mul_le_mul_of_nonneg_left hinner hC |
| _ ≤ (C+1)^2*(b+1)^2 := mul_le_mul_of_nonneg_right (by nlinarith [sq_nonneg C]) (sq_nonneg _) |
| _ = _ := by ring |
|
|
| lemma eventually_first_polynomial {H r ε : ℝ} (hH : 0 < H) (hr : 0 < r) (hε : 0 < ε) (k : ℕ) : |
| ∀ᶠ n : ℕ in atTop, H*((firstSize n : ℝ)+1)^k ≤ ε*(n : ℝ)^r := by |
| filter_upwards [eventually_firstSize_le_log (by norm_num : (0 : ℝ) < 1), |
| eventually_log_power_bound k hr (div_pos hε hH)] with n hfirst hlog |
| simp only [one_mul] at hfirst |
| calc |
| _ ≤ H*(Real.log (n : ℝ))^k := mul_le_mul_of_nonneg_left |
| (pow_le_pow_left₀ (by positivity) hfirst k) hH.le |
| _ ≤ H*((ε/H)*(n : ℝ)^r) := mul_le_mul_of_nonneg_left hlog hH.le |
| _ = _ := by field_simp |
|
|
|
|
|
|
|
|
| lemma eventually_marginal_scales {C α β γ C₀ : ℝ} (hC : 0 < C) |
| (hα : 0 < α) (hβ : 0 < β) (hγ : 0 < γ) (hC₀ : 0 ≤ C₀) : |
| ∀ᶠ n : ℕ in atTop, ∀ D : ℕ, (D : ℝ) ≤ C*((firstSize n : ℝ)+1) → |
| D ≤ n ∧ 2 ≤ n-D ∧ (D : ℝ) ≤ (n : ℝ)^α ∧ |
| 6*(D : ℝ)*sectionRadius C n < (n : ℝ)^β ∧ |
| C₀*(n : ℝ)^(-γ) ≤ 1/2 ∧ |
| sectionRadius C n^2/((n-D : ℕ) : ℝ)^2 ≤ 1 := by |
| have _ := hC₀ |
| have herr : ∀ᶠ n : ℕ in atTop, C₀*(n : ℝ)^(-γ) ≤ 1/2 := by |
| have ht : Tendsto (fun n : ℕ => C₀*(n : ℝ)^(-γ)) atTop (𝓝 0) := by |
| have hn : Tendsto (fun n : ℕ => (n : ℝ)) atTop atTop := tendsto_natCast_atTop_atTop |
| simpa only [mul_zero,Function.comp_def] using ((tendsto_rpow_neg_atTop hγ).comp hn).const_mul C₀ |
| exact ht.eventually (eventually_le_nhds (by norm_num : (0 : ℝ) < 1/2)) |
| filter_upwards [eventually_first_polynomial hC hα (by norm_num : (0 : ℝ) < 1) 1, |
| eventually_first_polynomial (show 0 < 6*C*(C+1) by positivity) hβ (by norm_num : (0 : ℝ) < 1/2) 2, |
| eventually_first_polynomial (show 0 < C+1 by linarith) (by norm_num : (0 : ℝ) < 1) |
| (by norm_num : (0 : ℝ) < 1/2) 1, |
| eventually_dimension_small hC,herr,eventually_ge_atTop (4 : ℕ)] with n hDim hRad hSmall hDsmall he hn D hD |
| simp only [pow_one,one_mul] at hDim |
| simp only [pow_one,Real.rpow_one] at hSmall |
| have hn4 : (4 : ℝ) ≤ n := by exact_mod_cast hn |
| have hn0 : (0 : ℝ) < n := by linarith |
| have hdhalf := (hDsmall D hD).2 |
| have hDn : D ≤ n := by exact_mod_cast (show (D : ℝ) ≤ n by linarith) |
| have hmhalf : (n : ℝ)/2 ≤ ((n-D : ℕ) : ℝ) := by rw [Nat.cast_sub hDn]; linarith |
| have hm2 : (2 : ℝ) ≤ ((n-D : ℕ) : ℝ) := by linarith |
| refine ⟨hDn,by exact_mod_cast hm2,hD.trans hDim,?_,he,?_⟩ |
| · have hDR : 6*(D : ℝ)*sectionRadius C n ≤ 6*C*(C+1)*((firstSize n : ℝ)+1)^2 := by |
| dsimp [sectionRadius] |
| have hh := mul_le_mul_of_nonneg_right hD (show 0 ≤ 6*((C+1)*((firstSize n : ℝ)+1)) by positivity) |
| nlinarith |
| have hp : 0 < (n : ℝ)^β := Real.rpow_pos_of_pos hn0 β |
| exact hDR.trans_lt (hRad.trans_lt (by nlinarith)) |
| · have hRm : sectionRadius C n ≤ ((n-D : ℕ) : ℝ) := by |
| dsimp [sectionRadius] |
| linarith |
| apply (div_le_one (sq_pos_of_pos (by linarith : (0 : ℝ) < ((n-D : ℕ) : ℝ)))).mpr |
| exact pow_le_pow_left₀ (sectionRadius_pos hC n).le hRm 2 |
|
|
|
|
| end SingleLatticeCovering.FinalRates |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace SingleLatticeCovering.Assembly |
| open MeasureTheory Folded LatticeGeometry Completion Shear CoverGeometry Vertical Sections Horizontal Inputs |
| open Filter Topology |
| open scoped BigOperators Pointwise ENNReal |
|
|
| lemma body_volume_pos {n : ℕ} {K : Set (Fin n → ℝ)} (hK : IsCompact K) |
| (hi : (interior K).Nonempty) : 0 < (volume K).toReal := by |
| apply ENNReal.toReal_pos (ne_of_gt ?_) hK.measure_ne_top |
| exact (isOpen_interior.measure_pos volume hi).trans_le (measure_mono interior_subset) |
|
|
| lemma affine_body {n : ℕ} (e : (Fin n → ℝ) ≃ᵃ[ℝ] (Fin n → ℝ)) |
| {K : Set (Fin n → ℝ)} (hK : IsCompact K) (hc : Convex ℝ K) (hi : (interior K).Nonempty) : |
| IsCompact (e '' K) ∧ Convex ℝ (e '' K) ∧ (interior (e '' K)).Nonempty := by |
| let he : (Fin n → ℝ) ≃ₜ (Fin n → ℝ) := |
| { toEquiv := e.toEquiv |
| continuous_toFun := e.toAffineMap.continuous_of_finiteDimensional |
| continuous_invFun := e.symm.toAffineMap.continuous_of_finiteDimensional } |
| refine ⟨hK.image he.continuous, hc.affine_image e.toAffineMap,?_⟩ |
| change (interior (he '' K)).Nonempty |
| rw [←he.image_interior] |
| exact hi.image he |
|
|
| lemma chain_first_le_dim {B : Block} (c : Chain B) : c.first.b ≤ c.dim := by |
| induction c with |
| | base B => rfl |
| | append c B w ih => exact ih.trans (Nat.le_add_right _ _) |
|
|
|
|
| def coversAtBound (n : ℕ) (d : ℝ) : Prop := |
| ∀ K : Set (Fin n → ℝ), IsCompact K → Convex ℝ K → (interior K).Nonempty → |
| ∃ (Λ : Submodule ℤ (Fin n → ℝ)) (_ : DiscreteTopology Λ), IsZLattice ℝ Λ ∧ |
| K+(Λ : Set (Fin n → ℝ))=Set.univ ∧ |
| (volume K).toReal/ZLattice.covolume Λ volume ≤ d |
|
|
|
|
|
|
|
|
|
|
|
|
| theorem eventual_main_reduction {α β γ C₀ CR : ℝ} |
| (hα : 0 < α) (hβ : 0 < β) (hγ : 0 < γ) (hC₀ : 0 ≤ C₀) (hCR : 0 ≤ CR) |
| (hGaussian : ∀ᶠ n : ℕ in atTop, GaussianPositions α β γ C₀ n) |
| (hMean : ∀ m : ℕ, 2 ≤ m → ∀ Dh : ℝ, 0 < Dh → Nonempty (MeanHoleModel m Dh CR)) : |
| ∃ C : ℝ, 0 < C ∧ ∀ᶠ n : ℕ in atTop, ∀ K : Set (Fin n → ℝ), |
| IsCompact K → Convex ℝ K → (interior K).Nonempty → |
| ∃ (Λ : Submodule ℤ (Fin n → ℝ)) (_ : DiscreteTopology Λ), IsZLattice ℝ Λ ∧ |
| K+(Λ : Set (Fin n → ℝ))=Set.univ ∧ |
| (volume K).toReal/ZLattice.covolume Λ volume ≤ C*(n : ℝ)*Real.log (n : ℝ) := by |
| classical |
| obtain ⟨cutoff,hcut,C,k,κ,hC,hk,hκ,hvertical⟩ := vertical_patterns_alphabets |
| obtain ⟨Cstar,hstar,hconditions⟩ := FinalRates.final_conditions hC hk |
| (show 0 < Real.exp (-1)/8 by positivity) (show 0 ≤ Real.exp 1/8 by positivity) |
| hκ (show (1 : ℝ) ≤ 3 by norm_num) hCR |
| refine ⟨Real.exp 1*Cstar,by positivity,?_⟩ |
| filter_upwards [hconditions,FinalRates.eventually_marginal_scales hC hα hβ hγ hC₀, |
| FinalRates.firstSize_tendsto.eventually (eventually_ge_atTop cutoff), hGaussian] |
| with n hn hscale hfirst hgaussian |
| obtain ⟨B,c,hcb,hcs,hDim,hRad,hAlphabet,hPattern⟩ := hvertical (FinalRates.firstSize n) hfirst |
| have hDdim : (c.fullDim : ℝ) ≤ C*((FinalRates.firstSize n : ℝ)+1) := by |
| simpa [Chain.fullDim,Nat.cast_add] using hDim |
| obtain ⟨hDn,hm,hcap,hload,hcrit,hcount⟩ := hn.2 c.fullDim hDdim |
| obtain ⟨_,_,hDpower,hRadius,hErr,hSmall⟩ := hscale c.fullDim hDdim |
| have hD : 0 < c.fullDim := by |
| have hfirstdim := chain_first_le_dim c |
| rw [hcb] at hfirstdim |
| dsimp [Chain.fullDim] |
| omega |
| let m := n-c.fullDim |
| have hmn : m+c.fullDim=n := Nat.sub_add_cancel hDn |
| have hmnle : m ≤ n := Nat.sub_le _ _ |
| have hnpos : (0 : ℝ) < n := by exact_mod_cast (show 0 < n by omega) |
| have hnlog : 0 < Real.log (n : ℝ) := Real.log_pos (by exact_mod_cast (show 1 < n by omega)) |
| let ρ := Cstar*(n : ℝ)*Real.log (n : ℝ) |
| let ε := Real.exp (-k*(FinalRates.firstSize n : ℝ)^(70/100 : ℝ)) |
| let R := FinalRates.sectionRadius C n |
| have hρ : 0 < ρ := by dsimp [ρ]; positivity |
| have hrad : c.radiusSq+(B.terminalDim : ℝ) ≤ R^2 := |
| FinalRates.radius_sq_bound hC.le (Nat.cast_nonneg _) hRad |
| have step : coversAtBound (m+c.fullDim) ((Real.exp 1*Cstar)*(n : ℝ)*Real.log (n : ℝ)) := by |
| intro K hK hc hi |
| obtain ⟨e,he⟩ := hgaussian m c.fullDim hmn hD hDpower K hK hc hi |
| obtain ⟨heK,hec,hei⟩ := affine_body e hK hc hi |
| have heV := body_volume_pos heK hei |
| have hg : ∀ y : c.FullVec, ‖WithLp.toLp 2 y‖ ≤ 6*(c.fullDim : ℝ)*R → |
| (volume (e '' K)).toReal*gamma y/2 ≤ (volume (coordinateFiber (e '' K) y)).toReal := by |
| intro y hy |
| apply le_trans _ (he y (hy.trans hRadius.le)) |
| have hy0 : 0 < gamma y := Finset.prod_pos (fun j _ => gamma1_pos _) |
| nlinarith [mul_nonneg (show 0 ≤ 1-C₀*(n : ℝ)^(-γ)-1/2 by linarith) |
| (mul_nonneg heV.le hy0.le)] |
| obtain ⟨model⟩ := hMean m hm ((volume (e '' K)).toReal/(ρ*c.det)) |
| (div_pos heV (mul_pos hρ c.det_pos)) |
| let := model.measurable |
| let := model.probability |
| obtain ⟨Λ,hd,hfull,hcover,hbound⟩ := sections_and_mean_cover c hm hD (e '' K) heK hec heV |
| (FinalRates.sectionRadius_pos hC n) hrad hSmall hg κ ρ ε (Real.sqrt (m : ℝ)) |
| (8*(n : ℝ)*Real.log (n : ℝ)) CR hρ (Real.sqrt_nonneg _) (by positivity) hCR |
| (by |
| intro y |
| obtain ⟨P,hPn,hPb,hPl,hPt,hPw⟩ := hPattern y |
| exact ⟨P,hPn,hPb,hPl,hPw⟩) |
| (by simpa only [Nat.cast_pow,Nat.cast_ofNat] using hload) hcap hcrit (by |
| intro δ s hs |
| have hs' : (s.card : ℝ) ≤ (3*(n : ℝ)^2)^c.fullDim := hs.trans (by |
| gcongr) |
| have ha : ∀ j < c.fullDim, Real.log ((c.alphabetSeq j).card+1 : ℝ) ≤ |
| Real.log 8+(c.fullDim : ℝ)*Real.log ((c.fullDim : ℝ)+2)+(FinalRates.firstSize n : ℝ)^2 := by |
| intro j hj |
| simpa only [c.alphabetSeq_fin ⟨j,hj⟩] using hAlphabet ⟨j,hj⟩ |
| simpa only [Nat.sub_add_cancel hDn] using hcount s c.alphabetSeq hs' ha) |
| model.measure model.lattice model.covolume model.measurable_hole model.mean |
| let := hd |
| let := hfull |
| have hb : (volume (e '' K)).toReal/ZLattice.covolume Λ volume ≤ |
| (Real.exp 1*Cstar)*(n : ℝ)*Real.log (n : ℝ) := by |
| convert hbound using 1 ; dsimp [ρ] ; ring |
| exact pull_back_cover e K Λ hcover hb |
| change coversAtBound n ((Real.exp 1*Cstar)*(n : ℝ)*Real.log (n : ℝ)) |
| simpa only [hmn] using step |
|
|
|
|
| end SingleLatticeCovering.Assembly |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Module MeasureTheory |
| open scoped BigOperators Pointwise |
| namespace SingleLatticeCovering.FiniteDimensions |
|
|
|
|
|
|
|
|
| theorem maximal_basis {n : ℕ} (K : Set (Fin n → ℝ)) (hK : IsCompact K) |
| (h0 : (0 : Fin n → ℝ) ∈ interior K) : |
| ∃ b : Basis (Fin n) ℝ (Fin n → ℝ), |
| (∀ j, b j ∈ K) ∧ ∀ x ∈ K, ∀ j, |b.repr x j| ≤ 1 := by |
| classical |
| obtain ⟨r,hr,hball⟩ := Metric.mem_nhds_iff.mp (mem_interior_iff_mem_nhds.mp h0) |
| let v₀ : Fin n → (Fin n → ℝ) := fun j => (r/2) • Pi.single j (1 : ℝ) |
| have hv₀ : ∀ j, v₀ j ∈ K := by |
| intro j |
| apply hball |
| rw [Metric.mem_ball,dist_zero_right] |
| simp only [v₀,norm_smul,Pi.norm_single,Real.norm_eq_abs,abs_one,mul_one, |
| abs_of_pos (by positivity : 0 < r/2)] |
| linarith |
| have hdet₀ : (Matrix.of v₀).det = (r/2)^n := by |
| have he : Matrix.of v₀ = (r/2) • (1 : Matrix (Fin n) (Fin n) ℝ) := by |
| ext i j |
| simp [v₀,Pi.single_apply,Matrix.one_apply,Pi.smul_apply,eq_comm] |
| rw [he,Matrix.det_smul,Matrix.det_one,mul_one,Fintype.card_fin] |
| have hS : IsCompact {v : Fin n → (Fin n → ℝ) | ∀ j, v j ∈ K} := |
| isCompact_pi_infinite (fun _ => hK) |
| have hcont : Continuous (fun v : Fin n → (Fin n → ℝ) => |(Matrix.of v).det|) := by |
| fun_prop |
| obtain ⟨v,hv,hmax⟩ := hS.exists_isMaxOn ⟨v₀,hv₀⟩ hcont.continuousOn |
| have hdet : (Matrix.of v).det ≠ 0 := by |
| have h : |(Matrix.of v₀).det| ≤ |(Matrix.of v).det| := hmax hv₀ |
| rw [hdet₀,abs_of_pos (pow_pos (by positivity : 0 < r/2) _)] at h |
| intro hz |
| rw [hz,abs_zero] at h |
| exact (not_le_of_gt (pow_pos (by positivity : 0 < r/2) _)) h |
| let b := basisOfLinearIndependentOfCardEqFinrank' v |
| (Matrix.linearIndependent_rows_of_det_ne_zero hdet) (by simp) |
| have hb : (b : Fin n → (Fin n → ℝ)) = v := by |
| simp [b] |
| refine ⟨b,?_,?_⟩ |
| · intro j |
| rw [show b j=v j from congrFun hb j] |
| exact hv j |
| · intro x hx j |
| have hupdate : (Function.update v j x) ∈ {v : Fin n → (Fin n → ℝ) | ∀ j, v j ∈ K} := by |
| intro k |
| by_cases hk : k=j |
| · subst k; simpa using hx |
| · simpa [hk] using hv k |
| have hbound := hmax hupdate |
| have hd : (Matrix.of (Function.update v j x)).det = b.repr x j*(Matrix.of v).det := by |
| have hs := b.sum_repr x |
| have ht := Matrix.det_updateRow_sum (Matrix.of b) j (fun k => b.repr x k) |
| change (Matrix.of (Function.update (fun k => b k) j (∑ k, b.repr x k • b k))).det = |
| b.repr x j*(Matrix.of b).det at ht |
| rw [hs,hb] at ht |
| exact ht |
| change |(Matrix.of (Function.update v j x)).det| ≤ |(Matrix.of v).det| at hbound |
| rw [hd,abs_mul] at hbound |
| exact (mul_le_mul_iff_left₀ (abs_pos.mpr hdet)).mp (by simpa [mul_comm] using hbound) |
| |
| |
| end SingleLatticeCovering.FiniteDimensions |
| |
| namespace SingleLatticeCovering.FiniteDimensions |
| open MeasureTheory Module Set Completion Vertical LatticeGeometry |
| open scoped BigOperators Pointwise |
| |
| lemma convex_basis_cube {n : ℕ} (hn : 0 < n) (K : Set (Fin n → ℝ)) |
| (hconv : Convex ℝ K) (h0 : (0 : Fin n → ℝ) ∈ K) |
| (b : Basis (Fin n) ℝ (Fin n → ℝ)) (hb : ∀ j, b j ∈ K) : |
| Icc (0 : Fin n → ℝ) (fun _ => 1/(n : ℝ)) ⊆ b.equivFun.symm ⁻¹' K := by |
| intro x hx |
| have hnr : (0 : ℝ) < n := by exact_mod_cast hn |
| have hsum : ∑ j, x j ≤ 1 := calc |
| ∑ j, x j ≤ ∑ _j : Fin n, 1/(n : ℝ) := Finset.sum_le_sum (fun j _ => hx.2 j) |
| _ = 1 := by simp [hnr.ne'] |
| let w : Fin (n+1) → ℝ := Fin.cons (1-∑ j, x j) x |
| let z : Fin (n+1) → (Fin n → ℝ) := Fin.cons 0 b |
| have hw : ∀ j ∈ (Finset.univ : Finset (Fin (n+1))), 0 ≤ w j := by |
| intro j _ |
| refine Fin.cases ?_ (fun i => ?_) j |
| · exact sub_nonneg.mpr hsum |
| · exact hx.1 i |
| have hw1 : ∑ j, w j = 1 := by simp [w,Fin.sum_univ_succ] |
| have hz : ∀ j ∈ (Finset.univ : Finset (Fin (n+1))), z j ∈ K := by |
| intro j _ |
| exact Fin.cases h0 hb j |
| have hc := hconv.sum_mem hw hw1 hz |
| change b.equivFun.symm x ∈ K |
| rw [Basis.equivFun_symm_apply] |
| simpa only [Fin.sum_univ_succ,w,z,Fin.cons_zero,Fin.cons_succ,smul_zero,zero_add] using hc |
| |
| lemma integer_cube_cover {n : ℕ} (hn : 0 < n) : |
| Icc (0 : Fin n → ℝ) (fun _ => 1/(n : ℝ))+ |
| (contractLattice (integerLattice n) (n : ℝ) (by exact_mod_cast hn.ne') : Set (Fin n → ℝ)) = |
| Set.univ := by |
| apply Set.eq_univ_of_forall |
| intro x |
| have hnr : (0 : ℝ) < n := by exact_mod_cast hn |
| let l : Fin n → ℝ := fun j => (⌊(n : ℝ)*x j⌋ : ℤ)/(n : ℝ) |
| let q : Fin n → ℝ := fun j => Int.fract ((n : ℝ)*x j)/(n : ℝ) |
| have hl : l ∈ contractLattice (integerLattice n) (n : ℝ) (by exact_mod_cast hn.ne') := by |
| rw [mem_contractLattice] |
| convert integer_mem n (fun j => ⌊(n : ℝ)*x j⌋) using 1 |
| ext j |
| simp only [Pi.smul_apply,smul_eq_mul,l] |
| field_simp |
| refine ⟨q,⟨?_,?_⟩,l,hl,?_⟩ |
| · intro j |
| exact div_nonneg (Int.fract_nonneg _) hnr.le |
| · intro j |
| exact (div_le_div_iff_of_pos_right hnr).mpr (Int.fract_lt_one _).le |
| · ext j |
| change Int.fract ((n : ℝ)*x j)/(n : ℝ)+(⌊(n : ℝ)*x j⌋ : ℤ)/(n : ℝ)=x j |
| rw [←add_div,Int.fract_add_floor] |
| exact mul_div_cancel_left₀ _ hnr.ne' |
|
|
|
|
|
|
| end SingleLatticeCovering.FiniteDimensions |
|
|
| namespace SingleLatticeCovering.FiniteDimensions |
| open MeasureTheory Module Set Completion Vertical LatticeGeometry |
| open scoped BigOperators Pointwise |
|
|
|
|
|
|
| theorem finite_dimension_cover {n : ℕ} (hn : 0 < n) |
| (K : Set (Fin n → ℝ)) (hK : IsCompact K) (hconv : Convex ℝ K) |
| (hinterior : (interior K).Nonempty) : |
| ∃ (L : Submodule ℤ (Fin n → ℝ)) (_ : DiscreteTopology L), |
| IsZLattice ℝ L ∧ K+(L : Set (Fin n → ℝ))=univ ∧ |
| (volume K).toReal / ZLattice.covolume L ≤ (2*(n : ℝ))^n := by |
| classical |
| obtain ⟨x₀,hx₀⟩ := hinterior |
| let t := Homeomorph.addRight x₀ |
| let K₀ := t ⁻¹' K |
| have hK₀ : IsCompact K₀ := t.isCompact_preimage.mpr hK |
| have h0 : (0 : Fin n → ℝ) ∈ interior K₀ := by |
| rw [←t.preimage_interior] |
| change 0+x₀ ∈ interior K |
| simpa using hx₀ |
| have hconv₀ : Convex ℝ K₀ := by |
| intro x hx y hy a b ha hb hab |
| have hh := hconv hx hy ha hb hab |
| change a • (x+x₀)+b • (y+x₀) ∈ K at hh |
| change a • x+b • y+x₀ ∈ K |
| have he : a • (x+x₀)+b • (y+x₀) = a • x+b • y+x₀ := by |
| calc |
| _ = (a • x+b • y)+(a+b) • x₀ := by module |
| _ = _ := by rw [hab,one_smul] |
| rwa [he] at hh |
| obtain ⟨b,hb,hbound⟩ := maximal_basis K₀ hK₀ h0 |
| let e := b.equivFun.symm |
| let K' := e ⁻¹' K₀ |
| have hsmall : Icc (0 : Fin n → ℝ) (fun _ => 1/(n : ℝ)) ⊆ K' := |
| convex_basis_cube hn K₀ hconv₀ (interior_subset h0) b hb |
| have hlarge : K' ⊆ Icc (fun _ : Fin n => (-1 : ℝ)) (fun _ => 1) := by |
| intro x hx |
| have hb' := hbound (e x) hx |
| have hj (j : Fin n) : |x j| ≤ 1 := by |
| have hh : |b.equivFun (e x) j| ≤ 1 := hb' j |
| simpa only [e,LinearEquiv.apply_symm_apply] using hh |
| exact ⟨fun j => (abs_le.mp (hj j)).1,fun j => (abs_le.mp (hj j)).2⟩ |
| have hnr : (0 : ℝ) < n := by exact_mod_cast hn |
| let L₀ := contractLattice (integerLattice n) (n : ℝ) hnr.ne' |
| have hcover : K'+(L₀ : Set (Fin n → ℝ))=univ := by |
| apply Set.eq_univ_of_univ_subset |
| rw [←integer_cube_cover hn] |
| exact Set.add_subset_add_right hsmall |
| have hvolume : (volume K').toReal ≤ (2 : ℝ)^n := by |
| have hh := ENNReal.toReal_mono (isCompact_Icc.measure_ne_top (μ := volume)) (measure_mono hlarge) |
| rw [Real.volume_Icc_pi_toReal (by intro j; norm_num)] at hh |
| norm_num at hh |
| exact hh |
| have hcov : ZLattice.covolume L₀ = (n : ℝ)⁻¹^n := by |
| rw [contractLattice_covolume _ _ hnr,integerLattice_covolume,mul_one] |
| have hdens : (volume K').toReal / ZLattice.covolume L₀ ≤ (2*(n : ℝ))^n := by |
| rw [hcov,inv_pow,div_inv_eq_mul,mul_pow] |
| exact mul_le_mul_of_nonneg_right hvolume (pow_nonneg hnr.le _) |
| have himage : (fun x => e x+x₀) '' K'=K := by |
| ext x |
| constructor |
| · rintro ⟨y,hy,rfl⟩ |
| exact hy |
| · intro hx |
| refine ⟨e.symm (x-x₀),?_,?_⟩ |
| · change e (e.symm (x-x₀))+x₀ ∈ K |
| simpa using hx |
| · simp |
| refine ⟨image L₀ e,inferInstance,inferInstance,?_,?_⟩ |
| · rw [←himage] |
| exact affine_image_cover L₀ e x₀ K' hcover |
| · rw [←himage,affine_image_density] |
| exact hdens |
| |
| |
| end SingleLatticeCovering.FiniteDimensions |
| |
| |
| end |
| end |
| end |
| |
| end OAI |
| |
