Blame for lean/OAI/Geometry/LatticeCovering/Covering.lean

import OAI.Geometry.LatticeCovering.Completion

namespace OAI

section
section
noncomputable section

namespace SingleLatticeCovering.CoverGeometry
open MeasureTheory Completion LatticeGeometry
open scoped Pointwise ENNReal




theorem quotient_hole_bound {m D : ℕ}
    (L : Submodule ℤ (Fin m → ℝ)) [DiscreteTopology L] [IsZLattice ℝ L]
    (N : Submodule ℤ (Fin D → ℝ)) [DiscreteTopology N] [IsZLattice ℝ N]
    (M : (Fin D → ℝ) ≃ₗ[ℝ] (Fin D → ℝ)) (Z : Fin D → (Fin m → ℝ))
    (K : Set (Fin (m+D) → ℝ)) (hK : IsCompact K) (ε : ℝ≥0∞)
    (hhole : ∀ y, torusMeasure m (horizontalHole L K (joinedLattice L N M Z) y) ≤ ε) :
    torusMeasure (m+D) ((joinedProjection L N M Z '' K)ᶜ) ≤ ε := by
  let π := joinedProjection L N M Z
  have hC : MeasurableSet ((π '' K)ᶜ) := (hK.image π.continuous).measurableSet.compl
  rw [←(appendTorus_measurePreserving m D).measure_preimage hC.nullMeasurableSet]
  have hpre : MeasurableSet ((appendTorus m D) ⁻¹' (π '' K)ᶜ) :=
    (appendTorus m D).continuous.measurable hC
  rw [Measure.prod_apply_symm hpre]
  calc
    (∫⁻ v : Torus D, torusMeasure m ((fun t => (t,v)) ⁻¹'
        ((appendTorus m D) ⁻¹' (π '' K)ᶜ)) ∂(torusMeasure D)) ≤
        (∫⁻ _v : Torus D, ε ∂(torusMeasure D)) := by
      apply lintegral_mono
      intro v
      obtain ⟨z,hz⟩ := latticeProjection_surjective N v
      have hsub : (fun t => (t,v)) ⁻¹' ((appendTorus m D) ⁻¹' (π '' K)ᶜ) ⊆
          (fun t => t+latticeProjection L (columnMap Z z)) ⁻¹'
            horizontalHole L K (joinedLattice L N M Z) (M z) := by
        intro t ht
        obtain ⟨x,hx⟩ := latticeProjection_surjective L (t+latticeProjection L (columnMap Z z))
        have hπ : π (Fin.append x (M z)) = appendTorus m D (t,v) := by
          simp only [π,joinedProjection_append,map_sub,hx,hz,add_sub_cancel_right]
          rfl
        have hnot : Fin.append x (M z) ∉ K+(joinedLattice L N M Z : Set (Fin (m+D) → ℝ)) := by
          intro hc
          have hm := (projection_mem_image_iff (joinedLattice L N M Z) π.toAddMonoidHom
            (joinedProjection_eq_zero_iff L N M Z) K (Fin.append x (M z))).mpr hc
          change π (Fin.append x (M z)) ∈ π '' K at hm
          rw [hπ] at hm
          exact ht hm
        exact ⟨x,hnot,hx⟩
      apply le_trans (measure_mono hsub)
      rw [measure_preimage_add_right]
      exact hhole (M z)
    _ = ε := by simp

lemma quotient_real_hole_bound {m D : ℕ}
    (L : Submodule ℤ (Fin m → ℝ)) [DiscreteTopology L] [IsZLattice ℝ L]
    (N : Submodule ℤ (Fin D → ℝ)) [DiscreteTopology N] [IsZLattice ℝ N]
    (M : (Fin D → ℝ) ≃ₗ[ℝ] (Fin D → ℝ)) (Z : Fin D → (Fin m → ℝ))
    (K : Set (Fin (m+D) → ℝ)) (hK : IsCompact K) (ε : ℝ) (hε : 0 ≤ ε)
    (hhole : ∀ y, torusMeasure m (horizontalHole L K (joinedLattice L N M Z) y) ≤ ENNReal.ofReal ε) :
    1-(torusMeasure (m+D)).real (joinedProjection L N M Z '' K) ≤ ε := by
  have h := ENNReal.toReal_mono ENNReal.ofReal_ne_top
    (quotient_hole_bound L N M Z K hK (ENNReal.ofReal ε) hhole)
  rw [ENNReal.toReal_ofReal hε] at h
  have he := measureReal_compl (μ := torusMeasure (m+D))
    (hK.image (joinedProjection L N M Z).continuous).measurableSet
  simpa using he.symm.trans_le h



theorem joined_holes_to_cover {m D : ℕ} (hn : 2 ≤ m+D)
    (L : Submodule ℤ (Fin m → ℝ)) [DiscreteTopology L] [IsZLattice ℝ L]
    (N : Submodule ℤ (Fin D → ℝ)) [DiscreteTopology N] [IsZLattice ℝ N]
    (M : (Fin D → ℝ) ≃ₗ[ℝ] (Fin D → ℝ)) (Z : Fin D → (Fin m → ℝ))
    (K : Set (Fin (m+D) → ℝ)) (hK : IsCompact K) (hconv : Convex ℝ K)
    (hhole : ∀ y, torusMeasure m (horizontalHole L K (joinedLattice L N M Z) y) ≤
      ENNReal.ofReal (1/((m+D : ℕ) : ℝ)^(2*(m+D)))) :
    ∃ (Λ : Submodule ℤ (Fin (m+D) → ℝ)) (_ : DiscreteTopology Λ),
      IsZLattice ℝ Λ ∧ K+(Λ : Set (Fin (m+D) → ℝ)) = Set.univ ∧
      (volume K).toReal / ZLattice.covolume Λ ≤
        Real.exp 1*((volume K).toReal /
          (ZLattice.covolume L*ZLattice.covolume (image N M))) := by
  have hh := quotient_real_hole_bound L N M Z K hK
    (1/((m+D : ℕ) : ℝ)^(2*(m+D))) (by positivity) hhole
  obtain ⟨Λ,hd,hfull,hcover,hdensity⟩ := complete_almost_cover_projection hn
    (joinedLattice L N M Z) (joinedProjection L N M Z)
    (joinedProjection_surjective L N M Z) (joinedProjection_eq_zero_iff L N M Z)
    K hK hconv hh
  exact ⟨Λ,hd,hfull,hcover,by simpa only [joined_covolume] using hdensity⟩



end SingleLatticeCovering.CoverGeometry

namespace SingleLatticeCovering.CoverGeometry
open MeasureTheory LatticeGeometry Completion Shear
open scoped BigOperators Pointwise ENNReal




theorem finite_patterns_to_cover {α : Type*} [Fintype α] {m D : ℕ} (hn : 2 ≤ m+D)
    (L : Submodule ℤ (Fin m → ℝ)) [DiscreteTopology L] [IsZLattice ℝ L]
    (N : Submodule ℤ (Fin D → ℝ)) [DiscreteTopology N] [IsZLattice ℝ N]
    (hints : ∀ k : Fin D → ℤ, (fun j => (k j : ℝ)) ∈ N)
    (M : (Fin D → ℝ) ≃ₗ[ℝ] (Fin D → ℝ))
    (K : Set (Fin (m+D) → ℝ)) (hK : IsCompact K) (hconv : Convex ℝ K)
    (J : α → Set (Fin m → ℝ)) (hJ : ∀ a, IsCompact (J a))
    (u : α → ℝ) (labels : Finset α)
    (hhole : ∀ a ∈ labels, torusMeasure m ((latticeProjection L '' J a)ᶜ) ≤
      ENNReal.ofReal (Real.exp (-u a/2)))
    (alphabet : ℕ → Finset ℝ) (Lstar A : ℝ) (hLstar : 1 ≤ Lstar)
    (hcost : ((∑ q ∈ Finset.range (D+1),
      (allPatterns alphabet labels q).card : ℕ) : ℝ) < Lstar)
    (herror : Real.exp ((2^D : ℕ)*Real.log Lstar-A/2) ≤ 1/((m+D : ℕ) : ℝ)^(2*(m+D)))
    (hpatterns : ∀ z : Fin D → ℝ, (∀ j, 0 ≤ z j ∧ z j < 1) →
      ∃ s : Finset ((Fin D → ℝ) × α), s ∈ allPatterns alphabet labels D ∧
        (∀ l ∈ s, l.1 ∈ N) ∧
        (∀ l ∈ s, ∀ j ∈ J l.2, Fin.append j (M z-M l.1) ∈ K) ∧
        A ≤ ∑ l ∈ s, u l.2) :
    ∃ (Λ : Submodule ℤ (Fin (m+D) → ℝ)) (_ : DiscreteTopology Λ),
      IsZLattice ℝ Λ ∧ K+(Λ : Set (Fin (m+D) → ℝ)) = Set.univ ∧
      (volume K).toReal / ZLattice.covolume Λ ≤
        Real.exp 1*((volume K).toReal /
          (ZLattice.covolume L*ZLattice.covolume (image N M))) := by
  obtain ⟨Z,hZ⟩ := finite_family_lattice_shear L N M K J hJ u labels hhole alphabet Lstar hLstar hcost
  apply joined_holes_to_cover hn L N M Z K hK hconv
  apply all_height_hole_bound L N hints M Z K
  intro z hz
  obtain ⟨s,hs,hraw,hsection,hload⟩ := hpatterns z hz
  exact (hZ (M z) s hs hraw hsection A hload).trans (ENNReal.ofReal_le_ofReal herror)


end SingleLatticeCovering.CoverGeometry

namespace SingleLatticeCovering.Vertical
open ConstructionA LatticeGeometry

lemma Block.integer_mem (B : Block) (k : Fin B.b → ℤ) :
    (fun j => (k j : ℝ)) ∈ B.lattice := by
  change ∃ z : Fin B.b → ℤ, residue B.p z ∈ Submodule.span (ZMod B.p) {B.direction} ∧
    (fun j => (z j : ℝ)/(B.p : ℝ)) = (fun j => (k j : ℝ))
  refine ⟨fun j => B.p*k j,?_,?_⟩
  · convert (Submodule.span (ZMod B.p) {B.direction}).zero_mem using 1
    ext j
    simp [residue]
  · ext j
    push_cast
    field_simp [B.prime.ne_zero]

namespace Chain
variable {B : Block}
lemma raw_integer_mem (c : Chain B) (k : Fin c.dim → ℤ) :
    (fun j => (k j : ℝ)) ∈ c.rawLattice := by
  induction c with
  | base B => exact B.integer_mem k
  | append c B w ih =>
    exact ⟨ih (fun j => k (Fin.castAdd B.b j)),
      B.integer_mem (fun j => k (Fin.natAdd c.dim j))⟩

lemma full_raw_integer_mem (c : Chain B) (k : Fin c.fullDim → ℤ) :
    (fun j => (k j : ℝ)) ∈ c.fullRaw :=
  ⟨c.raw_integer_mem (fun j => k (Fin.castAdd B.terminalDim j)),
    integer_mem _ (fun j => k (Fin.natAdd c.dim j))⟩

noncomputable def alphabetSeq (c : Chain B) (j : ℕ) : Finset ℝ :=
  if h : j<c.fullDim then c.alphabets ⟨j,h⟩ else ∅

@[simp] lemma alphabetSeq_fin (c : Chain B) (j : Fin c.fullDim) :
    c.alphabetSeq j.val=c.alphabets j := by
  simp [alphabetSeq,j.isLt]
end Chain
end SingleLatticeCovering.Vertical

namespace SingleLatticeCovering.Vertical
open MeasureTheory Folded LatticeGeometry Completion Shear CoverGeometry
open scoped BigOperators Pointwise ENNReal





theorem prepared_chain_to_cover {α : Type*} [Fintype α] {B : Block} (c : Chain B)
    {m : ℕ} (hn : 2 ≤ m+c.fullDim)
    (L : Submodule ℤ (Fin m → ℝ)) [DiscreteTopology L] [IsZLattice ℝ L]
    (K : Set (Fin (m+c.fullDim) → ℝ)) (hK : IsCompact K) (hconv : Convex ℝ K)
    (J : α → Set (Fin m → ℝ)) (hJ : ∀ a, IsCompact (J a)) (u : α → ℝ)
    (κ ρ csec Csec ε τ A Lstar : ℝ)
    (hρ : 0 ≤ ρ) (hc : 0 ≤ csec) (hC : 0 ≤ Csec) (hτ : 0 ≤ τ) (hA : 0 < A)
    (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))
    (hsection : ∀ v : c.FullVec, (∑ j, (v j)^2) ≤ c.radiusSq+(B.terminalDim : ℝ) →
      ∃ a : α, (∀ j ∈ J a, Fin.append j v ∈ K) ∧
        csec*ρ*(c.det*gamma v) ≤ u a ∧ u a ≤ Csec*ρ*(c.det*gamma v))
    (hhole : ∀ a, τ ≤ u a → u a ≤ Csec*ρ*ε →
      torusMeasure m ((latticeProjection L '' J a)ᶜ) ≤ ENNReal.ofReal (Real.exp (-u a/2)))
    (hload : A+(2^c.fullDim : ℕ)*τ ≤ csec*κ*ρ)
    (hLstar : 1 ≤ Lstar)
    (hcost : ((∑ q ∈ Finset.range (c.fullDim+1),
      (allPatterns c.alphabetSeq
        (Finset.univ.filter (fun a => τ ≤ u a ∧ u a ≤ Csec*ρ*ε)) q).card : ℕ) : ℝ) < Lstar)
    (herror : Real.exp ((2^c.fullDim : ℕ)*Real.log Lstar-A/2) ≤
      1/((m+c.fullDim : ℕ) : ℝ)^(2*(m+c.fullDim))) :
    ∃ (Λ : Submodule ℤ (Fin (m+c.fullDim) → ℝ)) (_ : DiscreteTopology Λ),
      IsZLattice ℝ Λ ∧ K+(Λ : Set (Fin (m+c.fullDim) → ℝ)) = Set.univ ∧
      (volume K).toReal / ZLattice.covolume Λ ≤
        Real.exp 1*((volume K).toReal /(ZLattice.covolume L*c.det)) := by
  classical
  let labels := Finset.univ.filter (fun a => τ ≤ u a ∧ u a ≤ Csec*ρ*ε)
  have hs : ∀ a ∈ labels, torusMeasure m ((latticeProjection L '' J a)ᶜ) ≤
      ENNReal.ofReal (Real.exp (-u a/2)) := by
    intro a ha
    exact hhole a (Finset.mem_filter.mp ha).2.1 (Finset.mem_filter.mp ha).2.2
  obtain ⟨Λ,hd,hfull,hcover,hdens⟩ := finite_patterns_to_cover hn L c.fullRaw
    c.full_raw_integer_mem c.fullLinear K hK hconv J hJ u labels hs
    c.alphabetSeq Lstar A hLstar hcost herror (by
      intro z hz
      obtain ⟨P,hPn,hPb,hPl,hPw⟩ := hpat (c.fullLinear z)
      exact section_labeled_retained P hPn hPb c.fullRaw (fun l hl => (hPl l hl).1)
        c.fullLinear (c.fullLinear z) K J u (fun l => c.det*gamma (c.fullLinear z-c.fullLinear l))
        κ ρ csec Csec ε τ A hρ hc hC hτ hA hPw (fun l hl => (hPl l hl).2.2)
        (fun l hl => hsection _ (c.full_residual_square _ _ (hPl l hl).2.1))
        hload c.alphabetSeq (by
          intro l hl j
          rw [Chain.alphabetSeq_fin]
          exact c.mem_alphabets z l hz (hPl l hl).2.1 (hPl l hl).1 j))
  refine ⟨Λ,hd,hfull,hcover,?_⟩
  change (volume K).toReal / ZLattice.covolume Λ ≤
    Real.exp 1*((volume K).toReal /(ZLattice.covolume L*ZLattice.covolume c.fullLattice)) at hdens
  simpa only [c.full_covolume] using hdens


end SingleLatticeCovering.Vertical

end
end

section

noncomputable section
namespace SingleLatticeCovering.Vertical
open MeasureTheory Folded LatticeGeometry Completion Shear CoverGeometry
open scoped BigOperators Pointwise ENNReal

lemma Chain.det_pos {B : Block} (c : Chain B) : 0 < c.det := by
  rw [←c.full_covolume]
  exact ZLattice.covolume_pos c.fullLattice




theorem labeled_chain_to_cover {α : Type*} [Fintype α] {B : Block} (c : Chain B)
    {m : ℕ} (hn : 2 ≤ m+c.fullDim)
    (L : Submodule ℤ (Fin m → ℝ)) [DiscreteTopology L] [IsZLattice ℝ L]
    (K : Set (Fin (m+c.fullDim) → ℝ)) (hK : IsCompact K) (hconv : Convex ℝ K)
    (hV : 0 < (volume K).toReal)
    (J : α → Set (Fin m → ℝ)) (hJ : ∀ a, IsCompact (J a))
    (κ ρ csec Csec ε τ A Lstar : ℝ)
    (hρ : 0 < ρ) (hc : 0 ≤ csec) (hC : 0 ≤ Csec) (hτ : 0 ≤ τ) (hA : 0 < A)
    (hcov : ZLattice.covolume L volume=(volume K).toReal/(ρ*c.det))
    (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))
    (hsection : ∀ v : c.FullVec, (∑ j, (v j)^2) ≤ c.radiusSq+(B.terminalDim : ℝ) →
      ∃ a : α, (∀ j ∈ J a, Fin.append j v ∈ K) ∧
        csec*(volume K).toReal*gamma v ≤ (volume (J a)).toReal ∧
        (volume (J a)).toReal ≤ Csec*(volume K).toReal*gamma v)
    (hhole : ∀ a, τ ≤ (volume (J a)).toReal/ZLattice.covolume L volume →
      (volume (J a)).toReal/ZLattice.covolume L volume ≤ Csec*ρ*ε →
      torusMeasure m ((latticeProjection L '' J a)ᶜ) ≤
        ENNReal.ofReal (Real.exp (-((volume (J a)).toReal/ZLattice.covolume L volume)/2)))
    (hload : A+(2^c.fullDim : ℕ)*τ ≤ csec*κ*ρ)
    (hLstar : 1 ≤ Lstar)
    (hcost : ((∑ q ∈ Finset.range (c.fullDim+1),
      (allPatterns c.alphabetSeq
        (Finset.univ.filter (fun a => τ ≤ (volume (J a)).toReal/ZLattice.covolume L volume ∧
          (volume (J a)).toReal/ZLattice.covolume L volume ≤ Csec*ρ*ε)) q).card : ℕ) : ℝ) < Lstar)
    (herror : Real.exp ((2^c.fullDim : ℕ)*Real.log Lstar-A/2) ≤
      1/((m+c.fullDim : ℕ) : ℝ)^(2*(m+c.fullDim))) :
    ∃ (Λ : 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
  have _ := hV
  have hL : 0 < ZLattice.covolume L volume := ZLattice.covolume_pos L
  have hVeq : (volume K).toReal=ZLattice.covolume L volume*(ρ*c.det) := by
    rw [hcov]; exact (div_mul_cancel₀ _ (mul_pos hρ c.det_pos).ne').symm
  have hratio (a g : ℝ) : (a*(volume K).toReal*g)/ZLattice.covolume L volume=a*ρ*(c.det*g) := by
    rw [hVeq]
    field_simp [hL.ne']
  obtain ⟨Λ,hd,hfull,hcover,hbound⟩ := prepared_chain_to_cover c hn L K hK hconv J hJ
    (fun a => (volume (J a)).toReal/ZLattice.covolume L volume) κ ρ csec Csec ε τ A Lstar
    hρ.le hc hC hτ hA hpat (by
      intro v hv
      obtain ⟨a,ha,hl,hu⟩ := hsection v hv
      refine ⟨a,ha,?_,?_⟩
      · rw [←hratio csec (gamma v)]
        exact div_le_div_of_nonneg_right hl hL.le
      · rw [←hratio Csec (gamma v)]
        exact div_le_div_of_nonneg_right hu hL.le) hhole hload hLstar hcost herror
  refine ⟨Λ,hd,hfull,hcover,?_⟩
  have heq : (volume K).toReal/(ZLattice.covolume L volume*c.det)=ρ := by
    rw [hVeq]
    field_simp [hL.ne',c.det_pos.ne']
  simpa only [heq] using hbound


end SingleLatticeCovering.Vertical

end
end

section

namespace SingleLatticeCovering.LatticeGeometry
open MeasureTheory
open scoped Pointwise

lemma affine_image_volume {n : ℕ} (e : (Fin n → ℝ) ≃ₗ[ℝ] (Fin n → ℝ))
    (t : Fin n → ℝ) (K : Set (Fin n → ℝ)) :
    volume ((fun x => e x+t) '' K) = ENNReal.ofReal |LinearMap.det e.toLinearMap| * volume K := by
  have hs : (fun x => e x+t) '' K = (fun x => x+t) '' (e '' K) := by
    rw [Set.image_image]
  rw [hs,Set.image_add_right,measure_preimage_add_right]
  exact volume.addHaar_image_linearMap e.toLinearMap K

lemma affine_image_cover {n : ℕ} (L : Submodule ℤ (Fin n → ℝ))
    (e : (Fin n → ℝ) ≃ₗ[ℝ] (Fin n → ℝ)) (t : Fin n → ℝ)
    (K : Set (Fin n → ℝ)) (hcover : K+(L : Set (Fin n → ℝ))=Set.univ) :
    (fun x => e x+t) '' K+(image L e : Set (Fin n → ℝ))=Set.univ := by
  apply Set.eq_univ_of_forall
  intro x
  have hx : e.symm (x-t) ∈ K+(L : Set (Fin n → ℝ)) := by rw [hcover]; trivial
  obtain ⟨k,hk,l,hl,hkl⟩ := hx
  refine ⟨e k+t,⟨k,hk,rfl⟩,e l,(mem_image L e (e l)).mpr ⟨l,hl,rfl⟩,?_⟩
  change e k+t+e l=x
  have he : e k+e l=x-t := by
    rw [←map_add]
    change k+l=e.symm (x-t) at hkl
    rw [hkl,e.apply_symm_apply]
  calc e k+t+e l = (e k+e l)+t := by abel
       _ = x := by rw [he]; abel

lemma affine_image_density {n : ℕ} (L : Submodule ℤ (Fin n → ℝ))
    [DiscreteTopology L] [IsZLattice ℝ L]
    (e : (Fin n → ℝ) ≃ₗ[ℝ] (Fin n → ℝ)) (t : Fin n → ℝ)
    (K : Set (Fin n → ℝ)) :
    (volume ((fun x => e x+t) '' K)).toReal / ZLattice.covolume (image L e) =
      (volume K).toReal / ZLattice.covolume L := by
  rw [affine_image_volume,ENNReal.toReal_mul,ENNReal.toReal_ofReal (abs_nonneg _),image_covolume]
  exact mul_div_mul_left _ _ (abs_ne_zero.mpr e.isUnit_det'.ne_zero)


end SingleLatticeCovering.LatticeGeometry

noncomputable section
namespace SingleLatticeCovering.LatticeGeometry
open MeasureTheory
open scoped Pointwise

lemma affineEquiv_eq_linear_add {n : ℕ}
    (e : (Fin n → ℝ) ≃ᵃ[ℝ] (Fin n → ℝ)) (x : Fin n → ℝ) : e x=e.linear x+e 0 := by
  have h := e.map_vadd (0 : Fin n → ℝ) x
  simpa using h



lemma pull_back_cover {n : ℕ} (e : (Fin n → ℝ) ≃ᵃ[ℝ] (Fin n → ℝ))
    (K : Set (Fin n → ℝ)) (L : Submodule ℤ (Fin n → ℝ))
    [DiscreteTopology L] [IsZLattice ℝ L]
    (hcover : e '' K+(L : Set (Fin n → ℝ))=Set.univ) {d : ℝ}
    (hd : (volume (e '' K)).toReal/ZLattice.covolume L ≤ d) :
    ∃ (Λ : Submodule ℤ (Fin n → ℝ)) (_ : DiscreteTopology Λ), IsZLattice ℝ Λ ∧
      K+(Λ : Set (Fin n → ℝ))=Set.univ ∧ (volume K).toReal/ZLattice.covolume Λ ≤ d := by
  let Λ := image L e.symm.linear
  have he : (fun x => e.symm.linear x+e.symm 0) '' (e '' K)=K := by
    simp_rw [←affineEquiv_eq_linear_add]
    exact e.symm_image_image K
  refine ⟨Λ,inferInstance,inferInstance,?_,?_⟩
  · have h := affine_image_cover L e.symm.linear (e.symm 0) (e '' K) hcover
    rwa [he] at h
  · have h := affine_image_density L e.symm.linear (e.symm 0) (e '' K)
    rw [he] at h
    exact h.trans_le hd


end SingleLatticeCovering.LatticeGeometry

end
end

section


noncomputable section
open Set Metric MeasureTheory MeasureTheory.Measure Module
open scoped ENNReal NNReal BigOperators
namespace SingleLatticeCovering.Sections

lemma compact_separated_cover {E : Type*} [PseudoMetricSpace E]
    (K : Set E) (hK : IsCompact K) {δ : ℝ≥0} (hδ : 0 < δ) :
    ∃ S : Finset E, (↑S : Set E) ⊆ K ∧
      Metric.IsSeparated δ (↑S : Set E) ∧ Metric.IsCover δ K (↑S : Set E) := by
  classical
  obtain ⟨U,hUK,hUf,hUC⟩ := Metric.exists_finite_isCover_of_isCompact
    (ε := δ/2) (by positivity) hK
  have hfin : Metric.packingNumber δ K ≠ ⊤ := by
    have hh := Metric.packingNumber_two_mul_le_externalCoveringNumber (δ/2) K
    rw [mul_div_cancel₀ _ (by norm_num : (2 : ℝ≥0) ≠ 0)] at hh
    exact ne_top_of_le_ne_top (Set.encard_ne_top_iff.mpr hUf) (hh.trans hUC.externalCoveringNumber_le_encard)
  have hSf' : (Metric.maximalSeparatedSet δ K).Finite :=
    Set.encard_ne_top_iff.mp (by rw [Metric.encard_maximalSeparatedSet hfin]; exact hfin)
  exact ⟨hSf'.toFinset,by simpa using (Metric.maximalSeparatedSet_subset (ε := δ) (A := K)),
    by simpa using (Metric.isSeparated_maximalSeparatedSet (ε := δ) (A := K)),
    by simpa using Metric.isCover_maximalSeparatedSet hfin⟩



lemma separated_card_bound {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
    (μ : Measure E) [IsAddHaarMeasure μ]
    (S : Finset E) {R δ : ℝ} (hR : 0 ≤ R) (hδ : 0 < δ)
    (hS : ∀ x ∈ S, ‖x‖ ≤ R)
    (hsep : ∀ x ∈ S, ∀ y ∈ S, x ≠ y → δ < dist x y) :
    (S.card : ℝ) ≤ (1+2*R/δ)^(finrank ℝ E) := by
  classical
  have hd : 0 < δ/2 := half_pos hδ
  have hdis : (↑S : Set E).PairwiseDisjoint (fun x => Metric.ball x (δ/2)) := by
    intro x hx y hy hxy
    apply Set.disjoint_left.mpr
    intro z hzx hzy
    have hxz : dist x z < δ/2 := by simpa only [Metric.mem_ball,dist_comm] using hzx
    have hzy' : dist z y < δ/2 := hzy
    have hh := dist_triangle x z y
    have hxy' := hsep x hx y hy hxy
    linarith
  have hsub : (⋃ x ∈ (↑S : Set E), Metric.ball x (δ/2)) ⊆ Metric.ball (0 : E) (R+δ/2) := by
    intro z hz
    obtain ⟨x,hx,hzx⟩ := Set.mem_iUnion₂.mp hz
    rw [Metric.mem_ball,dist_zero_right]
    have hdist : dist z x < δ/2 := hzx
    have hh := norm_add_le (z-x) x
    rw [sub_add_cancel,←dist_eq_norm] at hh
    linarith [hS x hx]
  have hμ := measure_mono (μ := μ) hsub
  simp only [Finset.mem_coe] at hμ
  rw [measure_biUnion_finset hdis (fun x hx => Metric.isOpen_ball.measurableSet)] at hμ
  simp_rw [μ.addHaar_ball_of_pos _ hd] at hμ
  rw [Finset.sum_const, nsmul_eq_mul,
    μ.addHaar_ball_of_pos _ (by linarith : 0 < R+δ/2)] at hμ
  have hunit0 : μ (Metric.ball (0 : E) 1) ≠ 0 :=
    Metric.isOpen_ball.measure_ne_zero μ ⟨0, by simp⟩
  have hunitTop : μ (Metric.ball (0 : E) 1) ≠ ∞ :=
    measure_ball_ne_top
  have hreal : (S.card : ℝ)*(δ/2)^finrank ℝ E ≤ (R+δ/2)^finrank ℝ E := by
    have hh := (ENNReal.mul_le_mul_iff_left hunit0 hunitTop).mp (by simpa only [←mul_assoc] using hμ)
    have hs : (S.card : ℝ≥0∞)*ENNReal.ofReal ((δ/2)^finrank ℝ E) =
        ENNReal.ofReal ((S.card : ℝ)*(δ/2)^finrank ℝ E) := by rw [ENNReal.ofReal_mul (Nat.cast_nonneg _)]; simp
    rw [hs] at hh
    exact (ENNReal.ofReal_le_ofReal_iff (by positivity)).mp hh
  have he : (1+2*R/δ)^finrank ℝ E = (R+δ/2)^finrank ℝ E/(δ/2)^finrank ℝ E := by
    rw [←div_pow]; congr 1; field_simp; ring
  rw [he]
  exact (le_div_iff₀ (pow_pos hd _)).mpr hreal


lemma ball_finite_net {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
    (μ : Measure E) [IsAddHaarMeasure μ] {R : ℝ} (hR : 0 < R)
    {m : ℕ} (hm : 1 ≤ m) :
    ∃ S : Finset E, (S.card : ℝ) ≤ (3*(m : ℝ)^2)^(finrank ℝ E) ∧
      (∀ a ∈ S, ‖a‖ ≤ R) ∧
      ∀ y : E, ‖y‖ ≤ R → ∃ a ∈ S, dist y a ≤ R/(m : ℝ)^2 := by
  classical
  have hm0 : (0 : ℝ) < m := by exact_mod_cast hm
  have hd : 0 < R/(m : ℝ)^2 := div_pos hR (pow_pos hm0 2)
  let δ : ℝ≥0 := ⟨R/(m : ℝ)^2,hd.le⟩
  obtain ⟨S,hS,hsep,hcover⟩ := compact_separated_cover (Metric.closedBall (0 : E) R)
    (isCompact_closedBall _ _) (show 0 < δ from hd)
  have hSn : ∀ a ∈ S, ‖a‖ ≤ R := by
    intro a ha
    simpa only [Metric.mem_closedBall,dist_zero_right] using hS ha
  have hsep' : ∀ x ∈ S, ∀ y ∈ S, x ≠ y → R/(m : ℝ)^2 < dist x y := by
    intro x hx y hy hxy
    have hh := ENNReal.toReal_strict_mono (edist_ne_top x y) (hsep hx hy hxy)
    rw [ENNReal.coe_toReal,edist_dist,ENNReal.toReal_ofReal dist_nonneg] at hh
    exact hh
  have hcard := separated_card_bound μ S hR.le hd hSn hsep'
  have hm1 : (1 : ℝ) ≤ m := by exact_mod_cast hm
  have hratio : 1+2*R/(R/(m : ℝ)^2) ≤ 3*(m : ℝ)^2 := by
    have he : 2*R/(R/(m : ℝ)^2)=2*(m : ℝ)^2 := by field_simp
    rw [he]; nlinarith
  refine ⟨S,hcard.trans (pow_le_pow_left₀ (by positivity) hratio _),hSn,?_⟩
  intro y hy
  obtain ⟨a,ha,hya⟩ := hcover (show y ∈ Metric.closedBall (0 : E) R by simpa using hy)
  refine ⟨a,ha,?_⟩
  have hh := ENNReal.toReal_mono ENNReal.coe_ne_top hya
  rw [ENNReal.coe_toReal,edist_dist,ENNReal.toReal_ofReal dist_nonneg] at hh
  exact hh




end SingleLatticeCovering.Sections




noncomputable section
open Set Metric MeasureTheory MeasureTheory.Measure Module
open scoped Pointwise ENNReal NNReal BigOperators
namespace SingleLatticeCovering.Sections

variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]

def fiber (K : Set (E × F)) (y : F) : Set E := {x | (x,y) ∈ K}

lemma fiber_compact {E : Type*} {F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F] {K : Set (E × F)} (hK : IsCompact K) (y : F) :
    IsCompact (fiber K y) := by
  have he : fiber K y = Prod.fst '' (K ∩ Prod.snd ⁻¹' {y}) := by
    ext x; constructor
    · intro hx; exact ⟨(x,y),⟨hx,by simp⟩,rfl⟩
    · rintro ⟨⟨x',y'⟩,⟨hxy,hy⟩,hx⟩
      have hy' : y'=y := hy
      change x'=x at hx
      subst x'; subst y'; exact hxy
  rw [he]
  exact (hK.inter_right (isClosed_singleton.preimage continuous_snd)).image continuous_fst

lemma fiber_convex {K : Set (E × F)} (hK : Convex ℝ K) (y : F) :
    Convex ℝ (fiber K y) := by
  intro x hx z hz a b ha hb hab
  have hh := hK hx hz ha hb hab
  simpa only [fiber, Set.mem_ofPred_eq, Prod.smul_mk, Prod.mk_add_mk,
    ←add_smul,hab,one_smul] using hh



lemma nearby_fiber_inclusion {K : Set (E × F)} (hK : Convex ℝ K)
    {R : ℝ} (hR : 0 ≤ R) {m : ℕ} (hm : 1 ≤ m)
    (hcenter : ∀ z : F, ‖z‖ ≤ 2*R → (0,z) ∈ K)
    {a y : F} (ha : ‖a‖ ≤ R) (hya : dist y a ≤ R/(m : ℝ)^2) :
    (1-(m : ℝ)^(-2 : ℤ)) • fiber K a ⊆ fiber K y := by
  have _ := hR
  have hm1 : (1 : ℝ) ≤ m := by exact_mod_cast hm
  have hm0 : (0 : ℝ) < m := lt_of_lt_of_le zero_lt_one hm1
  let z := a+(m : ℝ)^2 • (y-a)
  have hz : ‖z‖ ≤ 2*R := by
    calc
      _ ≤ ‖a‖+‖(m : ℝ)^2 • (y-a)‖ := norm_add_le _ _
      _ = ‖a‖+(m : ℝ)^2*dist y a := by rw [norm_smul, Real.norm_of_nonneg (sq_nonneg _),dist_eq_norm]
      _ ≤ R+(m : ℝ)^2*(R/(m : ℝ)^2) := add_le_add ha (mul_le_mul_of_nonneg_left hya (sq_nonneg _))
      _ = 2*R := by field_simp; ring
  have ht : 0 ≤ 1-(m : ℝ)^(-2 : ℤ) := by
    norm_num only [zpow_neg, zpow_ofNat]
    have hh : 1 ≤ (m : ℝ)^2 := one_le_pow₀ hm1
    exact sub_nonneg.mpr ((inv_le_one₀ (pow_pos hm0 _)).mpr hh)
  intro v hv
  obtain ⟨x,hx,rfl⟩ := hv
  have hh := hK hx (hcenter z hz) ht (by positivity : 0 ≤ (m : ℝ)^(-2 : ℤ)) (by ring)
  have he : (1-(m : ℝ)^(-2 : ℤ)) • a+(m : ℝ)^(-2 : ℤ) • z=y := by
    dsimp [z]; rw [smul_add,smul_smul]
    norm_num only [zpow_neg, zpow_ofNat]
    rw [inv_mul_cancel₀ (pow_ne_zero 2 hm0.ne'),one_smul]
    module
  simpa only [fiber,Set.mem_ofPred_eq,Prod.smul_mk,Prod.mk_add_mk,smul_zero,add_zero,he] using hh

lemma shrink_power_half {m : ℕ} (hm : 2 ≤ m) :
    (1-(m : ℝ)^(-2 : ℤ))^m ≥ (1/2 : ℝ) := by
  have hm2 : (2 : ℝ) ≤ m := by exact_mod_cast hm
  have hp : 0 < (m : ℝ)^2 := by positivity
  have hinv : (m : ℝ)^(-2 : ℤ)=((m : ℝ)^2)⁻¹ := by norm_num [zpow_neg]
  rw [hinv]
  have hi : ((m : ℝ)^2)⁻¹ ≤ 1 := (inv_le_one₀ hp).mpr (by nlinarith)
  have hh := one_add_mul_le_pow (show -2 ≤ -((m : ℝ)^2)⁻¹ by linarith) m
  have he : (m : ℝ)*((m : ℝ)^2)⁻¹=(m : ℝ)⁻¹ := by field_simp
  have hi2 : (m : ℝ)⁻¹ ≤ 1/2 := by simpa only [one_div] using one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 2) hm2
  simp only [mul_neg,he,←sub_eq_add_neg] at hh
  linarith



lemma prescribed_volume [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
    (μ : Measure E) [IsAddHaarMeasure μ] (hn : 0 < finrank ℝ E)
    {A : Set E} (hA : IsCompact A) (hconv : Convex ℝ A) (hzero : (0 : E) ∈ A)
    {v : ℝ} (hv : 0 < v) (hvol : v ≤ (μ A).toReal) :
    ∃ J : Set E, IsCompact J ∧ Convex ℝ J ∧ (0 : E) ∈ J ∧ J ⊆ A ∧ (μ J).toReal=v := by
  have hμ : 0 < (μ A).toReal := hv.trans_le hvol
  let t : ℝ := (v/(μ A).toReal)^((finrank ℝ E : ℝ)⁻¹)
  have ht : 0 < t := Real.rpow_pos_of_pos (div_pos hv hμ) _
  have ht1 : t ≤ 1 := Real.rpow_le_one (by positivity) ((div_le_one hμ).mpr hvol) (by positivity)
  refine ⟨t • A, hA.smul t, hconv.smul t,?_,?_,?_⟩
  · exact ⟨0,hzero,smul_zero _⟩
  · rintro x ⟨a,ha,rfl⟩
    exact hconv.smul_mem_of_zero_mem hzero ha ⟨ht.le,ht1⟩
  · rw [μ.addHaar_smul_of_nonneg ht.le, ENNReal.toReal_mul,
      ENNReal.toReal_ofReal (pow_nonneg ht.le _)]
    have he : t^finrank ℝ E=v/(μ A).toReal :=
      Real.rpow_inv_natCast_pow (div_pos hv hμ).le hn.ne'
    rw [he,div_mul_cancel₀ _ hμ.ne']




end SingleLatticeCovering.Sections





noncomputable section

end
end
end
end
end

end OAI