import Mathlib
import OAI.Computability.MinUncut.Encoding.UniformEncoding

namespace OAI

noncomputable section
open MeasureTheory ProbabilityTheory
open scoped RealInnerProductSpace NNReal
namespace MinUncut.GaussianBudget

lemma pdf_le_one {v : ℝ≥0} (hv : 1≤v) (x : ℝ) : gaussianPDFReal 0 v x≤1 := by
  have hvR : (1:ℝ)≤v := by exact_mod_cast hv
  have hs : 1≤Real.sqrt (2*Real.pi*(v:ℝ)) := by
    apply Real.le_sqrt_of_sq_le
    nlinarith [Real.pi_gt_three]
  have he : Real.exp (-(x-0)^2/(2*(v:ℝ))) ≤ 1 := Real.exp_le_one_iff.mpr (div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (sq_nonneg _)) (by positivity))
  rw [gaussianPDFReal]
  exact (mul_le_mul_of_nonneg_left he (by positivity)).trans (by simpa using (one_div_le_one_div_of_le (by norm_num : (0:ℝ)<1) hs))

lemma small_ball {v : ℝ≥0} (hv : 1≤v) {r : ℝ} (hr : 0≤r) :
    (gaussianReal 0 v).real {x : ℝ | |x|≤r} ≤ 2*r := by
  have hv0 : v≠0 := by linarith
  have he : {x : ℝ | |x|≤r}=Set.Icc (-r) r := by ext x; simp only [Set.mem_ofPred_eq,Set.mem_Icc,abs_le]
  rw [he,Measure.real,gaussianReal_apply_eq_integral 0 hv0]
  rw [ENNReal.toReal_ofReal (integral_nonneg (fun x => gaussianPDFReal_nonneg 0 v x))]
  calc
    _ ≤ ∫ _ : ℝ in Set.Icc (-r) r, (1:ℝ) :=
      integral_mono (integrable_gaussianPDFReal 0 v).integrableOn (integrable_const 1) (fun x => pdf_le_one hv x)
    _ = 2*r := by simp only [setIntegral_const,smul_eq_mul,mul_one,Real.volume_real_Icc]; rw [max_eq_left (by linarith)]; ring

def betweenIndicator (x y : ℝ) : ℝ := if |x|≤|y| then 1 else 0

lemma between_measurable : Measurable (fun p : ℝ×ℝ => betweenIndicator p.1 p.2) := by
  unfold betweenIndicator
  exact Measurable.ite (measurableSet_le (by fun_prop) (by fun_prop)) measurable_const measurable_const

lemma between_integrable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsFiniteMeasure μ]
    {X Y : Ω → ℝ} (hX : Measurable X) (hY : Measurable Y) :
    Integrable (fun ω => betweenIndicator (X ω) (Y ω)) μ := by
  apply Integrable.of_bound (between_measurable.comp (hX.prodMk hY)).aestronglyMeasurable 1
  filter_upwards [] with x
  change |betweenIndicator (X x) (Y x)|≤1
  unfold betweenIndicator
  split_ifs <;> norm_num

lemma integral_between {v : ℝ≥0} (hv : 1≤v) (y : ℝ) :
    (∫ x, betweenIndicator x y ∂gaussianReal 0 v) ≤ 2*|y| := by
  have he : (fun x => betweenIndicator x y) = Set.indicator {x : ℝ | |x|≤|y|} (fun _ => (1:ℝ)) := by
    ext x; simp only [betweenIndicator,Set.indicator_apply,Set.mem_ofPred_eq]
  rw [he,integral_indicator (measurableSet_le (by fun_prop) measurable_const),setIntegral_const]
  simpa using small_ball hv (abs_nonneg y)

lemma independent_small_ball {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ]
    {X Y : Ω→ℝ} (hX : Measurable X) (hY : Measurable Y) (hYI : Integrable Y μ)
    (hXY : IndepFun X Y μ) {v : ℝ≥0} (hv : 1≤v) (hlaw : μ.map X=gaussianReal 0 v) :
    (∫ ω, betweenIndicator (X ω) (Y ω) ∂μ) ≤ 2*(∫ ω, |Y ω| ∂μ) := by
  have hmap := hXY.map_prod_eq_prod_map_map hX.aemeasurable hY.aemeasurable
  have hi : Integrable (fun p : ℝ×ℝ => betweenIndicator p.1 p.2) ((μ.map X).prod (μ.map Y)) :=
    between_integrable measurable_fst measurable_snd
  have he : (∫ ω, betweenIndicator (X ω) (Y ω) ∂μ) =
      ∫ y, ∫ x, betweenIndicator x y ∂(μ.map X) ∂(μ.map Y) := by
    rw [← integral_map (hX.prodMk hY).aemeasurable between_measurable.aestronglyMeasurable,hmap,
      integral_prod_symm _ hi]
  rw [he,hlaw]
  have hiY : Integrable (fun y : ℝ => 2*|y|) (μ.map Y) := by
    rw [integrable_map_measure (by fun_prop) hY.aemeasurable]
    exact hYI.abs.const_mul 2
  have hiB : Integrable (fun y => ∫ x, betweenIndicator x y ∂gaussianReal 0 v) (μ.map Y) := by
    rw [hlaw] at hi
    exact hi.integral_prod_right
  calc
    _ ≤ ∫ y, 2*|y| ∂(μ.map Y) := integral_mono hiB hiY (integral_between hv)
    _ = _ := by rw [integral_const_mul,integral_map hY.aemeasurable (by fun_prop)]

attribute [local instance] Classical.propDecidable

def signFailure (x y : ℝ) : ℝ := if (0 ≤ x ↔ 0 ≤ y) then 0 else 1

lemma signFailure_range (x y : ℝ) : 0 ≤ signFailure x y ∧ signFailure x y ≤ 1 := by
  unfold signFailure
  split_ifs <;> norm_num

lemma signFailure_measurable : Measurable (fun p : ℝ×ℝ => signFailure p.1 p.2) := by
  unfold signFailure
  apply Measurable.ite _ measurable_const measurable_const
  exact (measurableSet_le measurable_const measurable_fst).iff
    (measurableSet_le measurable_const measurable_snd)

lemma signFailure_integrable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsFiniteMeasure μ]
    {X Y : Ω → ℝ} (hX : Measurable X) (hY : Measurable Y) :
    Integrable (fun ω => signFailure (X ω) (Y ω)) μ := by
  apply Integrable.of_bound (signFailure_measurable.comp (hX.prodMk hY)).aestronglyMeasurable 1
  filter_upwards [] with ω
  change ‖signFailure (X ω) (Y ω)‖ ≤ 1
  rw [Real.norm_eq_abs,abs_of_nonneg (signFailure_range _ _).1]
  exact (signFailure_range _ _).2

lemma signFailure_add_le (x y : ℝ) : signFailure x (x+y) ≤ betweenIndicator x y := by
  unfold signFailure betweenIndicator
  split_ifs with h h' h'
  all_goals try norm_num
  exfalso
  apply h'
  have hh : (x < 0 ∧ 0 ≤ x+y) ∨ (0 ≤ x ∧ x+y < 0) := by
    by_cases hx : 0 ≤ x
    · right; refine ⟨hx,lt_of_not_ge ?_⟩; intro hy; exact h (iff_of_true hx hy)
    · left; refine ⟨lt_of_not_ge hx,?_⟩; by_contra hy; exact h (iff_of_false hx hy)
  rcases hh with hh|hh
  · rw [abs_of_neg hh.1,abs_of_nonneg (by linarith : 0 ≤ y)]; linarith
  · rw [abs_of_nonneg hh.1,abs_of_neg (by linarith : y < 0)]; linarith

lemma signFailure_sumdiff_le (x y : ℝ) : signFailure x y ≤ betweenIndicator (x+y) (x-y) := by
  unfold signFailure betweenIndicator
  split_ifs with h h' h'
  all_goals try norm_num
  exfalso
  apply h'
  have hh : (x < 0 ∧ 0 ≤ y) ∨ (0 ≤ x ∧ y < 0) := by
    by_cases hx : 0 ≤ x
    · right; refine ⟨hx,lt_of_not_ge ?_⟩; intro hy; exact h (iff_of_true hx hy)
    · left; refine ⟨lt_of_not_ge hx,?_⟩; by_contra hy; exact h (iff_of_false hx hy)
  rcases hh with hh|hh
  · rw [abs_of_neg (by linarith : x-y < 0)]
    rw [abs_le]; constructor <;> linarith
  · rw [abs_of_nonneg (by linarith : 0 ≤ x-y)]
    rw [abs_le]; constructor <;> linarith

lemma signFailure_triangle (x y z : ℝ) :
    signFailure x z ≤ signFailure x y+signFailure y z := by
  by_cases hx : 0 ≤ x <;> by_cases hy : 0 ≤ y <;> by_cases hz : 0 ≤ z <;>
    simp [signFailure,hx,hy,hz]

lemma integral_abs_le_sqrt_sq {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : MemLp X 2 μ) :
    (∫ ω, |X ω| ∂μ) ≤ Real.sqrt (∫ ω, X ω^2 ∂μ) := by
  have h := integral_mul_norm_le_Lp_mul_Lq (p := 2) (q := 2)
    (by rw [Real.holderConjugate_iff]; norm_num : (2:ℝ).HolderConjugate 2)
    (by simpa using hX) (by simpa using (memLp_const (1:ℝ) (p := 2) (μ := μ)))
  simpa only [Real.norm_eq_abs,abs_one,mul_one,Real.rpow_two,sq_abs,
    one_pow,integral_const,probReal_univ,one_smul,Real.one_rpow,← Real.sqrt_eq_rpow,Real.sqrt_one,mul_one] using h

lemma independent_sign_add {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ]
    {X Y : Ω → ℝ} (hX : Measurable X) (hY : Measurable Y) (hy : MemLp Y 2 μ)
    (hXY : IndepFun X Y μ) {v : ℝ≥0} (hv : 1 ≤ v) (hlaw : μ.map X=gaussianReal 0 v) :
    (∫ ω, signFailure (X ω) (X ω+Y ω) ∂μ) ≤ 2*Real.sqrt (∫ ω, Y ω^2 ∂μ) := by
  calc
    _ ≤ ∫ ω, betweenIndicator (X ω) (Y ω) ∂μ :=
      integral_mono (signFailure_integrable hX (hX.add hY)) (between_integrable hX hY) (fun ω => signFailure_add_le _ _)
    _ ≤ 2*(∫ ω, |Y ω| ∂μ) := independent_small_ball hX hY (hy.integrable (by norm_num)) hXY hv hlaw
    _ ≤ _ := mul_le_mul_of_nonneg_left (integral_abs_le_sqrt_sq hy) (by norm_num)

variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
    [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E]

lemma inner_hasGaussianLaw (v : E) : HasGaussianLaw (fun c : E => ⟪v,c⟫) (stdGaussian E) := by
  exact IsGaussian.hasGaussianLaw_id.map (innerSL ℝ v)

lemma inner_law (v : E) : (stdGaussian E).map (fun c : E => ⟪v,c⟫) =
    gaussianReal 0 ⟨‖v‖^2,sq_nonneg _⟩ := by
  have h := (inner_hasGaussianLaw v).map_eq_gaussianReal
  have hm : (∫ c : E, ⟪v,c⟫ ∂stdGaussian E)=0 := integral_strongDual_stdGaussian (innerSL ℝ v)
  have hv : Var[fun c : E => ⟪v,c⟫;stdGaussian E]=‖v‖^2 := by
    change Var[⇑(innerSL ℝ v);stdGaussian E]=‖v‖^2
    rw [variance_dual_stdGaussian,innerSL_apply_norm]
  rw [hm,hv] at h
  convert h using 2
  congr 1
  apply Subtype.ext
  simp

lemma inner_second_moment (v : E) : (∫ c : E, ⟪v,c⟫^2 ∂stdGaussian E)=‖v‖^2 := by
  have h := variance_eq_sub (inner_hasGaussianLaw v).memLp_two
  have hm : (∫ c : E, ⟪v,c⟫ ∂stdGaussian E)=0 := integral_strongDual_stdGaussian (innerSL ℝ v)
  have hv : Var[fun c : E => ⟪v,c⟫;stdGaussian E]=‖v‖^2 := by
    change Var[⇑(innerSL ℝ v);stdGaussian E]=‖v‖^2
    rw [variance_dual_stdGaussian,innerSL_apply_norm]
  simpa only [hm,hv,zero_pow (by norm_num : (2:ℕ) ≠ 0),sub_zero,Pi.pow_apply] using h.symm

lemma orthogonal_indep {v w : E} (hvw : ⟪v,w⟫=0) :
    IndepFun (fun c : E => ⟪v,c⟫) (fun c : E => ⟪w,c⟫) (stdGaussian E) := by
  have hj : HasGaussianLaw (fun c : E => (⟪v,c⟫,⟪w,c⟫)) (stdGaussian E) :=
    IsGaussian.hasGaussianLaw_id.map ((innerSL ℝ v).prod (innerSL ℝ w))
  apply hj.indepFun_of_covariance_eq_zero
  rw [← covarianceBilin_apply_eq_cov IsGaussian.memLp_two_id,covarianceBilin_stdGaussian]
  exact hvw

lemma sign_inner_le {v w : E} (hv : ‖v‖=1) (hw : ‖w‖=1) :
    (∫ c : E, signFailure ⟪v,c⟫ ⟪w,c⟫ ∂stdGaussian E) ≤ 2*‖v-w‖ := by
  by_cases hd : 1 ≤ ‖v-w‖
  · have h := integral_mono (signFailure_integrable (μ := stdGaussian E) (X := fun c => ⟪v,c⟫) (Y := fun c => ⟪w,c⟫) (by fun_prop) (by fun_prop))
        (integrable_const (1:ℝ)) (fun c : E => (signFailure_range ⟪v,c⟫ ⟪w,c⟫).2)
    simp only [integral_const,probReal_univ,one_smul] at h
    linarith
  have hd1 : ‖v-w‖ < 1 := lt_of_not_ge hd
  have horth : ⟪v+w,v-w⟫=0 := by
    simp only [inner_add_left,inner_sub_right,real_inner_self_eq_norm_sq,real_inner_comm w v,hv,hw]
    ring
  have hsum : (1:ℝ) ≤ ‖v+w‖^2 := by
    have h := parallelogram_law_with_norm ℝ v w
    simp only [hv,hw,one_pow] at h
    nlinarith [norm_nonneg (v-w)]
  have hh := independent_small_ball (μ := stdGaussian E)
    (X := fun c : E => ⟪v+w,c⟫) (Y := fun c : E => ⟪v-w,c⟫)
    (by fun_prop) (by fun_prop) (inner_hasGaussianLaw (v-w)).integrable
    (orthogonal_indep horth) (v := ⟨‖v+w‖^2,sq_nonneg _⟩) (by exact_mod_cast hsum) (inner_law _)
  have hi := integral_abs_le_sqrt_sq (inner_hasGaussianLaw (v-w)).memLp_two
  rw [inner_second_moment,Real.sqrt_sq (norm_nonneg _)] at hi
  have hb := integral_mono (signFailure_integrable (μ := stdGaussian E) (X := fun c => ⟪v,c⟫) (Y := fun c => ⟪w,c⟫) (by fun_prop) (by fun_prop))
    (between_integrable (μ := stdGaussian E) (X := fun c => ⟪v+w,c⟫) (Y := fun c => ⟪v-w,c⟫)
      (by fun_prop) (by fun_prop)) (fun c => by
      simpa only [inner_add_left,inner_sub_left] using signFailure_sumdiff_le ⟪v,c⟫ ⟪w,c⟫)
  linarith

open MeasureTheory ProbabilityTheory
open scoped BigOperators RealInnerProductSpace
variable {ι : Type*} [Fintype ι]

def score (v c : ι → ℝ) : ℝ := ∑ i, v i*c i
abbrev vector (v : ι → ℝ) : EuclideanSpace ℝ ι := WithLp.toLp 2 v

lemma score_inner (v c : ι → ℝ) : score v c=⟪vector v,vector c⟫ := by
  simp [score,PiLp.inner_apply,vector,mul_comm]

lemma toLp_preserving : MeasurePreserving (MeasurableEquiv.toLp 2 (ι → ℝ))
    (Measure.pi (fun _ : ι => gaussianReal 0 1)) (stdGaussian (EuclideanSpace ℝ ι)) :=
  ⟨(MeasurableEquiv.toLp 2 (ι → ℝ)).measurable,map_pi_eq_stdGaussian⟩

lemma integral_score_sign (v w : ι → ℝ) :
    (∫ c, signFailure (score v c) (score w c) ∂Measure.pi (fun _ : ι => gaussianReal 0 1)) =
    ∫ c : EuclideanSpace ℝ ι, signFailure ⟪vector v,c⟫ ⟪vector w,c⟫ ∂stdGaussian (EuclideanSpace ℝ ι) := by
  simpa only [score_inner,MeasurableEquiv.toLp_apply] using toLp_preserving.integral_comp
    (MeasurableEquiv.toLp 2 (ι → ℝ)).measurableEmbedding
    (fun c : EuclideanSpace ℝ ι => signFailure ⟪vector v,c⟫ ⟪vector w,c⟫)

lemma sign_score_le {v w : ι → ℝ} (hv : ‖vector v‖=1) (hw : ‖vector w‖=1) :
    (∫ c, signFailure (score v c) (score w c) ∂Measure.pi (fun _ : ι => gaussianReal 0 1)) ≤ 2*‖vector v-vector w‖ := by
  rw [integral_score_sign]
  exact sign_inner_le hv hw

lemma signFailure_mul_right {r : ℝ} (hr : 0<r) (x y : ℝ) : signFailure x (r*y)=signFailure x y := by
  simp only [signFailure,mul_nonneg_iff_of_pos_left hr]

lemma signFailure_mul {r : ℝ} (hr : 0<r) (x y : ℝ) : signFailure (r*x) (r*y)=signFailure x y := by
  simp only [signFailure,mul_nonneg_iff_of_pos_left hr]

section Norm
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
lemma norm_unit (v : E) (hv : 0<‖v‖) : ‖(‖v‖⁻¹:ℝ) • v‖=1 := by
  rw [norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hv),inv_mul_cancel₀ hv.ne']

lemma distance_normalize {u v : E} (hu : ‖u‖=1) (hv : 0<‖v‖) :
    ‖u-(‖v‖⁻¹:ℝ) • v‖ ≤ 2*‖u-v‖ := by
  have he : v-(‖v‖⁻¹:ℝ) • v=(1-‖v‖⁻¹:ℝ) • v := by rw [sub_smul,one_smul]
  have hn : ‖v-(‖v‖⁻¹:ℝ) • v‖=|‖v‖-1| := by
    rw [he,norm_smul,Real.norm_eq_abs]
    calc
      |1-‖v‖⁻¹| *‖v‖ = |(1-‖v‖⁻¹)*‖v‖| := by rw [abs_mul,abs_of_nonneg (norm_nonneg v)]
      _ = |‖v‖-1| := by congr 1; field_simp

  have h := dist_triangle u v ((‖v‖⁻¹:ℝ) • v)
  simp only [dist_eq_norm] at h
  have hb := abs_norm_sub_norm_le v u
  rw [hu,norm_sub_rev v u] at hb
  rw [hn] at h
  linarith
end Norm

variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
    [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E]
lemma sign_inner_normalize_le {v w : E} (hv : ‖v‖=1) (hw : 0<‖w‖) :
    (∫ c : E, signFailure ⟪v,c⟫ ⟪w,c⟫ ∂stdGaussian E) ≤ 4*‖v-w‖ := by
  have h := sign_inner_le hv (norm_unit w hw)
  simp only [real_inner_smul_left,
    signFailure_mul_right (inv_pos.mpr hw)] at h
  exact h.trans (by have := distance_normalize hv hw; linarith)

lemma sign_inner_common_norm {v w : E} {s : ℝ} (hs : 0<s) (hv : ‖v‖=s) (hw : ‖w‖=s) :
    (∫ c : E, signFailure ⟪v,c⟫ ⟪w,c⟫ ∂stdGaussian E) ≤ 2/s*‖v-w‖ := by
  have hv1 : ‖s⁻¹ • v‖=1 := by simpa only [hv] using norm_unit v (by rw [hv]; exact hs)
  have hw1 : ‖s⁻¹ • w‖=1 := by simpa only [hw] using norm_unit w (by rw [hw]; exact hs)
  have h := sign_inner_le hv1 hw1
  simp only [real_inner_smul_left,signFailure_mul (inv_pos.mpr hs)] at h
  rw [← smul_sub,norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hs)] at h
  convert h using 1; ring
end MinUncut.GaussianBudget

open scoped BigOperators Topology
open MeasureTheory Set
namespace MinUncut.FiniteGaussian

def evenExp (r : ℕ) (u : ℝ) : ℝ := ∑ j ∈ Finset.range (2*r+1), (-u)^j/(j.factorial:ℝ)

def densityPolynomial (r : ℕ) (v : ℝ) : ℝ := evenExp r (v^2/2)

def error (r : ℕ) (U : ℝ) : ℝ := U^(2*r+1)/((2*r+1).factorial:ℝ)

lemma taylor_exp (n : ℕ) {x : ℝ} (hx : x ≠ 0) :
    taylorWithinEval Real.exp n (Set.uIcc 0 x) 0 x =
      ∑ j ∈ Finset.range (n+1), x^j/(j.factorial:ℝ) := by
  rw [taylor_within_apply]
  apply Finset.sum_congr rfl
  intro j _
  rw [iteratedDerivWithin_eq_iteratedDeriv (uniqueDiffOn_uIcc hx.symm)
    Real.contDiff_exp.contDiffAt (by simp)]
  simp [iteratedDeriv_eq_iterate,Real.iter_deriv_exp,div_eq_mul_inv,mul_comm]

lemma evenExp_error {u : ℝ} (hu : 0 ≤ u) (r : ℕ) :
    0 ≤ evenExp r u-Real.exp (-u) ∧
      evenExp r u-Real.exp (-u) ≤ error r u := by
  rcases hu.eq_or_lt with he|hu
  · subst u
    simp [evenExp,error,Finset.sum_range_succ']
  have hx : (0:ℝ) ≠ -u := by linarith
  obtain ⟨z,hz,he⟩ := taylor_mean_remainder_lagrange_iteratedDeriv (f := Real.exp) (n := 2*r)
    hx (Real.contDiff_exp.contDiffOn)
  rw [taylor_exp (2*r) hx.symm] at he
  simp only [iteratedDeriv_eq_iterate,Real.iter_deriv_exp,sub_zero] at he
  have hz0 : z < 0 := by
    have hh := hz
    rw [Set.uIoo_of_ge (by linarith : -u ≤ 0)] at hh
    exact hh.2
  have hpow : (-u)^(2*r+1) = -(u^(2*r+1)) := by
    rw [pow_succ,pow_mul,neg_sq,pow_succ]
    ring
  rw [hpow] at he
  have heq : evenExp r u-Real.exp (-u)=Real.exp z*error r u := by
    dsimp [evenExp,error,Finset.sum_range_succ']
    linear_combination -he
  rw [heq]
  have herror : 0 ≤ error r u := by unfold error; positivity
  exact ⟨mul_nonneg (Real.exp_nonneg _) herror,
    by simpa only [one_mul] using (mul_le_mul_of_nonneg_right
      (Real.exp_le_one_iff.mpr hz0.le) herror)⟩

lemma density_bounds {T v : ℝ} (hT : 0 ≤ T) (hv : |v| ≤ T) (r : ℕ) :
    0 ≤ densityPolynomial r v-Real.exp (-v^2/2) ∧
      densityPolynomial r v-Real.exp (-v^2/2) ≤ error r (T^2/2) := by
  have hu : 0 ≤ v^2/2 := by positivity
  have hb : v^2/2 ≤ T^2/2 := by
    have hh := (sq_le_sq₀ (abs_nonneg v) hT).mpr hv
    rw [sq_abs] at hh
    linarith
  obtain ⟨h0,h1⟩ := evenExp_error hu r
  have he : error r (v^2/2) ≤ error r (T^2/2) := by
    unfold error
    exact div_le_div_of_nonneg_right (pow_le_pow_left₀ hu hb _) (by positivity)
  simpa only [densityPolynomial,neg_div] using ⟨h0,h1.trans he⟩

lemma density_positive (r : ℕ) (v : ℝ) : 0 < densityPolynomial r v := by
  have h := (evenExp_error (by positivity : 0 ≤ v^2/2) r).1
  have := Real.exp_pos (-(v^2/2))
  dsimp [densityPolynomial]
  linarith

lemma exists_error {U ε : ℝ} (hε : 0 < ε) : ∃ r : ℕ, error r U < ε := by
  have h := FloorSemiring.tendsto_pow_div_factorial_atTop U
  obtain ⟨N,hN⟩ := Filter.eventually_atTop.mp (h.eventually_lt_const hε)
  refine ⟨N,?_⟩
  exact hN (2*N+1) (by omega)

open scoped BigOperators
open MeasureTheory

def coefficient (j : ℕ) : ℚ := (-1)^j/((2:ℚ)^j*j.factorial)
def primitive (r : ℕ) (v : ℚ) : ℚ :=
  ∑ j ∈ Finset.range (2*r+1), coefficient j*v^(2*j+1)/(2*j+1)
def qIntegral (r : ℕ) (a b : ℚ) : ℚ := primitive r b-primitive r a

lemma density_sum (r : ℕ) (v : ℝ) :
    densityPolynomial r v=∑ j ∈ Finset.range (2*r+1), (coefficient j:ℝ)*v^(2*j) := by
  unfold densityPolynomial evenExp
  apply Finset.sum_congr rfl
  intro j _
  unfold coefficient
  push_cast
  rw [neg_eq_neg_one_mul,mul_pow,div_pow,pow_mul]
  ring

lemma continuous_density (r : ℕ) : Continuous (densityPolynomial r) := by
  simp_rw [funext (density_sum r)]
  fun_prop

lemma qIntegral_cast (r : ℕ) (a b : ℚ) :
    (qIntegral r a b:ℝ)=∫ v in (a:ℝ)..(b:ℝ), densityPolynomial r v := by
  simp_rw [density_sum]
  rw [intervalIntegral.integral_finsetSum (f := fun (j : ℕ) (v : ℝ) => (coefficient j:ℝ)*v^(2*j))
    (fun j _ => (show Continuous (fun v : ℝ => (coefficient j:ℝ)*v^(2*j)) by fun_prop).intervalIntegrable _ _)]
  simp_rw [intervalIntegral.integral_const_mul,integral_pow]
  unfold qIntegral primitive
  push_cast
  rw [← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro j _
  ring

lemma qIntegral_pos (r : ℕ) {a b : ℚ} (hab : a < b) : 0 < qIntegral r a b := by
  apply (Rat.cast_pos (K := ℝ)).mp
  rw [qIntegral_cast]
  have hab' : (a:ℝ) < b := by exact_mod_cast hab
  exact intervalIntegral.integral_pos hab' (continuous_density r).continuousOn
    (fun v _ => (density_positive r v).le) ⟨a,⟨le_rfl,hab'.le⟩,density_positive r a⟩

def endpoint (T : ℚ) (L i : ℕ) : ℚ := -T+2*T*i/L
def midpoint (T : ℚ) (L i : ℕ) : ℚ := (endpoint T L i+endpoint T L (i+1))/2

def cellWeight (r : ℕ) (T : ℚ) (L : ℕ) (i : Fin L) : ℚ :=
  qIntegral r (endpoint T L i) (endpoint T L (i+1))/qIntegral r (-T) T

lemma endpoint_zero (T : ℚ) (L : ℕ) : endpoint T L 0 = -T := by simp [endpoint]
lemma endpoint_end (T : ℚ) {L : ℕ} (hL : 0 < L) : endpoint T L L=T := by
  have hh : (L:ℚ) ≠ 0 := by exact_mod_cast hL.ne'
  unfold endpoint
  field_simp
  ring

lemma endpoint_lt {T : ℚ} (hT : 0 < T) {L : ℕ} (hL : 0 < L) (i : ℕ) :
    endpoint T L i < endpoint T L (i+1) := by
  have hL' : (0:ℚ) < L := by exact_mod_cast hL
  unfold endpoint
  simp only [add_lt_add_iff_left,div_lt_div_iff_of_pos_right hL']
  push_cast
  nlinarith

lemma cellWeight_pos {T : ℚ} (hT : 0 < T) {L : ℕ} (hL : 0 < L) (r : ℕ) (i : Fin L) :
    0 < cellWeight r T L i := by
  exact div_pos (qIntegral_pos r (endpoint_lt hT hL i)) (qIntegral_pos r (by linarith))

lemma sum_cellWeight {T : ℚ} (hT : 0 < T) {L : ℕ} (hL : 0 < L) (r : ℕ) :
    ∑ i : Fin L, cellWeight r T L i=1 := by
  have hden : qIntegral r (-T) T ≠ 0 := (qIntegral_pos r (by linarith)).ne'
  unfold cellWeight
  rw [← Finset.sum_div]
  rw [Fin.sum_univ_eq_sum_range (fun i : ℕ => qIntegral r (endpoint T L i) (endpoint T L (i+1)))]
  have he : (∑ i ∈ Finset.range L, qIntegral r (endpoint T L i) (endpoint T L (i+1)))=
      qIntegral r (-T) T := by
    unfold qIntegral
    rw [Finset.sum_range_sub (fun i => primitive r (endpoint T L i)),endpoint_zero,endpoint_end T hL]
  rw [he,div_self hden]

open scoped BigOperators
open Set MeasureTheory
attribute [local instance] Classical.propDecidable

lemma endpoint_mono {T : ℚ} (hT : 0 ≤ T) {L i j : ℕ} (hij : i ≤ j) :
    endpoint T L i ≤ endpoint T L j := by
  unfold endpoint
  apply add_le_add_right
  apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _)
  exact mul_le_mul_of_nonneg_left (by exact_mod_cast hij) (by positivity)

def cell (T : ℚ) (L : ℕ) (i : Fin L) : Set ℝ :=
  Ioc (endpoint T L i) (endpoint T L (i+1))

lemma cell_subset {T : ℚ} (hT : 0 ≤ T) {L : ℕ} (hL : 0 < L) (i : Fin L) :
    cell T L i ⊆ Ioc (-(T:ℝ)) T := by
  apply Ioc_subset_Ioc
  · have hh := endpoint_mono hT (Nat.zero_le i.val) (L := L)
    rw [endpoint_zero] at hh
    exact_mod_cast hh
  · have hh := endpoint_mono hT (Nat.succ_le_of_lt i.isLt) (L := L)
    rw [endpoint_end T hL] at hh
    exact_mod_cast hh

lemma exists_cell {T : ℚ} {L : ℕ} (hL : 0 < L) {x : ℝ} (hx : x ∈ Ioc (-(T:ℝ)) T) :
    ∃ i : Fin L, x ∈ cell T L i := by
  have hh := Ioc_subset_biUnion_Ioc L (fun i => (endpoint T L i:ℝ))
  rw [endpoint_zero,endpoint_end T hL] at hh
  have hx' := hh (by simpa only [Rat.cast_neg] using hx)
  obtain ⟨i,hi,hx'⟩ := Set.mem_iUnion₂.mp hx'
  exact ⟨⟨i,Finset.mem_range.mp hi⟩,hx'⟩

lemma disjoint_cells {T : ℚ} (hT : 0 ≤ T) {L : ℕ} {i j : Fin L} (hij : i ≠ j) :
    Disjoint (cell T L i) (cell T L j) := by
  rcases lt_or_gt_of_ne hij with h|h
  · apply Set.Ioc_disjoint_Ioc_of_le
    exact_mod_cast endpoint_mono hT (show i.val+1 ≤ j.val by exact Nat.succ_le_of_lt h) (L := L)
  · apply Disjoint.symm
    apply Set.Ioc_disjoint_Ioc_of_le
    exact_mod_cast endpoint_mono hT (show j.val+1 ≤ i.val by exact Nat.succ_le_of_lt h) (L := L)

lemma midpoint_distance {T : ℚ} {L : ℕ} (i : Fin L) {x : ℝ} (hx : x ∈ cell T L i) :
    |x-(midpoint T L i:ℝ)| ≤ (T:ℝ)/L := by
  have he : (endpoint T L (i.val+1):ℝ)-(endpoint T L i.val:ℝ)=2*((T:ℝ)/L) := by
    unfold endpoint
    push_cast
    ring
  have hm : (midpoint T L i:ℝ)=((endpoint T L i:ℝ)+(endpoint T L (i.val+1):ℝ))/2 := by
    unfold midpoint
    push_cast
    rfl
  rw [hm]
  exact abs_le.mpr ⟨by linarith [hx.1],by linarith [hx.2]⟩

variable {ι : Type*} [Fintype ι]
def cube (T : ℚ) : Set (ι → ℝ) := Set.pi Set.univ (fun _ => Ioc (-(T:ℝ)) T)
def cubeCell (T : ℚ) (L : ℕ) (j : ι → Fin L) : Set (ι → ℝ) := Set.pi Set.univ (fun i => cell T L (j i))
def gridPoint (T : ℚ) (L : ℕ) (j : ι → Fin L) : ι → ℝ := fun i => midpoint T L (j i)

lemma cubeCell_measurable (T : ℚ) (L : ℕ) (j : ι → Fin L) : MeasurableSet (cubeCell T L j) :=
  MeasurableSet.pi (Set.to_countable _) (fun _ _ => measurableSet_Ioc)

lemma cube_measurable (T : ℚ) : MeasurableSet (cube (ι := ι) T) :=
  MeasurableSet.pi (Set.to_countable _) (fun _ _ => measurableSet_Ioc)

omit [Fintype ι] in
lemma cubeCell_subset {T : ℚ} (hT : 0 ≤ T) {L : ℕ} (hL : 0 < L) (j : ι → Fin L) :
    cubeCell T L j ⊆ cube T := by
  intro x hx i hi
  exact cell_subset hT hL (j i) (hx i hi)

omit [Fintype ι] in
lemma cube_union {T : ℚ} (hT : 0 ≤ T) {L : ℕ} (hL : 0 < L) :
    (⋃ j : ι → Fin L, cubeCell T L j)=cube T := by
  apply Set.Subset.antisymm
  · exact Set.iUnion_subset (cubeCell_subset hT hL)
  · intro x hx
    have hh : ∀ i : ι, ∃ j : Fin L, x i ∈ cell T L j := fun i => exists_cell hL (hx i (by simp))
    choose j hj using hh
    exact Set.mem_iUnion.mpr ⟨j,fun i _ => hj i⟩

omit [Fintype ι] in
lemma cubeCell_disjoint {T : ℚ} (hT : 0 ≤ T) {L : ℕ} {j k : ι → Fin L} (hjk : j ≠ k) :
    Disjoint (cubeCell T L j) (cubeCell T L k) := by
  obtain ⟨i,hi⟩ := Function.ne_iff.mp hjk
  apply Set.disjoint_left.mpr
  intro x hx hy
  exact Set.disjoint_left.mp (disjoint_cells hT hi) (hx i (by simp)) (hy i (by simp))

attribute [local instance] Classical.propDecidable
variable {ι : Type*} [Fintype ι]

def gridStep (T : ℚ) (L : ℕ) (F : (ι → Fin L) → ℝ) (x : ι → ℝ) : ℝ :=
  ∑ j, (cubeCell T L j).indicator (fun _ => F j) x

lemma gridStep_of_mem {T : ℚ} (hT : 0 ≤ T) {L : ℕ} (F : (ι → Fin L) → ℝ)
    {j : ι → Fin L} {x : ι → ℝ} (hx : x ∈ cubeCell T L j) :
    gridStep T L F x=F j := by
  unfold gridStep
  rw [Finset.sum_eq_single j]
  · exact Set.indicator_of_mem hx _
  · intro k _ hk
    exact Set.indicator_of_notMem (fun hkx =>
      Set.disjoint_left.mp (cubeCell_disjoint hT hk) hkx hx) _
  · simp

lemma gridStep_of_notMem {T : ℚ} (hT : 0 ≤ T) {L : ℕ} (hL : 0 < L)
    (F : (ι → Fin L) → ℝ) {x : ι → ℝ} (hx : x ∉ cube T) : gridStep T L F x=0 := by
  apply Finset.sum_eq_zero
  intro j _
  exact Set.indicator_of_notMem (fun hj => hx (cubeCell_subset hT hL j hj)) _

lemma gridStep_range {T : ℚ} (hT : 0 ≤ T) {L : ℕ} (hL : 0 < L)
    (F : (ι → Fin L) → ℝ) (hF : ∀ j, 0 ≤ F j ∧ F j ≤ 1) (x : ι → ℝ) :
    0 ≤ gridStep T L F x ∧ gridStep T L F x ≤ 1 := by
  by_cases hx : x ∈ cube T
  · rw [← cube_union hT hL] at hx
    obtain ⟨j,hj⟩ := Set.mem_iUnion.mp hx
    simpa only [gridStep_of_mem hT F hj] using hF j
  · rw [gridStep_of_notMem hT hL F hx]; norm_num

lemma gridStep_integrable {μ : Measure (ι → ℝ)} [IsFiniteMeasure μ]
    (T : ℚ) (L : ℕ) (F : (ι → Fin L) → ℝ) : Integrable (gridStep T L F) μ := by
  exact integrable_finsetSum _ (fun j _ => (integrable_const (F j)).indicator (cubeCell_measurable T L j))

lemma integral_gridStep {μ : Measure (ι → ℝ)} [IsFiniteMeasure μ]
    (T : ℚ) (L : ℕ) (F : (ι → Fin L) → ℝ) :
    (∫ x, gridStep T L F x ∂μ)=∑ j, μ.real (cubeCell T L j)*F j := by
  unfold gridStep
  rw [integral_finsetSum _ (fun j _ => (integrable_const (F j)).indicator (cubeCell_measurable T L j))]
  apply Finset.sum_congr rfl
  intro j _
  rw [integral_indicator (cubeCell_measurable T L j),setIntegral_const,smul_eq_mul]

lemma setIntegral_gridStep {μ : Measure (ι → ℝ)} [IsFiniteMeasure μ]
    {T : ℚ} (hT : 0 ≤ T) {L : ℕ} (hL : 0 < L) (F : (ι → Fin L) → ℝ) :
    (∫ x in cube T, gridStep T L F x ∂μ)=∑ j, μ.real (cubeCell T L j)*F j := by
  rw [setIntegral_eq_integral_of_forall_compl_eq_zero (fun x hx => gridStep_of_notMem hT hL F hx)]
  exact integral_gridStep T L F

open scoped BigOperators
open MeasureTheory ProbabilityTheory Set
attribute [local instance] Classical.propDecidable
variable {ι : Type*} [Fintype ι]

abbrev gaussianLaw (ι : Type*) [Fintype ι] : Measure (ι → ℝ) :=
  Measure.pi (fun _ : ι => gaussianReal 0 1)

lemma coordinate_sq_integrable (i : ι) : Integrable (fun x : ι → ℝ => x i^2) (gaussianLaw ι) := by
  have h := (memLp_id_gaussianReal' (μ := 0) (v := 1) 2 (by norm_num)).integrable_sq
  exact (measurePreserving_eval (fun _ : ι => gaussianReal 0 1) i).integrable_comp_of_integrable h

lemma coordinate_second_moment (i : ι) : (∫ x : ι → ℝ, x i^2 ∂gaussianLaw ι)=1 := by
  have hp := measurePreserving_eval (fun _ : ι => gaussianReal 0 1) i
  have h : (∫ x : ℝ, x^2 ∂gaussianReal 0 1)=1 := by
    have hh := variance_fun_id_gaussianReal (μ := 0) (v := 1)
    change Var[id; gaussianReal 0 1] = (1:ℝ) at hh
    rw [variance_eq_integral measurable_id.aemeasurable] at hh
    simpa only [id_eq,integral_id_gaussianReal,sub_zero,NNReal.coe_one] using hh
  rw [← hp.map_eq,integral_map hp.measurable.aemeasurable (by fun_prop)] at h
  exact h

lemma gaussian_cube_tail {T : ℚ} (hT : 0 < T) :
    (gaussianLaw ι).real (cube T)ᶜ ≤ (Fintype.card ι:ℝ)/(T:ℝ)^2 := by
  have hT' : (0:ℝ) < T := by exact_mod_cast hT
  let F : (ι → ℝ) → ℝ := (cube (ι := ι) T)ᶜ.indicator (fun _ => 1)
  have hi : Integrable F (gaussianLaw ι) := (integrable_const (1:ℝ)).indicator (cube_measurable T).compl
  have hacc : Integrable (fun x : ι → ℝ => (∑ i, x i^2)/(T:ℝ)^2) (gaussianLaw ι) :=
    (integrable_finsetSum _ (fun i _ => coordinate_sq_integrable i)).div_const _
  have hpoint (x : ι → ℝ) : F x ≤ (∑ i, x i^2)/(T:ℝ)^2 := by
    by_cases hx : x ∈ cube (ι := ι) T
    · simp only [F,Set.indicator_of_notMem (show x ∉ (cube T)ᶜ from fun hh => hh hx)]
      positivity
    · rw [show F x=1 by exact Set.indicator_of_mem hx _]
      apply (le_div_iff₀ (sq_pos_of_pos hT')).mpr
      obtain ⟨i,hi⟩ : ∃ i : ι, ¬ (-(T:ℝ)<x i ∧ x i ≤ T) := by
        simpa only [cube,Set.mem_pi,Set.mem_univ,true_implies,Set.mem_Ioc,not_forall] using hx
      have hs : (T:ℝ)^2 ≤ x i^2 := by
        rcases not_and_or.mp hi with h|h
        · have := le_of_not_gt h; nlinarith
        · have := lt_of_not_ge h; nlinarith
      have hb := Finset.single_le_sum (s := Finset.univ) (a := i) (fun j _ => sq_nonneg (x j)) (Finset.mem_univ i)
      simpa only [one_mul] using hs.trans hb
  have hh := integral_mono hi hacc hpoint
  have hleft : (∫ x, F x ∂gaussianLaw ι)=(gaussianLaw ι).real (cube T)ᶜ := by
    change (∫ x, (cube (ι := ι) T)ᶜ.indicator (fun _ => (1:ℝ)) x ∂gaussianLaw ι)=_
    rw [integral_indicator (cube_measurable T).compl,setIntegral_const,smul_eq_mul,mul_one]
  have hright : (∫ x : ι → ℝ, (∑ i, x i^2)/(T:ℝ)^2 ∂gaussianLaw ι)=(Fintype.card ι:ℝ)/(T:ℝ)^2 := by
    rw [integral_div,integral_finsetSum _ (fun i _ => coordinate_sq_integrable i)]
    simp only [coordinate_second_moment,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one]
  simpa only [hleft,hright] using hh

open scoped BigOperators RealInnerProductSpace NNReal
open MeasureTheory ProbabilityTheory Set
open GaussianBudget
attribute [local instance] Classical.propDecidable
variable {ι S : Type*} [Fintype ι] [Fintype S]

def thresholdBit (x : ℝ) : Bool := if 0 ≤ x then true else false

def thresholdTable (v : S → ι → ℝ) (x : ι → ℝ) : S → Bool :=
  fun s => thresholdBit (score (v s) x)

lemma thresholdBit_measurable : Measurable thresholdBit :=
  Measurable.ite (measurableSet_le measurable_const measurable_id) measurable_const measurable_const

omit [Fintype S] in
lemma thresholdTable_measurable (v : S → ι → ℝ) : Measurable (thresholdTable v) := by
  apply Measurable.of_eval
  intro s
  exact thresholdBit_measurable.comp (by unfold score; fun_prop)

lemma tableTest_integrable (v : S → ι → ℝ) (F : (S → Bool) → ℝ)
    (hF : ∀ t, 0 ≤ F t ∧ F t ≤ 1) :
    Integrable (fun x => F (thresholdTable v x)) (gaussianLaw ι) := by
  apply Integrable.of_bound ((measurable_of_countable F).comp (thresholdTable_measurable v)).aestronglyMeasurable 1
  filter_upwards [] with x
  simpa only [Function.comp_apply,Real.norm_eq_abs,abs_of_nonneg (hF _).1] using (hF (thresholdTable v x)).2

lemma score_law (v : ι → ℝ) : (gaussianLaw ι).map (score v)=
    gaussianReal 0 ⟨‖vector v‖^2,sq_nonneg _⟩ := by
  rw [← inner_law (vector v),← toLp_preserving.map_eq]
  rw [Measure.map_map (by fun_prop) toLp_preserving.measurable]
  congr 1
  ext x
  exact score_inner v x

lemma score_small_ball {v : ι → ℝ} (hv : 1 ≤ ‖vector v‖^2) {r : ℝ} (hr : 0 ≤ r) :
    (gaussianLaw ι).real {x | |score v x| ≤ r} ≤ 2*r := by
  have hh := small_ball (by exact_mod_cast hv : (1:ℝ≥0) ≤ ⟨‖vector v‖^2,sq_nonneg _⟩) hr
  rw [← score_law v,Measure.real,Measure.map_apply (by unfold score; fun_prop)
    (measurableSet_le (by fun_prop) measurable_const)] at hh
  exact hh

lemma score_grid_distance (v : ι → ℝ) {T : ℚ} {L : ℕ} {j : ι → Fin L}
    {x : ι → ℝ} (hx : x ∈ cubeCell T L j) :
    |score v x-score v (gridPoint T L j)| ≤ (∑ i, |v i|)*((T:ℝ)/L) := by
  unfold score
  rw [← Finset.sum_sub_distrib]
  calc
    _ ≤ ∑ i, |v i*x i-v i*gridPoint T L j i| := Finset.abs_sum_le_sum_abs _ _
    _ ≤ ∑ i, |v i| *((T:ℝ)/L) := by
      apply Finset.sum_le_sum
      intro i _
      rw [← mul_sub,abs_mul]
      exact mul_le_mul_of_nonneg_left (midpoint_distance (j i) (hx i (by simp))) (abs_nonneg _)
    _ = _ := (Finset.sum_mul _ _ _).symm

lemma threshold_change_small {a b r : ℝ} (hr : |a-b| ≤ r)
    (hab : thresholdBit a ≠ thresholdBit b) : |a| ≤ r := by
  unfold thresholdBit at hab
  split_ifs at hab with ha hb hb
  · exact False.elim (hab rfl)
  · rw [abs_of_nonneg ha] at ⊢
    have hh : b < 0 := lt_of_not_ge hb
    have := (abs_le.mp hr).2
    linarith
  · rw [abs_of_neg (lt_of_not_ge ha)]
    have := (abs_le.mp hr).1
    linarith
  · exact False.elim (hab rfl)

lemma tableTest_rounding_pointwise (v : S → ι → ℝ) {A : ℝ}
    (hA : ∀ s, (∑ i, |v s i|) ≤ A) {T : ℚ} (hT : 0 ≤ T) {L : ℕ} (hL : 0 < L)
    (F : (S → Bool) → ℝ) (hF : ∀ t, 0 ≤ F t ∧ F t ≤ 1)
    {x : ι → ℝ} (hx : x ∈ cube T) :
    |F (thresholdTable v x)-gridStep T L (fun j => F (thresholdTable v (gridPoint T L j))) x| ≤
      ∑ s, {x : ι → ℝ | |score (v s) x| ≤ A*((T:ℝ)/L)}.indicator (fun _ => (1:ℝ)) x := by
  rw [← cube_union hT hL] at hx
  obtain ⟨j,hj⟩ := Set.mem_iUnion.mp hx
  rw [gridStep_of_mem hT _ hj]
  by_cases he : thresholdTable v x=thresholdTable v (gridPoint T L j)
  · rw [he,sub_self,abs_zero]
    exact Finset.sum_nonneg (fun s _ => Set.indicator_nonneg (fun _ _ => by norm_num) x)
  · obtain ⟨s,hs⟩ := Function.ne_iff.mp he
    have hdist : |score (v s) x-score (v s) (gridPoint T L j)| ≤ A*((T:ℝ)/L) :=
      (score_grid_distance (v s) hj).trans (mul_le_mul_of_nonneg_right (hA s) (by positivity))
    have hb := threshold_change_small hdist hs
    have hone : {x : ι → ℝ | |score (v s) x| ≤ A*((T:ℝ)/L)}.indicator (fun _ => (1:ℝ)) x=1 :=
      Set.indicator_of_mem (show x ∈ {x : ι → ℝ | |score (v s) x| ≤ A*((T:ℝ)/L)} from hb) _
    have hsum := Finset.single_le_sum (s := Finset.univ) (a := s)
      (f := fun s => {x : ι → ℝ | |score (v s) x| ≤ A*((T:ℝ)/L)}.indicator (fun _ => (1:ℝ)) x)
      (fun _ _ => Set.indicator_nonneg (fun _ _ => by norm_num) x) (Finset.mem_univ s)
    rw [hone] at hsum
    exact (abs_le.mpr ⟨by linarith [(hF (thresholdTable v x)).1,(hF (thresholdTable v (gridPoint T L j))).2],
      by linarith [(hF (thresholdTable v x)).2,(hF (thresholdTable v (gridPoint T L j))).1]⟩).trans hsum

end MinUncut.FiniteGaussian

end

end OAI