lean/OAI/Geometry/LatticeCovering/Concentration.lean

import OAI.Geometry.LatticeCovering.Folded

namespace OAI

section
section
noncomputable section
open scoped BigOperators
open Real
noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Set

namespace SingleLatticeCovering.Folded
open MeasureTheory ProbabilityTheory Set Real

lemma law_real_of_subset {h : ℝ} (hh : 0 < h) {s : Set ℝ}
    (hs : MeasurableSet s) (hsub : s ⊆ Icc (0 : ℝ) 1) :
    (law h).real s = (∫ t in s, density h t)/totalMass h := by
  calc
    _ = ∫ _ in s, (1 : ℝ) ∂law h := by simp
    _ = ∫ t in s, density h t/totalMass h ∂volume.restrict (Icc (0 : ℝ) 1) := by
      unfold law
      rw [setIntegral_withDensity_eq_setIntegral_toReal_smul (measurable_weight h)
        (Filter.Eventually.of_forall (fun _ => ENNReal.ofReal_lt_top)) (fun _ => (1 : ℝ)) hs]
      simp only [ENNReal.toReal_ofReal (div_nonneg (density_pos hh _).le (totalMass_pos hh).le),
        smul_eq_mul, mul_one]
    _ = _ := by rw [Measure.restrict_restrict hs, inter_eq_left.mpr hsub, integral_div]


def centralInterval (h : ℝ) : Set ℝ := Icc (1/2-1/(2*h^2)) (1/2+1/(2*h^2))

lemma centralInterval_subset {h : ℝ} (hh : 1 ≤ h) : centralInterval h ⊆ Icc (0 : ℝ) 1 := by
  have hh2 : 1 ≤ h^2 := by nlinarith
  have hw : 1/(2*h^2) ≤ (1/2 : ℝ) := (div_le_div_iff₀ (by positivity) (by norm_num)).mpr (by nlinarith)
  intro t ht
  rcases ht with ⟨hl,hu⟩
  constructor <;> linarith

lemma centralInterval_volume {h : ℝ} (hh : 0 < h) :
    volume.real (centralInterval h) = 1/h^2 := by
  unfold centralInterval
  rw [Real.volume_real_Icc]
  have hz : 0 ≤ (1/2+1/(2*h^2))-(1/2-1/(2*h^2)) := by
    have : 0 ≤ 1/(2*h^2) := by positivity
    linarith
  rw [max_eq_left hz]
  ring

lemma centralInterval_probability {h : ℝ} (hh : 1 ≤ h) :
    Real.exp (-(h^2)/8)/(h*Real.sqrt (2*Real.pi)) ≤ (law h).real (centralInterval h) := by
  have hp : 0 < h := by linarith
  have hs : 0 < Real.sqrt (2*Real.pi) := Real.sqrt_pos.mpr (mul_pos (by norm_num) Real.pi_pos)
  have hmin : h/Real.sqrt (2*Real.pi)*Real.exp (-(h^2)/8) * volume.real (centralInterval h) ≤
      ∫ t in centralInterval h, density h t := by
    calc
      _ = ∫ _ in centralInterval h, h/Real.sqrt (2*Real.pi)*Real.exp (-(h^2)/8) := by simp [mul_comm]
      _ ≤ _ := by
        apply setIntegral_mono_on (integrableOn_const (s := centralInterval h) (hs := isCompact_Icc.measure_ne_top))
          (continuous_density h).integrableOn_Icc measurableSet_Icc
        intro t ht
        exact density_lower hp (centralInterval_subset hh ht)
  rw [centralInterval_volume hp] at hmin
  have he : h/Real.sqrt (2*Real.pi)*Real.exp (-(h^2)/8)*(1/h^2) =
      Real.exp (-(h^2)/8)/(h*Real.sqrt (2*Real.pi)) := by field_simp
  rw [he] at hmin
  rw [law_real_of_subset (s := centralInterval h) hp measurableSet_Icc (centralInterval_subset hh)]
  exact hmin.trans ((le_div_iff₀ (totalMass_pos hp)).mpr
    (mul_le_of_le_one_right (le_trans (by positivity) hmin) (totalMass_le_one hp)))

variable {ι : Type*} [Fintype ι]

def cubeLaw (h : ℝ) : Measure (ι → ℝ) := Measure.pi (fun _ : ι => law h)

lemma log_folded {h : ℝ} (hh : 0 < h) (t : ι → ℝ) :
    Real.log (folded h t) = ∑ i, Real.log (density h (t i)) := by
  exact Real.log_prod (fun i _ => (density_pos hh (t i)).ne')

lemma folded_chebyshev {h c : ℝ} (hh : 0 < h) (hc : 0 < c) :
    (cubeLaw h : Measure (ι → ℝ)).real
      {t | c ≤ |Real.log (folded h t)-(Fintype.card ι : ℝ)*logMean h|} ≤
      (Fintype.card ι : ℝ)*((Real.log 2+h^2/8)/2)^2/c^2 := by
  let := law_isProbability hh
  have ht := Concentration.sum_chebyshev (ι := ι) (log_density_memLp hh)
    (log_density_variance hh) hc
  simp only [integral_log_density hh] at ht
  simpa only [cubeLaw, log_folded hh] using ht

lemma central_count_tail {h : ℝ} (hh : 1 ≤ h) (hi : 0 < Fintype.card ι)
    {r : ℝ} (hr : 2*r ≤ (Fintype.card ι : ℝ)*Real.exp (-(h^2)/8)/(h*Real.sqrt (2*Real.pi))) :
    (cubeLaw h : Measure (ι → ℝ)).real
      {t | (∑ i, (centralInterval h).indicator (fun _ => (1 : ℝ)) (t i)) < r} ≤
      4/((Fintype.card ι : ℝ)*Real.exp (-(h^2)/8)/(h*Real.sqrt (2*Real.pi))) := by
  have hp : 0 < h := by linarith
  let := law_isProbability hp
  have hl := mul_le_mul_of_nonneg_left (centralInterval_probability hh) (Nat.cast_nonneg (Fintype.card ι) : (0 : ℝ) ≤ _)
  rw [←mul_div_assoc] at hl
  have hx : 0 < (Fintype.card ι : ℝ)*Real.exp (-(h^2)/8)/(h*Real.sqrt (2*Real.pi)) := by positivity
  have ht := Concentration.count_lower_tail (ι := ι) (μ := law h) (s := centralInterval h) measurableSet_Icc (lt_of_lt_of_le hx hl)
  apply (measureReal_mono (show {t : ι → ℝ | (∑ i, (centralInterval h).indicator (fun _ => (1 : ℝ)) (t i)) < r} ⊆ _ from ?_)).trans
    (ht.trans (div_le_div_of_nonneg_left (by norm_num) hx hl))
  intro t ht
  dsimp at ht ⊢
  linarith




end SingleLatticeCovering.Folded
noncomputable section
open scoped BigOperators
open MeasureTheory Set
namespace SingleLatticeCovering
variable {ι : Type*} [Fintype ι] {Ω : ι → Type*}
    [∀ i, MeasurableSpace (Ω i)] {μ : ∀ i, Measure (Ω i)} [∀ i, SigmaFinite (μ i)]

lemma pi_withDensity_ofReal {f : ∀ i, Ω i → ℝ}
    (hf : ∀ i, Integrable (f i) (μ i)) (hpos : ∀ i x, 0 ≤ f i x) :
    Measure.pi (fun i => (μ i).withDensity (fun x => ENNReal.ofReal (f i x))) =
      (Measure.pi μ).withDensity (fun x => ENNReal.ofReal (∏ i, f i (x i))) := by
  apply Measure.pi_eq
  intro s hs
  rw [withDensity_apply _ (MeasurableSet.univ_pi hs), Measure.restrict_pi_pi]
  rw [←ofReal_integral_eq_lintegral_ofReal
    (Integrable.fintype_prod_dep (fun i => (hf i).restrict))
    (Filter.Eventually.of_forall (fun x => Finset.prod_nonneg (fun i _ => hpos i (x i))))]
  rw [integral_fintype_prod_eq_prod]
  rw [ENNReal.ofReal_prod_of_nonneg (fun i _ => integral_nonneg (hpos i))]
  apply Finset.prod_congr rfl
  intro i hi
  rw [withDensity_apply _ (hs i)]
  exact ofReal_integral_eq_lintegral_ofReal (hf i).restrict (Filter.Eventually.of_forall (hpos i))


end SingleLatticeCovering

namespace SingleLatticeCovering.Folded
open MeasureTheory ProbabilityTheory Set Real
variable {ι : Type*} [Fintype ι]

def cube : Set (ι → ℝ) := Set.univ.pi (fun _ => Set.Icc (0 : ℝ) 1)

lemma continuous_folded (h : ℝ) : Continuous (folded h : (ι → ℝ) → ℝ) := by
  unfold folded
  exact continuous_finsetProd _ (fun i _ => (continuous_density h).comp (continuous_apply i))

lemma cubeLaw_density {h : ℝ} (hh : 0 < h) :
    (cubeLaw h : Measure (ι → ℝ)) =
      (volume.restrict cube).withDensity
        (fun t => ENNReal.ofReal (folded h t/(totalMass h)^Fintype.card ι)) := by
  have hf : Integrable (fun x => density h x/totalMass h) (volume.restrict (Icc (0 : ℝ) 1)) :=
    ((continuous_density h).div_const _).integrableOn_Icc
  have ht := pi_withDensity_ofReal (μ := fun _ : ι => volume.restrict (Icc (0 : ℝ) 1))
    (f := fun _ : ι => fun x => density h x/totalMass h) (fun _ => hf)
    (fun _ x => div_nonneg (density_pos hh x).le (totalMass_pos hh).le)
  simpa only [cubeLaw, law, ←Measure.restrict_pi_pi, volume_pi, cube,
    Finset.prod_div_distrib, Finset.prod_const, Finset.card_univ, folded] using ht

lemma cube_integral {h : ℝ} (_ : 0 < h) :
    (∫ t in (cube : Set (ι → ℝ)), folded h t) = (totalMass h)^Fintype.card ι := by
  rw [cube, volume_pi, Measure.restrict_pi_pi]
  unfold folded
  rw [integral_fintype_prod_eq_pow, integral_Icc_eq_integral_Ioc,
    ←intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1)]
  rfl

lemma cubeLaw_real {h : ℝ} (hh : 0 < h) {s : Set (ι → ℝ)} (hs : MeasurableSet s) :
    (cubeLaw h).real s = (∫ t in s ∩ cube, folded h t)/(totalMass h)^Fintype.card ι := by
  calc
    _ = ∫ _ in s, (1 : ℝ) ∂cubeLaw h := by simp
    _ = ∫ t in s, folded h t/(totalMass h)^Fintype.card ι ∂volume.restrict cube := by
      rw [cubeLaw_density hh, setIntegral_withDensity_eq_setIntegral_toReal_smul
        (((continuous_folded h).div_const _).measurable.ennreal_ofReal)
        (Filter.Eventually.of_forall (fun _ => ENNReal.ofReal_lt_top)) (fun _ => (1 : ℝ)) hs]
      simp only [ENNReal.toReal_ofReal (div_nonneg (folded_pos hh _).le (pow_nonneg (totalMass_pos hh).le _)),
        smul_eq_mul, mul_one]
    _ = _ := by rw [Measure.restrict_restrict hs, integral_div]

lemma cubeLaw_isProbability {h : ℝ} (hh : 0 < h) : IsProbabilityMeasure (cubeLaw h : Measure (ι → ℝ)) := by
  let := law_isProbability hh
  change IsProbabilityMeasure (Measure.pi (fun _ : ι => law h))
  infer_instance


lemma continuous_good_mass {h c r : ℝ} (hh : 1 ≤ h) (hi : 0 < Fintype.card ι) (hc : 0 < c)
    (hr : 2*r ≤ (Fintype.card ι : ℝ)*Real.exp (-(h^2)/8)/(h*Real.sqrt (2*Real.pi))) :
    1 - (Fintype.card ι : ℝ)*((Real.log 2+h^2/8)/2)^2/c^2 -
      4/((Fintype.card ι : ℝ)*Real.exp (-(h^2)/8)/(h*Real.sqrt (2*Real.pi))) ≤
    (cubeLaw h : Measure (ι → ℝ)).real
      {t | |Real.log (folded h t)-(Fintype.card ι : ℝ)*logMean h| < c ∧
        r ≤ ∑ i, (centralInterval h).indicator (fun _ => (1 : ℝ)) (t i)} := by
  have hp : 0 < h := by linarith
  let := cubeLaw_isProbability (ι := ι) hp
  let A : Set (ι → ℝ) := {t | c ≤ |Real.log (folded h t)-(Fintype.card ι : ℝ)*logMean h|}
  let B : Set (ι → ℝ) := {t | (∑ i, (centralInterval h).indicator (fun _ => (1 : ℝ)) (t i)) < r}
  have hA : MeasurableSet A := by
    apply measurableSet_le measurable_const
    exact (((continuous_folded h).log (fun t => (folded_pos hp t).ne')).sub continuous_const).abs.measurable
  have hB : MeasurableSet B := by
    apply measurableSet_lt _ measurable_const
    exact Finset.measurable_sum _ (fun i _ =>
      (measurable_const.indicator (show MeasurableSet (centralInterval h) from measurableSet_Icc)).comp (measurable_pi_apply i))
  have he : {t : ι → ℝ | |Real.log (folded h t)-(Fintype.card ι : ℝ)*logMean h| < c ∧
        r ≤ ∑ i, (centralInterval h).indicator (fun _ => (1 : ℝ)) (t i)} = (A ∪ B)ᶜ := by
    ext t
    simp only [A, B, mem_ofPred_eq, mem_compl_iff, mem_union, not_or, not_le, not_lt]
  rw [he, measureReal_compl (hA.union hB)]
  have hu := measureReal_union_le (μ := cubeLaw h) A B
  have ha := folded_chebyshev (ι := ι) hp hc
  have hb := central_count_tail (ι := ι) hh hi hr
  change (cubeLaw h).real A ≤ _ at ha
  change (cubeLaw h).real B ≤ _ at hb
  have hu1 : (cubeLaw h : Measure (ι → ℝ)).real Set.univ = 1 := by simp
  rw [hu1]
  linarith



end SingleLatticeCovering.Folded



noncomputable section
open Module Submodule MeasureTheory
open scoped BigOperators

namespace SingleLatticeCovering.ConstructionA

variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def generator (p : ℕ) (a : ι → ℤ) : ι → ℝ := fun j => (a j : ℝ) / p

def matrix (p : ℕ) (i : ι) (a : ι → ℤ) : Matrix ι ι ℝ :=
  (1 : Matrix ι ι ℝ).updateRow i (generator p a)

lemma det_matrix (p : ℕ) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    (matrix p i a).det = (p : ℝ)⁻¹ := by
  have hs : (∑ j, (generator p a j) • (1 : Matrix ι ι ℝ) j) = generator p a := by
    ext k
    simp [Matrix.one_apply, Pi.smul_apply, smul_eq_mul]
  rw [matrix, ← hs, Matrix.det_updateRow_sum]
  simp [generator, ha]

lemma independent_matrix (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    LinearIndependent ℝ (matrix p i a) := by
  apply Matrix.linearIndependent_rows_iff_isUnit.mpr
  rw [Matrix.isUnit_iff_isUnit_det]
  change IsUnit (matrix p i a).det
  rw [det_matrix p i a ha]
  exact isUnit_iff_ne_zero.mpr (inv_ne_zero (by exact_mod_cast hp.ne'))

def basis (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    Basis ι ℝ (ι → ℝ) := by
  letI : Nonempty ι := ⟨i⟩
  exact Basis.mk (independent_matrix p hp i a ha)
    (by rw [(independent_matrix p hp i a ha).span_eq_top_of_card_eq_finrank
      (Module.finrank_pi ℝ).symm])

@[simp] lemma basis_apply (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1)
    (j : ι) : basis p hp i a ha j = matrix p i a j := by
  unfold basis
  exact Basis.mk_apply _ _ j

@[simp] lemma basis_pivot (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    basis p hp i a ha i = generator p a := by
  rw [basis_apply]
  exact Matrix.updateRow_self

lemma basis_other (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1)
    (j : ι) (hj : j ≠ i) : basis p hp i a ha j = (Pi.basisFun ℝ ι) j := by
  rw [basis_apply]
  change (1 : Matrix ι ι ℝ).updateRow i (generator p a) j = _
  rw [Matrix.updateRow_ne hj]
  ext k
  simp [Pi.basisFun_apply, Matrix.one_apply, Pi.single_apply, eq_comm]

def lattice (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    Submodule ℤ (ι → ℝ) := span ℤ (Set.range (basis p hp i a ha))

instance lattice_discrete (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    DiscreteTopology (lattice p hp i a ha) := inferInstanceAs
      (DiscreteTopology (span ℤ (Set.range (basis p hp i a ha))))

instance lattice_full (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    IsZLattice ℝ (lattice p hp i a ha) := inferInstanceAs
      (IsZLattice ℝ (span ℤ (Set.range (basis p hp i a ha))))

lemma covolume_lattice (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    ZLattice.covolume (lattice p hp i a ha) = (p : ℝ)⁻¹ := by
  change ZLattice.covolume (span ℤ (Set.range (basis p hp i a ha))) = _
  rw [ZLattice.covolume_eq_measure_fundamentalDomain _ volume
    (ZSpan.isAddFundamentalDomain (basis p hp i a ha) volume),
    ZSpan.volume_real_fundamentalDomain]
  have he : Matrix.of (basis p hp i a ha) = matrix p i a := by ext; simp
  rw [he, det_matrix p i a ha, abs_of_pos (inv_pos.mpr (by exact_mod_cast hp))]

lemma generator_mem (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    generator p a ∈ lattice p hp i a ha := by
  rw [← basis_pivot p hp i a ha]
  exact subset_span ⟨i, rfl⟩

lemma integer_mem (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1)
    (z : ι → ℤ) : (fun j => (z j : ℝ)) ∈ lattice p hp i a ha := by
  rw [lattice, Submodule.mem_span_range_iff_exists_fun]
  refine ⟨fun j => if j = i then (p : ℤ)*z i else z j-z i*a j, ?_⟩
  ext k
  rw [Finset.sum_apply, ← Finset.sum_erase_add _ _ (Finset.mem_univ i)]
  simp only [Pi.smul_apply, basis_pivot, generator, zsmul_eq_mul]
  have he : ∑ j ∈ Finset.univ.erase i,
      ((if j = i then (p : ℤ)*z i else z j-z i*a j) : ℤ) •
        basis p hp i a ha j k =
      if k = i then 0 else (z k : ℝ) - (z i : ℝ)*(a k : ℝ) := by
    calc
      _ = ∑ j ∈ Finset.univ.erase i,
          ((z j : ℝ)-(z i : ℝ)*(a j : ℝ)) * (if j = k then 1 else 0) := by
        apply Finset.sum_congr rfl
        intro j hj
        have hji := (Finset.mem_erase.mp hj).1
        rw [ite_eq_right hji, basis_other p hp i a ha j hji]
        simp [Pi.basisFun_apply, Pi.single_apply, eq_comm, zsmul_eq_mul]
      _ = _ := by
        by_cases hki : k = i
        · subst k
          simp only [↓reduceIte]
          apply Finset.sum_eq_zero
          intro j hj
          simp [(Finset.mem_erase.mp hj).1]
        · simp [hki, Finset.mem_erase]
  simp only [zsmul_eq_mul] at he
  rw [he]
  have hp0 : (p : ℝ) ≠ 0 := by exact_mod_cast hp.ne'
  by_cases hki : k = i
  · subst k; simp [ha]; field_simp
  · rw [ite_eq_right hki]
    push_cast
    field_simp
    ring

lemma mem_lattice_iff (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1)
    (x : ι → ℝ) : x ∈ lattice p hp i a ha ↔
      ∃ (z : ι → ℤ) (m : ℤ), x = (fun j => (z j : ℝ)) + m • generator p a := by
  constructor
  · intro hx
    obtain ⟨c, hc⟩ := (Submodule.mem_span_range_iff_exists_fun ℤ).mp hx
    refine ⟨fun j => if j = i then 0 else c j, c i, ?_⟩
    rw [← hc]
    ext k
    rw [Finset.sum_apply, ← Finset.sum_erase_add _ _ (Finset.mem_univ i)]
    simp only [Pi.add_apply, Pi.smul_apply, basis_pivot]
    congr 1
    calc
      _ = ∑ j ∈ Finset.univ.erase i, (c j : ℝ) * (if j = k then 1 else 0) := by
        apply Finset.sum_congr rfl
        intro j hj
        rw [basis_other p hp i a ha j (Finset.mem_erase.mp hj).1]
        simp [Pi.basisFun_apply, Pi.single_apply, eq_comm, zsmul_eq_mul]
      _ = _ := by
        by_cases hki : k = i
        · subst k
          simp only [↓reduceIte, Int.cast_zero]
          apply Finset.sum_eq_zero
          intro j hj
          simp [(Finset.mem_erase.mp hj).1]
        · simp [hki, Finset.mem_erase]
  · rintro ⟨z, m, rfl⟩
    exact (lattice p hp i a ha).add_mem (integer_mem p hp i a ha z)
      ((lattice p hp i a ha).smul_mem m (generator_mem p hp i a ha))



end SingleLatticeCovering.ConstructionA

namespace SingleLatticeCovering.ConstructionA
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def residue (p : ℕ) (k : ι → ℤ) : ι → ZMod p := fun j => (k j : ZMod p)



def codeLattice (p : ℕ) (C : Submodule (ZMod p) (ι → ZMod p)) :
    Submodule ℤ (ι → ℝ) where
  carrier := {x | ∃ k : ι → ℤ, residue p k ∈ C ∧ generator p k = x}
  zero_mem' := ⟨0, by convert C.zero_mem using 1 ; ext j ; simp [residue], by ext; simp [generator]⟩
  add_mem' := by
    rintro x y ⟨k, hk, rfl⟩ ⟨l, hl, rfl⟩
    refine ⟨k+l, ?_, ?_⟩
    · convert C.add_mem hk hl using 1 ; ext j ; simp [residue]
    · ext j; simp [generator, add_div]
  smul_mem' := by
    rintro m x ⟨k, hk, rfl⟩
    refine ⟨m • k, ?_, ?_⟩
    · convert C.smul_mem (m : ZMod p) hk using 1 ; ext j ; simp [residue]
    · ext j; simp [generator, zsmul_eq_mul, mul_div_assoc]

lemma lattice_eq_codeLattice (p : ℕ) (hp : 0 < p) (i : ι) (a : ι → ℤ) (ha : a i = 1) :
    lattice p hp i a ha = codeLattice p (Submodule.span (ZMod p) {residue p a}) := by
  let : NeZero p := ⟨hp.ne'⟩
  ext x
  rw [mem_lattice_iff]
  constructor
  · rintro ⟨z, m, rfl⟩
    refine ⟨fun j => (p : ℤ)*z j+m*a j, ?_, ?_⟩
    · apply Submodule.mem_span_singleton.mpr
      refine ⟨(m : ZMod p), ?_⟩
      ext j
      simp [residue]
    · ext j
      simp only [Pi.add_apply, zsmul_eq_mul, Pi.mul_apply]
      change ((p : ℤ)*z j+m*a j : ℤ) / (p : ℝ) = (z j : ℝ) + (m : ℝ)*((a j : ℝ)/p)
      push_cast
      field_simp

  · rintro ⟨k, hk, rfl⟩
    obtain ⟨r, hr⟩ := Submodule.mem_span_singleton.mp hk
    let m : ℤ := r.val
    have hm : (m : ZMod p) = r := by simp [m]
    have hd (j : ι) : (p : ℤ) ∣ k j - m*a j := by
      apply (ZMod.intCast_zmod_eq_zero_iff_dvd _ _).mp
      have hj := congr_fun hr j
      simpa [residue, hm] using sub_eq_zero.mpr hj.symm
    choose z hz using hd
    refine ⟨z, m, ?_⟩
    ext j
    have hj : (k j : ℝ) - (m : ℝ)*(a j : ℝ) = (p : ℝ)*(z j : ℝ) := by
      exact_mod_cast hz j
    simp only [Pi.add_apply, zsmul_eq_mul, Pi.mul_apply]
    change (k j : ℝ)/(p : ℝ) = (z j : ℝ)+(m : ℝ)*((a j : ℝ)/p)
    apply (div_eq_iff (show (p : ℝ) ≠ 0 by exact_mod_cast hp.ne')).mpr
    field_simp
    nlinarith

lemma normalized_lift {ι : Type*} [Fintype ι] [DecidableEq ι] (p : ℕ) [Fact p.Prime] (v : ι → ZMod p) (hv : v ≠ 0) :
    ∃ (i : ι) (a : ι → ℤ), a i = 1 ∧
      Submodule.span (ZMod p) {residue p a} = Submodule.span (ZMod p) {v} := by
  have hp : p.Prime := Fact.out
  let : Fact (1 < p) := ⟨hp.one_lt⟩
  obtain ⟨i, hi⟩ : ∃ i, v i ≠ 0 := by
    by_contra! h
    exact hv (funext h)
  let a : ι → ℤ := fun j => ((v i)⁻¹*v j).val
  have ha : a i = 1 := by simp only [a, inv_mul_cancel₀ hi, ZMod.val_one, Nat.cast_one]
  have hr : residue p a = (v i)⁻¹ • v := by
    ext j
    simp [residue, a]
  refine ⟨i, a, ha, ?_⟩
  apply le_antisymm
  · apply Submodule.span_le.mpr
    intro x hx
    rw [Set.mem_singleton_iff] at hx
    rw [hx]
    exact Submodule.mem_span_singleton.mpr ⟨(v i)⁻¹, hr.symm⟩
  · apply Submodule.span_le.mpr
    intro x hx
    rw [Set.mem_singleton_iff] at hx
    rw [hx]
    apply Submodule.mem_span_singleton.mpr
    refine ⟨v i, ?_⟩
    rw [hr, smul_smul, mul_inv_cancel₀ hi, one_smul]



theorem line_lattice (p : ℕ) [Fact p.Prime] (v : ι → ZMod p) (hv : v ≠ 0) :
    ∃ (_ : DiscreteTopology (codeLattice p (Submodule.span (ZMod p) {v}))),
      IsZLattice ℝ (codeLattice p (Submodule.span (ZMod p) {v})) ∧
      ZLattice.covolume (codeLattice p (Submodule.span (ZMod p) {v})) = (p : ℝ)⁻¹ := by
  obtain ⟨i, a, ha, hspan⟩ := normalized_lift p v hv
  have hp : 0 < p := (show p.Prime from Fact.out).pos
  have he : codeLattice p (Submodule.span (ZMod p) {v}) = lattice p hp i a ha := by
    rw [lattice_eq_codeLattice p hp i a ha, hspan]
  rw [he]
  exact ⟨inferInstance, inferInstance, covolume_lattice p hp i a ha⟩


end SingleLatticeCovering.ConstructionA

namespace SingleLatticeCovering.ConstructionA
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def floorVector (p : ℕ) (t : ι → ℝ) : ι → ℤ := fun j => ⌊(p : ℝ)*t j⌋
def anchor (p : ℕ) (z : ι → ZMod p) : ι → ℝ := fun j => (z j).val / (p : ℝ)
def integerLift (p : ℕ) (z : ι → ZMod p) : ι → ℤ := fun j => (z j).val

def gridCell (p : ℕ) (z : ι → ZMod p) : Set (ι → ℝ) :=
  {t | ∀ j, t j - anchor p z j ∈ Set.Ico 0 (p : ℝ)⁻¹}

def cellPoint (p : ℕ) (t : ι → ℝ) (z : ι → ZMod p) : ι → ℝ :=
  generator p (floorVector p t - integerLift p z)

lemma residue_integerLift {ι : Type*} [Fintype ι] [DecidableEq ι] (p : ℕ) [NeZero p] (z : ι → ZMod p) :
    residue p (integerLift p z) = z := by
  ext j
  simp only [residue, integerLift, Int.cast_natCast, ZMod.natCast_zmod_val]

lemma cellPoint_mem {ι : Type*} [Fintype ι] [DecidableEq ι] (p : ℕ) [NeZero p] (C : Submodule (ZMod p) (ι → ZMod p))
    (t : ι → ℝ) (z : ι → ZMod p)
    (hz : residue p (floorVector p t) - z ∈ C) : cellPoint p t z ∈ codeLattice p C := by
  refine ⟨floorVector p t - integerLift p z, ?_, rfl⟩
  convert hz using 1
  ext j
  simp [residue, integerLift]

lemma cell_residual {ι : Type*} [Fintype ι] [DecidableEq ι] (p : ℕ) (hp : 0 < p) (t : ι → ℝ) (z : ι → ZMod p) (j : ι) :
    (t-cellPoint p t z) j = ((z j).val + Int.fract ((p : ℝ)*t j))/(p : ℝ) := by
  have hp0 : (p : ℝ) ≠ 0 := by exact_mod_cast hp.ne'
  have hf := Int.floor_add_fract ((p : ℝ)*t j)
  simp only [Pi.sub_apply, cellPoint, generator, floorVector, integerLift, Int.cast_sub,
    Int.cast_natCast]
  apply (eq_div_iff hp0).mpr
  field_simp
  nlinarith [Int.floor_add_fract (t j*(p : ℝ))]

lemma cell_residual_mem_grid (p : ℕ) (hp : 0 < p) (t : ι → ℝ) (z : ι → ZMod p) :
    t-cellPoint p t z ∈ gridCell p z := by
  intro j
  rw [cell_residual p hp t z j]
  have hp0 : (0 : ℝ) < p := by exact_mod_cast hp
  change 0 ≤ ((z j).val+Int.fract ((p : ℝ)*t j))/(p : ℝ)-(z j).val/(p : ℝ) ∧
    ((z j).val+Int.fract ((p : ℝ)*t j))/(p : ℝ)-(z j).val/(p : ℝ) < (p : ℝ)⁻¹
  rw [add_div, add_sub_cancel_left]
  constructor
  · exact div_nonneg (Int.fract_nonneg _) hp0.le
  · simpa only [one_div] using (div_lt_div_of_pos_right (Int.fract_lt_one _) hp0)

lemma gridCell_subset_cube {ι : Type*} [Fintype ι] [DecidableEq ι] (p : ℕ) (hp : 0 < p) (z : ι → ZMod p) (τ : ι → ℝ)
    (hτ : τ ∈ gridCell p z) (j : ι) : τ j ∈ Set.Ico 0 1 := by
  let : NeZero p := ⟨hp.ne'⟩
  have hp0 : (0 : ℝ) < p := by exact_mod_cast hp
  have hj := hτ j
  change 0 ≤ τ j - (z j).val/(p : ℝ) ∧ τ j - (z j).val/(p : ℝ) < (p : ℝ)⁻¹ at hj
  have hv : ((z j).val : ℝ)+1 ≤ (p : ℝ) := by exact_mod_cast Nat.succ_le_iff.mpr (ZMod.val_lt _)
  have h0 : 0 ≤ ((z j).val : ℝ)/(p : ℝ) := div_nonneg (Nat.cast_nonneg _) hp0.le
  have hl : ((z j).val : ℝ)/(p : ℝ) + (p : ℝ)⁻¹ ≤ 1 := by
    rw [← one_div, ← add_div, div_le_one hp0]
    exact hv
  exact ⟨by linarith, by linarith⟩

lemma integer_code_mem {ι : Type*} [Fintype ι] [DecidableEq ι] (p : ℕ) (hp : 0 < p) (C : Submodule (ZMod p) (ι → ZMod p))
    (k : ι → ℤ) : (fun j => (k j : ℝ)) ∈ codeLattice p C := by
  refine ⟨fun j => (p : ℤ)*k j, ?_, ?_⟩
  · have he : residue p (fun j => (p : ℤ)*k j) = 0 := by ext; simp [residue]
    rw [he]; exact C.zero_mem
  · ext j
    simp [generator, show (p : ℝ) ≠ 0 by exact_mod_cast hp.ne']

lemma cell_bits (p : ℕ) (hp : 0 < p) (C : Submodule (ZMod p) (ι → ZMod p))
    (t : ι → ℝ) (z : ι → ZMod p)
    (hz : residue p (floorVector p t) - z ∈ C) (e : ι → Bool) :
    cellPoint p t z + (fun j => if e j then (1 : ℝ) else 0) ∈ codeLattice p C ∧
      ∀ j, (t j - cellPoint p t z j - (if e j then (1 : ℝ) else 0)) ∈ Set.Icc (-1) 1 := by
  let : NeZero p := ⟨hp.ne'⟩
  refine ⟨(codeLattice p C).add_mem (cellPoint_mem p C t z hz) ?_, ?_⟩
  · convert integer_code_mem p hp C (fun j => if e j then (1 : ℤ) else 0) using 1
    ext j
    cases e j <;> simp
  · intro j
    have hj := gridCell_subset_cube p hp z _ (cell_residual_mem_grid p hp t z) j
    simp only [Pi.sub_apply, Set.mem_Ico] at hj
    cases e j <;> simp only [Bool.false_eq_true, ↓reduceIte, sub_zero, Set.mem_Icc] <;>
      constructor <;> linarith


end SingleLatticeCovering.ConstructionA

namespace SingleLatticeCovering.ConstructionA
open Set MeasureTheory
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

lemma gridCell_eq_pi {ι : Type*} [Fintype ι] [DecidableEq ι] (p : ℕ) (z : ι → ZMod p) :
    gridCell p z = Set.univ.pi (fun j => Ico (anchor p z j) (anchor p z j+(p : ℝ)⁻¹)) := by
  ext t
  simp only [gridCell, Set.mem_ofPred_eq, Set.mem_univ_pi, Set.mem_Ico]
  constructor <;> intro ht j <;> have hj := ht j <;> constructor <;> linarith

lemma gridCell_measurable (p : ℕ) (z : ι → ZMod p) : MeasurableSet (gridCell p z) := by
  rw [gridCell_eq_pi]
  exact MeasurableSet.pi Set.countable_univ (fun _ _ => measurableSet_Ico)

lemma floorVector_gridCell {ι : Type*} [Fintype ι] [DecidableEq ι] {p : ℕ} (hp : 0 < p) {z : ι → ZMod p} {t : ι → ℝ}
    (ht : t ∈ gridCell p z) : floorVector p t = integerLift p z := by
  have hp0 : (0 : ℝ) < p := by exact_mod_cast hp
  ext j
  apply Int.floor_eq_iff.mpr
  have hj := ht j
  change 0 ≤ t j-(z j).val/(p : ℝ) ∧ t j-(z j).val/(p : ℝ) < (p : ℝ)⁻¹ at hj
  have h1 := mul_le_mul_of_nonneg_left hj.1 hp0.le
  have h2 := mul_lt_mul_of_pos_left hj.2 hp0
  simp only [mul_sub, mul_div_cancel₀ _ hp0.ne', mul_inv_cancel₀ hp0.ne', mul_zero] at h1 h2
  change ((z j).val : ℝ) ≤ (p : ℝ)*t j ∧ (p : ℝ)*t j < (z j).val+1
  constructor <;> linarith

lemma gridCell_disjoint {p : ℕ} (hp : 0 < p) {z w : ι → ZMod p} (hzw : z ≠ w) :
    Disjoint (gridCell p z) (gridCell p w) := by
  let : NeZero p := ⟨hp.ne'⟩
  apply Set.disjoint_left.mpr
  intro t hz hw
  have he := (floorVector_gridCell hp hz).symm.trans (floorVector_gridCell hp hw)
  have he' := congr_arg (residue p) he
  simp only [residue_integerLift] at he'
  exact hzw he'

lemma anchor_floorVector {ι : Type*} [Fintype ι] [DecidableEq ι] {p : ℕ} (hp : 0 < p) {t : ι → ℝ}
    (ht : ∀ j, t j ∈ Ico 0 1) (j : ι) :
    anchor p (residue p (floorVector p t)) j = (⌊(p : ℝ)*t j⌋ : ℝ)/(p : ℝ) := by
  let : NeZero p := ⟨hp.ne'⟩
  have hp0 : (0 : ℝ) < p := by exact_mod_cast hp
  have h0 : 0 ≤ ⌊(p : ℝ)*t j⌋ := Int.floor_nonneg.mpr (mul_nonneg hp0.le (ht j).1)
  have h1 : ⌊(p : ℝ)*t j⌋ < (p : ℤ) := Int.floor_lt.mpr (by simpa only [Int.cast_natCast, mul_one] using (mul_lt_mul_of_pos_left (ht j).2 hp0))
  have he := ZMod.val_intCast (n := p) (a := ⌊(p : ℝ)*t j⌋)
  rw [Int.emod_eq_of_lt h0 h1] at he
  unfold anchor residue floorVector
  congr 1
  exact_mod_cast he

lemma cube_mem_gridCell {p : ℕ} (hp : 0 < p) {t : ι → ℝ} (ht : ∀ j, t j ∈ Ico 0 1) :
    t ∈ gridCell p (residue p (floorVector p t)) := by
  have hp0 : (0 : ℝ) < p := by exact_mod_cast hp
  intro j
  rw [anchor_floorVector hp ht]
  have h0 := Int.floor_le ((p : ℝ)*t j)
  have h1 := Int.lt_floor_add_one ((p : ℝ)*t j)
  constructor
  · rw [sub_nonneg, div_le_iff₀ hp0]
    nlinarith
  · rw [sub_lt_iff_lt_add, ← one_div, ← add_div, lt_div_iff₀ hp0]
    nlinarith

lemma gridCell_iUnion {p : ℕ} (hp : 0 < p) :
    (⋃ z : ι → ZMod p, gridCell p z) = Set.univ.pi (fun _ : ι => Ico (0 : ℝ) 1) := by
  ext t
  simp only [Set.mem_iUnion, Set.mem_univ_pi]
  constructor
  · rintro ⟨z, ht⟩ j
    exact gridCell_subset_cube p hp z t ht j
  · intro ht
    exact ⟨_, cube_mem_gridCell hp ht⟩

lemma gridCell_volume (p : ℕ) (z : ι → ZMod p) :
    volume (gridCell p z) = (ENNReal.ofReal ((p : ℝ)⁻¹))^Fintype.card ι := by
  rw [gridCell_eq_pi, volume_pi_pi]
  simp only [Real.volume_Ico, add_sub_cancel_left, Finset.prod_const, Finset.card_univ]

lemma gridCell_volume_real (p : ℕ) (z : ι → ZMod p) :
    volume.real (gridCell p z) = ((p : ℝ)⁻¹)^Fintype.card ι := by
  rw [Measure.real, gridCell_volume, ENNReal.toReal_pow, ENNReal.toReal_ofReal]
  positivity

lemma integral_gridCells {p : ℕ} [NeZero p] (hp : 0 < p) {f : (ι → ℝ) → ℝ}
    (hf : Continuous f) :
    (∫ t in Set.univ.pi (fun _ : ι => Icc (0 : ℝ) 1), f t) =
      ∑ z : ι → ZMod p, ∫ t in gridCell p z, f t := by
  let : NeZero p := ⟨hp.ne'⟩
  have hi : IsCompact (Set.univ.pi (fun _ : ι => Icc (0 : ℝ) 1)) :=
    isCompact_univ_pi (fun _ => isCompact_Icc)
  have hf' z : IntegrableOn f (gridCell p z) :=
    (hf.continuousOn.integrableOn_compact hi).mono_set (by
      intro t ht
      exact Set.mem_univ_pi.mpr (fun j => (gridCell_subset_cube p hp z t ht j).imp_right le_of_lt))
  have he : Set.univ.pi (fun _ : ι => Ico (0 : ℝ) 1) =ᵐ[volume]
      Set.univ.pi (fun _ : ι => Icc (0 : ℝ) 1) := by
    rw [volume_pi]
    exact Measure.pi_Ico_ae_eq_pi_Icc
  rw [←setIntegral_congr_set he, ←gridCell_iUnion hp]
  exact integral_iUnion_fintype (gridCell_measurable p)
    (fun _ _ hz => gridCell_disjoint hp hz) hf'


end SingleLatticeCovering.ConstructionA


end
end
end
end
end
end

end OAI