import Mathlib
import OAI.Computability.MinUncut.Model

namespace OAI

noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Filter
open scoped Topology NNReal
open scoped BigOperators
open MeasureTheory ProbabilityTheory Polynomial Filter
open scoped BigOperators Topology
namespace MinUncut.GaussianHermite
abbrev γ : Measure ℝ := gaussianReal 0 1

def he (n : ℕ) (x : ℝ) : ℝ := aeval x (hermite n)

lemma integrable_poly (p : ℝ[X]) : Integrable (fun x => p.eval x) γ := by
  induction p using Polynomial.induction_on' with
  | add p q hp hq =>
    simpa only [eval_add] using hp.fun_add hq
  | monomial n a =>
    have hn : Integrable (fun x : ℝ => x^n) γ :=
      integrable_pow_of_mem_interior_integrableExpSet (by simp [γ]) n
    simpa only [eval_monomial] using hn.const_mul a

lemma integrable_poly_density (p : ℝ[X]) :
    Integrable (fun x => p.eval x * gaussianPDFReal 0 1 x) := by
  induction p using Polynomial.induction_on' with
  | add p q hp hq =>
    simpa only [eval_add, add_mul] using hp.fun_add hq
  | monomial n a =>
    have hn := integrable_rpow_mul_exp_neg_mul_sq (by norm_num : (0:ℝ) < 1/2)
      (by exact lt_of_lt_of_le (by norm_num) (Nat.cast_nonneg n) : (-1:ℝ) < (n:ℝ))
    have heq : (fun x : ℝ => (monomial n a).eval x * gaussianPDFReal 0 1 x) =
      fun x : ℝ => (a * (Real.sqrt (2 * Real.pi))⁻¹) *
        (x^(n:ℝ) * Real.exp (-(1/2) * x^2)) := by
      funext x
      simp only [eval_monomial, gaussianPDFReal, NNReal.coe_one, mul_one, sub_zero,
        Real.rpow_natCast]
      rw [show -x^2 / (2:ℝ) = -(1/2) * x^2 by ring]
      ring
    rw [heq]
    exact hn.const_mul _

lemma density_derivative (x : ℝ) :
    HasDerivAt (gaussianPDFReal 0 1) (-x * gaussianPDFReal 0 1 x) x := by
  have h : HasDerivAt (fun x : ℝ => Real.exp (-(x^2/2)))
      (-x * Real.exp (-(x^2/2))) x := by
    convert (((hasDerivAt_id x).pow 2).div_const 2).neg.exp using 1 <;>
      simp only [id_eq, Pi.pow_apply, Pi.neg_apply]
    ring
  have heq : gaussianPDFReal 0 1 = fun x : ℝ =>
      (Real.sqrt (2 * Real.pi))⁻¹ * Real.exp (-(x^2/2)) := by
    funext x
    simp only [gaussianPDFReal, NNReal.coe_one, mul_one, sub_zero, neg_div]
  rw [heq]
  apply (h.const_mul ((Real.sqrt (2 * Real.pi))⁻¹)).congr_deriv
  ring

lemma stein_poly (p : ℝ[X]) :
    (∫ x, x * p.eval x ∂γ) = ∫ x, p.derivative.eval x ∂γ := by
  have hi := integral_mul_deriv_eq_deriv_mul_of_integrable
    (u := fun x => p.eval x) (v := gaussianPDFReal 0 1)
    (u' := fun x => p.derivative.eval x) (v' := fun x => -x * gaussianPDFReal 0 1 x)
    (fun x _ => p.hasDerivAt x) (fun x _ => density_derivative x)
    (by convert (integrable_poly_density (-(X*p))) using 1
        funext x; simp only [Pi.mul_apply, eval_neg, eval_mul, eval_X]; ring)
    (integrable_poly_density p.derivative)
    (integrable_poly_density p)
  have hleft : (∫ x, p.eval x * (-x * gaussianPDFReal 0 1 x)) =
      -(∫ x, x * p.eval x ∂γ) := by
    rw [integral_gaussianReal_eq_integral_smul (by norm_num : (1:NNReal) ≠ 0), ← integral_neg]
    congr 1
    funext x
    simp only [smul_eq_mul]
    ring
  rw [hleft] at hi
  rw [integral_gaussianReal_eq_integral_smul (f := fun x => p.derivative.eval x)
    (by norm_num : (1:NNReal) ≠ 0)]
  simp only [smul_eq_mul]
  have hr : (∫ x, p.derivative.eval x * gaussianPDFReal 0 1 x) =
      ∫ x, gaussianPDFReal 0 1 x * p.derivative.eval x := by
    congr 1; funext x; ring
  rw [hr] at hi
  linarith

def hePoly (n : ℕ) : ℝ[X] := (hermite n).map (Int.castRingHom ℝ)

@[simp] lemma hePoly_eval (n : ℕ) (x : ℝ) : (hePoly n).eval x = he n x := by
  simp [hePoly, he, aeval_def, eval_map]

@[simp] lemma hePoly_zero : hePoly 0 = 1 := by simp [hePoly]

lemma hePoly_succ (n : ℕ) : hePoly (n+1) = X * hePoly n - (hePoly n).derivative := by
  simp [hePoly, derivative_map]

lemma derivative_hePoly (n : ℕ) : (hePoly (n+1)).derivative = (n+1 : ℝ) • hePoly n := by
  induction n with
  | zero => simp [hePoly_succ]
  | succ n ih =>
    rw [hePoly_succ (n+1), derivative_sub, derivative_mul, derivative_X, one_mul, ih,
      derivative_smul, hePoly_succ n]
    simp only [Nat.cast_add, Nat.cast_one, smul_eq_C_mul, map_add, map_one]
    ring

lemma hePoly_adjoint (n : ℕ) (p : ℝ[X]) :
    (∫ x, he (n+1) x * p.eval x ∂γ) = ∫ x, he n x * p.derivative.eval x ∂γ := by
  have hi := stein_poly (hePoly n * p)
  have ha : Integrable (fun x => (hePoly n).derivative.eval x * p.eval x) γ := by
    simpa using integrable_poly ((hePoly n).derivative * p)
  have hb : Integrable (fun x => (hePoly n).eval x * p.derivative.eval x) γ := by
    simpa using integrable_poly (hePoly n * p.derivative)
  have hc : Integrable (fun x => x * (hePoly n).eval x * p.eval x) γ := by
    convert integrable_poly (X * hePoly n * p) using 1
    funext x; simp only [eval_mul, eval_X]
  simp only [eval_mul, derivative_mul, eval_add] at hi
  rw [integral_add ha hb] at hi
  have heq : (fun x => he (n+1) x * p.eval x) = fun x =>
      x * (hePoly n).eval x * p.eval x - (hePoly n).derivative.eval x * p.eval x := by
    funext x
    rw [← hePoly_eval, hePoly_succ]
    simp [sub_mul]
  rw [heq, integral_sub hc ha]
  simp only [hePoly_eval] at *
  simp only [mul_assoc] at *
  linarith

@[simp] lemma he_zero (x : ℝ) : he 0 x = 1 := by simp [he]

lemma he_mean_succ (n : ℕ) : (∫ x, he (n+1) x ∂γ) = 0 := by
  simpa using hePoly_adjoint n 1

lemma he_product (n m : ℕ) :
    (∫ x, he n x * he m x ∂γ) = if n = m then (n.factorial : ℝ) else 0 := by
  induction n generalizing m with
  | zero =>
    cases m with
    | zero => simp [γ]
    | succ m => simp [he_mean_succ]
  | succ n ih =>
    cases m with
    | zero => simp [he_mean_succ]
    | succ m =>
      have h := hePoly_adjoint n (hePoly (m+1))
      rw [derivative_hePoly] at h
      simp only [hePoly_eval, eval_smul, smul_eq_mul] at h
      rw [show (fun x => he n x * ((m+1:ℝ) * he m x)) =
        fun x => (m+1:ℝ) * (he n x * he m x) by funext x; ring,
        integral_const_mul, ih] at h
      rw [h]
      by_cases hnm : n = m
      · subst m; simp [Nat.factorial_succ]
      · simp [hnm]

lemma measure_eq_of_moments {μ ν : Measure ℝ} [IsFiniteMeasure μ] [IsFiniteMeasure ν]
    (hμ : integrableExpSet id μ = Set.univ) (hν : integrableExpSet id ν = Set.univ)
    (hm : ∀ n : ℕ, (∫ x, x^n ∂μ) = ∫ x, x^n ∂ν) : μ = ν := by
  have haμ : AnalyticOnNhd ℂ (complexMGF id μ) Set.univ := by
    intro z _
    exact analyticAt_complexMGF (by simp [hμ])
  have haν : AnalyticOnNhd ℂ (complexMGF id ν) Set.univ := by
    intro z _
    exact analyticAt_complexMGF (by simp [hν])
  let d := fun z => complexMGF id μ z - complexMGF id ν z
  have hd : AnalyticAt ℂ d 0 := (haμ 0 (Set.mem_univ _)).sub (haν 0 (Set.mem_univ _))
  have hdn (n : ℕ) : iteratedDeriv n d 0 = 0 := by
    rw [show d = fun z => complexMGF id μ z - complexMGF id ν z from rfl,
      iteratedDeriv_fun_sub (haμ 0 (Set.mem_univ _)).contDiffAt
        (haν 0 (Set.mem_univ _)).contDiffAt,
      iteratedDeriv_complexMGF (by simp [hμ]), iteratedDeriv_complexMGF (by simp [hν])]
    simp only [zero_mul, Complex.exp_zero, mul_one, id_eq]
    rw [show (fun x : ℝ => (x:ℂ)^n) = fun x : ℝ => ((x^n:ℝ):ℂ) by ext x; simp,
      integral_complex_ofReal, integral_complex_ofReal, hm n]
    simp
  have ht : analyticOrderAt d (0:ℂ) = ⊤ := by
    rw [ENat.eq_top_iff_forall_ge]
    intro n
    exact (natCast_le_analyticOrderAt_iff_iteratedDeriv_eq_zero hd).mpr (fun i _ => hdn i)
  have he : complexMGF id μ =ᶠ[𝓝 (0:ℂ)] complexMGF id ν := by
    filter_upwards [analyticOrderAt_eq_top.mp ht] with z hz
    exact sub_eq_zero.mp hz
  apply Measure.ext_of_complexMGF_id_eq
  funext z
  exact haμ.eqOn_of_preconnected_of_eventuallyEq haν isPreconnected_univ (Set.mem_univ 0) he
    (Set.mem_univ z)

lemma memLp_poly (p : ℝ[X]) : MemLp (fun x => p.eval x) 2 γ := by
  apply (memLp_two_iff_integrable_sq (p.continuous.aestronglyMeasurable)).mpr
  convert integrable_poly (p^2) using 1
  funext x
  rw [Polynomial.eval_pow]

lemma memLp_exp (t : ℝ) : MemLp (fun x => Real.exp (t*x)) 2 γ := by
  apply (memLp_two_iff_integrable_sq (by fun_prop)).mpr
  convert integrable_exp_mul_gaussianReal (μ := 0) (v := 1) (2*t) using 1
  funext x
  rw [← Real.exp_nat_mul]
  congr 1
  ring

lemma memLp_positivePart {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    {f : Ω → ℝ} (hf : MemLp f 2 μ) :
    MemLp (fun x => max (f x) 0) 2 μ := by
  apply hf.mono ((hf.aestronglyMeasurable.aemeasurable.max aemeasurable_const).aestronglyMeasurable)
  filter_upwards [] with x
  simp only [Real.norm_eq_abs, abs_of_nonneg (le_max_right (f x) (0:ℝ))]
  exact max_le (le_abs_self _) (abs_nonneg _)

lemma weighted_finite {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    [IsFiniteMeasure μ] {w : Ω → ℝ} (hw : MemLp w 2 μ) :
    IsFiniteMeasure (μ.withDensity (fun x => ENNReal.ofReal (w x))) :=
  isFiniteMeasure_withDensity (hw.integrable (by norm_num)).lintegral_lt_top.ne

lemma weighted_expSet {w : ℝ → ℝ} (hw : MemLp w 2 γ) (hwn : ∀ x, 0 ≤ w x) :
    integrableExpSet id (γ.withDensity (fun x => ENNReal.ofReal (w x))) = Set.univ := by
  apply Set.eq_univ_of_forall
  intro t
  show Integrable (fun x => Real.exp (t*x)) _
  rw [integrable_withDensity_iff_integrable_smul₀'
    hw.aestronglyMeasurable.aemeasurable.ennreal_ofReal (by simp)]
  simpa only [ENNReal.toReal_ofReal (hwn _), smul_eq_mul, Pi.mul_def] using
    hw.integrable_mul (memLp_exp t)

lemma integral_weighted {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    {w : Ω → ℝ} (hw : MemLp w 2 μ) (hwn : ∀ x, 0 ≤ w x)
    (q : Ω → ℝ) :
    (∫ x, q x ∂μ.withDensity (fun x => ENNReal.ofReal (w x))) = ∫ x, w x * q x ∂μ := by
  rw [integral_withDensity_eq_integral_toReal_smul₀
    hw.aestronglyMeasurable.aemeasurable.ennreal_ofReal (by simp)]
  simp only [ENNReal.toReal_ofReal (hwn _), smul_eq_mul]

lemma ae_zero_of_integral_poly_eq_zero {f : ℝ → ℝ} (hf : MemLp f 2 γ)
    (horth : ∀ p : ℝ[X], (∫ x, f x * p.eval x ∂γ) = 0) : f =ᵐ[γ] 0 := by
  let p := fun x => max (f x) 0
  let n := fun x => max (-f x) 0
  have hp : MemLp p 2 γ := memLp_positivePart hf
  have hn : MemLp n 2 γ := memLp_positivePart hf.neg
  have hpn : ∀ x, 0 ≤ p x := fun x => le_max_right _ _
  have hnn : ∀ x, 0 ≤ n x := fun x => le_max_right _ _
  let μ := γ.withDensity (fun x => ENNReal.ofReal (p x))
  let ν := γ.withDensity (fun x => ENNReal.ofReal (n x))
  let : IsFiniteMeasure μ := weighted_finite hp
  let : IsFiniteMeasure ν := weighted_finite hn
  have hμν : μ = ν := by
    apply measure_eq_of_moments (weighted_expSet hp hpn) (weighted_expSet hn hnn)
    intro k
    rw [integral_weighted hp hpn, integral_weighted hn hnn]
    have hi := horth (X^k)
    have hk := memLp_poly (X^k)
    simp only [eval_pow, eval_X] at hi hk
    have heq : (fun x => f x * x^k) = fun x => p x * x^k - n x * x^k := by
      funext x
      dsimp [p,n]
      rw [← sub_mul, max_zero_sub_max_neg_zero_eq_self]
    have hip : Integrable (fun x => p x * x^k) γ := by simpa only [Pi.mul_def] using hp.integrable_mul hk
    have hin : Integrable (fun x => n x * x^k) γ := by simpa only [Pi.mul_def] using hn.integrable_mul hk
    rw [heq, integral_sub hip hin] at hi
    exact sub_eq_zero.mp hi
  have hae := (withDensity_eq_iff_of_sigmaFinite
    hp.aestronglyMeasurable.aemeasurable.ennreal_ofReal
    hn.aestronglyMeasurable.aemeasurable.ennreal_ofReal).mp hμν
  filter_upwards [hae] with x hx
  have heq := congrArg ENNReal.toReal hx
  rw [ENNReal.toReal_ofReal (hpn x), ENNReal.toReal_ofReal (hnn x)] at heq
  have hd : p x - n x = f x := by dsimp [p,n]; exact max_zero_sub_max_neg_zero_eq_self _
  change f x = 0
  linarith

def heSequence : Polynomial.Sequence ℝ where
  elems' := hePoly
  degree_eq' n := by
    rw [hePoly, (hermite_monic n).degree_map, degree_hermite]

lemma heSequence_span : Submodule.span ℝ (Set.range hePoly) = ⊤ := by
  apply heSequence.span
  intro n
  change IsUnit (hePoly n).leadingCoeff
  rw [show (hePoly n).leadingCoeff = 1 from ((hermite_monic n).map _).leadingCoeff]
  exact isUnit_one

lemma ae_zero_of_integral_he_eq_zero {f : ℝ → ℝ} (hf : MemLp f 2 γ)
    (horth : ∀ n, (∫ x, f x * he n x ∂γ) = 0) : f =ᵐ[γ] 0 := by
  apply ae_zero_of_integral_poly_eq_zero hf
  intro p
  have hp : p ∈ Submodule.span ℝ (Set.range hePoly) := by rw [heSequence_span]; trivial
  induction hp using Submodule.span_induction with
  | mem p hp =>
    obtain ⟨n,rfl⟩ := hp
    simpa only [hePoly_eval] using horth n
  | zero => simp
  | add p q hp hq ihp ihq =>
    have hi (q : ℝ[X]) : Integrable (fun x => f x * q.eval x) γ := by
      simpa only [Pi.mul_def] using hf.integrable_mul (memLp_poly q)
    simp only [eval_add, mul_add, integral_add (hi p) (hi q), ihp, ihq, add_zero]
  | smul a p hp ih =>
    simp only [eval_smul, smul_eq_mul]
    rw [show (fun x => f x * (a * p.eval x)) = fun x => a * (f x * p.eval x) by
      funext x; ring, integral_const_mul, ih, mul_zero]

def H (n : ℕ) (x : ℝ) : ℝ := he n x / Real.sqrt (n.factorial : ℝ)

lemma sqrt_factorial_pos (n : ℕ) : 0 < Real.sqrt (n.factorial : ℝ) := by
  positivity

lemma memLp_H (n : ℕ) : MemLp (H n) 2 γ := by
  change MemLp (fun x => he n x / Real.sqrt (n.factorial : ℝ)) 2 γ
  simpa only [ div_eq_mul_inv, hePoly_eval] using (memLp_poly (hePoly n)).mul_const
    (Real.sqrt (n.factorial : ℝ))⁻¹

lemma H_product (n m : ℕ) :
    (∫ x, H n x * H m x ∂γ) = if n = m then 1 else 0 := by
  simp only [H, div_mul_div_comm]
  rw [integral_div, he_product]
  split_ifs with h
  · subst m
    rw [Real.mul_self_sqrt (Nat.cast_nonneg _)]
    exact div_self (by positivity)
  · exact zero_div _

lemma integral_inner_toLp {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
    {f g : Ω → ℝ} (hf : MemLp f 2 μ) (hg : MemLp g 2 μ) :
    inner ℝ (hf.toLp f) (hg.toLp g) = ∫ ω, f ω * g ω ∂μ := by
  rw [L2.inner_def]
  apply integral_congr_ae
  filter_upwards [hf.coeFn_toLp, hg.coeFn_toLp] with ω hfω hgω
  simp only [hfω, hgω, RCLike.inner_apply, conj_trivial, mul_comm]

def Hvec (n : ℕ) : Lp ℝ 2 γ := (memLp_H n).toLp (H n)

lemma Hvec_orthonormal : Orthonormal ℝ Hvec := by
  rw [orthonormal_iff_ite]
  intro n m
  simpa only [Hvec, integral_inner_toLp] using H_product n m

lemma eq_zero_of_inner_Hvec_eq_zero (f : Lp ℝ 2 γ)
    (h : ∀ n, inner ℝ f (Hvec n) = 0) : f = 0 := by
  have hae : (f : ℝ → ℝ) =ᵐ[γ] 0 := by
    apply ae_zero_of_integral_he_eq_zero (Lp.memLp f)
    intro n
    have hi := h n
    rw [L2.inner_def] at hi
    have hieq : (∫ x, inner ℝ (f x) ((Hvec n) x) ∂γ) =
        (∫ x, f x * he n x ∂γ) / Real.sqrt (n.factorial : ℝ) := by
      rw [← integral_div]
      apply integral_congr_ae
      filter_upwards [(memLp_H n).coeFn_toLp] with x hx
      simp only [Hvec] at *
      rw [hx]
      simp [H, mul_div_assoc, mul_comm]
    rw [hieq] at hi
    exact (div_eq_zero_iff).mp hi |>.resolve_right (ne_of_gt (sqrt_factorial_pos n))
  apply Lp.ext
  exact hae.trans (Lp.coeFn_zero ℝ 2 γ).symm

def hermiteBasis : HilbertBasis ℕ ℝ (Lp ℝ 2 γ) :=
  HilbertBasis.mkOfOrthogonalEqBot Hvec_orthonormal (by
    apply eq_bot_iff.mpr
    intro f hf
    change f = 0
    apply eq_zero_of_inner_Hvec_eq_zero f
    intro n
    exact (Submodule.mem_orthogonal' _ f).mp hf _
      (Submodule.subset_span (Set.mem_range_self n)))

section Product
variable {ι : Type*} [Fintype ι]
abbrev γpi (ι : Type*) [Fintype ι] : Measure (ι → ℝ) := Measure.pi (fun _ => γ)

lemma memLp_polyProd (p : ι → ℝ[X]) :
    MemLp (fun x : ι → ℝ => ∏ i, (p i).eval (x i)) 2 (γpi ι) := by
  apply (memLp_two_iff_integrable_sq
    (continuous_finsetProd _ (fun i _ => (p i).continuous.comp (continuous_apply i))).aestronglyMeasurable).mpr
  simpa only [Finset.prod_pow, Function.comp_def] using Integrable.fintype_prod
    (fun i => (memLp_two_iff_integrable_sq (by fun_prop)).mp (memLp_poly (p i)))

def polyProdMap : MultilinearMap ℝ (fun _ : ι => ℝ[X]) ((ι → ℝ) → ℝ) :=
  (MultilinearMap.mkPiAlgebra ℝ ι ((ι → ℝ) → ℝ)).compLinearMap (fun i =>
    { toFun := fun p x => p.eval (x i)
      map_add' := by intros; ext x; simp
      map_smul' := by intros; ext x; simp })

lemma polyProdMap_apply (p : ι → ℝ[X]) (x : ι → ℝ) :
    polyProdMap p x = ∏ i, (p i).eval (x i) := by
  simp [polyProdMap, MultilinearMap.mkPiAlgebra_apply]

def orthPolyMap {f : (ι → ℝ) → ℝ} (hf : MemLp f 2 (γpi ι)) :
    MultilinearMap ℝ (fun _ : ι => ℝ[X]) ℝ where
  toFun p := ∫ x, f x * polyProdMap p x ∂γpi ι
  map_update_add' p i a b := by
    rw [polyProdMap.map_update_add]
    simp only [Pi.add_apply, mul_add]
    apply integral_add <;>
      simpa only [polyProdMap_apply, Pi.mul_def] using hf.integrable_mul (memLp_polyProd _)
  map_update_smul' p i a b := by
    rw [polyProdMap.map_update_smul]
    simp only [Pi.smul_apply, smul_eq_mul]
    rw [show (fun x => f x * (a * polyProdMap (Function.update p i b) x)) =
      fun x => a * (f x * polyProdMap (Function.update p i b) x) by funext x; ring]
    exact integral_const_mul _ _

lemma heLeadingUnit (n : ℕ) : IsUnit (heSequence n).leadingCoeff := by
  change IsUnit (hePoly n).leadingCoeff
  rw [show (hePoly n).leadingCoeff = 1 from ((hermite_monic n).map _).leadingCoeff]
  exact isUnit_one

lemma ortho_polyProd_of_heProd {f : (ι → ℝ) → ℝ} (hf : MemLp f 2 (γpi ι))
    (h : ∀ a : ι → ℕ, (∫ x, f x * ∏ i, he (a i) (x i) ∂γpi ι) = 0)
    (p : ι → ℝ[X]) : (∫ x, f x * ∏ i, (p i).eval (x i) ∂γpi ι) = 0 := by
  have heq : orthPolyMap hf = 0 := by
    apply Module.Basis.ext_multilinear (fun _ => heSequence.basis heLeadingUnit)
    intro a
    simpa only [orthPolyMap, MultilinearMap.coe_mk, polyProdMap_apply,
      Sequence.basis_eq_self, show (fun i => heSequence (a i)) = fun i => hePoly (a i) from rfl,
      hePoly_eval, zero_apply] using h a
  simpa only [orthPolyMap, MultilinearMap.coe_mk, polyProdMap_apply, zero_apply] using
    congrArg (fun q => q p) heq

lemma memLp_exp_linear (L : (ι → ℝ) →L[ℝ] ℝ) (t : ℝ) :
    MemLp (fun x => Real.exp (t * L x)) 2 (γpi ι) := by
  classical
  have heq (x : ι → ℝ) : Real.exp (t * L x) =
      ∏ i, Real.exp ((t * L (Pi.single i 1)) * x i) := by
    rw [← Real.exp_sum]
    congr 1
    rw [← ContinuousLinearMap.sum_comp_single ℝ (fun _ : ι => ℝ) L x, Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro i _
    rw [ContinuousLinearMap.comp_apply, ContinuousLinearMap.single_apply]
    rw [show Pi.single i (x i) = x i • Pi.single i (1:ℝ) by
      simpa only [smul_eq_mul, mul_one] using (Pi.single_smul (f := fun _ : ι => ℝ) i (x i) (1:ℝ))]
    simp [mul_comm, mul_left_comm]
  apply (memLp_two_iff_integrable_sq (by fun_prop)).mpr
  simp_rw [heq, ← Finset.prod_pow]
  exact Integrable.fintype_prod (fun i =>
    (memLp_two_iff_integrable_sq (by fun_prop)).mp (memLp_exp (t * L (Pi.single i 1))))

lemma memLp_mvpoly (p : MvPolynomial ι ℝ) :
    MemLp (fun x => MvPolynomial.eval x p) 2 (γpi ι) := by
  induction p using MvPolynomial.induction_on' with
  | add p q hp hq => simpa only [MvPolynomial.eval_add, Pi.add_def] using hp.add hq
  | monomial m a =>
    simpa only [MvPolynomial.eval_monomial, Finsupp.prod_fintype _ _ (fun _ => pow_zero _),
      Polynomial.eval_pow, Polynomial.eval_X] using
      (memLp_polyProd (fun i : ι => (X : ℝ[X])^(m i))).const_mul a

lemma ortho_mvpoly_of_polyProd {f : (ι → ℝ) → ℝ} (hf : MemLp f 2 (γpi ι))
    (h : ∀ p : ι → ℝ[X], (∫ x, f x * ∏ i, (p i).eval (x i) ∂γpi ι) = 0)
    (p : MvPolynomial ι ℝ) : (∫ x, f x * MvPolynomial.eval x p ∂γpi ι) = 0 := by
  have hi (p : MvPolynomial ι ℝ) : Integrable (fun x => f x * MvPolynomial.eval x p) (γpi ι) := by
    simpa only [Pi.mul_def] using hf.integrable_mul (memLp_mvpoly p)
  induction p using MvPolynomial.induction_on' with
  | add p q hp hq => rw [show (fun x => f x * MvPolynomial.eval x (p+q)) =
        fun x => f x * MvPolynomial.eval x p + f x * MvPolynomial.eval x q by
          funext x; simp [mul_add], integral_add (hi p) (hi q), hp, hq, add_zero]
  | monomial m a =>
    simp only [MvPolynomial.eval_monomial, Finsupp.prod_fintype _ _ (fun _ => pow_zero _)]
    rw [show (fun x => f x * (a * ∏ i, x i ^ m i)) =
        fun x => a * (f x * ∏ i, x i ^ m i) by funext x; ring, integral_const_mul]
    have hh := h (fun i => (X : ℝ[X]) ^ m i)
    simp only [Polynomial.eval_pow, Polynomial.eval_X] at hh
    rw [hh, mul_zero]

def linearPoly [DecidableEq ι] (L : (ι → ℝ) →L[ℝ] ℝ) : MvPolynomial ι ℝ :=
  ∑ i, MvPolynomial.C (L (Pi.single i 1)) * MvPolynomial.X i

lemma eval_linearPoly [DecidableEq ι] (L : (ι → ℝ) →L[ℝ] ℝ) (x : ι → ℝ) :
    MvPolynomial.eval x (linearPoly L) = L x := by
  simp only [linearPoly, map_sum, map_mul, MvPolynomial.eval_C, MvPolynomial.eval_X]
  rw [← ContinuousLinearMap.sum_comp_single ℝ (fun _ : ι => ℝ) L x]
  apply Finset.sum_congr rfl
  intro i _
  simp only [ContinuousLinearMap.comp_apply, ContinuousLinearMap.single_apply]
  rw [show Pi.single i (x i) = x i • Pi.single i (1:ℝ) by
      simpa only [smul_eq_mul, mul_one] using (Pi.single_smul (f := fun _ : ι => ℝ) i (x i) (1:ℝ))]
  simp [mul_comm]

lemma weighted_linear_expSet {w : (ι → ℝ) → ℝ} (hw : MemLp w 2 (γpi ι))
    (hwn : ∀ x, 0 ≤ w x) (L : (ι → ℝ) →L[ℝ] ℝ) :
    integrableExpSet id ((γpi ι).withDensity (fun x => ENNReal.ofReal (w x)) |>.map L) =
      Set.univ := by
  apply Set.eq_univ_of_forall
  intro t
  show Integrable (fun x => Real.exp (t*x)) _
  rw [integrable_map_measure (by fun_prop) (by fun_prop)]
  rw [integrable_withDensity_iff_integrable_smul₀'
    hw.aestronglyMeasurable.aemeasurable.ennreal_ofReal (by simp)]
  simpa only [Function.comp_def, ENNReal.toReal_ofReal (hwn _), smul_eq_mul, Pi.mul_def] using
    hw.integrable_mul (memLp_exp_linear L t)

lemma ae_zero_of_integral_mvpoly_eq_zero {f : (ι → ℝ) → ℝ} (hf : MemLp f 2 (γpi ι))
    (horth : ∀ p : MvPolynomial ι ℝ, (∫ x, f x * MvPolynomial.eval x p ∂γpi ι) = 0) :
    f =ᵐ[γpi ι] 0 := by
  classical
  let p := fun x => max (f x) 0
  let n := fun x => max (-f x) 0
  have hp : MemLp p 2 (γpi ι) := memLp_positivePart hf
  have hn : MemLp n 2 (γpi ι) := memLp_positivePart hf.neg
  have hpn : ∀ x, 0 ≤ p x := fun x => le_max_right _ _
  have hnn : ∀ x, 0 ≤ n x := fun x => le_max_right _ _
  let μ := (γpi ι).withDensity (fun x => ENNReal.ofReal (p x))
  let ν := (γpi ι).withDensity (fun x => ENNReal.ofReal (n x))
  let : IsFiniteMeasure μ := weighted_finite hp
  let : IsFiniteMeasure ν := weighted_finite hn
  have hμν : μ = ν := by
    apply Measure.ext_of_charFunDual
    funext L
    rw [charFunDual_eq_charFun_map_one, charFunDual_eq_charFun_map_one]
    have hh : μ.map L = ν.map L := by
      apply measure_eq_of_moments (weighted_linear_expSet hp hpn L)
        (weighted_linear_expSet hn hnn L)
      intro k
      rw [integral_map (by fun_prop) (by fun_prop), integral_map (by fun_prop) (by fun_prop)]
      rw [integral_weighted hp hpn, integral_weighted hn hnn]
      have hi := horth ((linearPoly L)^k)
      have hk := memLp_mvpoly ((linearPoly L)^k)
      simp only [map_pow, eval_linearPoly] at hi hk
      have heq : (fun x => f x * (L x)^k) = fun x => p x * (L x)^k - n x * (L x)^k := by
        funext x
        dsimp [p,n]
        rw [← sub_mul, max_zero_sub_max_neg_zero_eq_self]
      have hip : Integrable (fun x => p x * (L x)^k) (γpi ι) := by
        simpa only [Pi.mul_def] using hp.integrable_mul hk
      have hin : Integrable (fun x => n x * (L x)^k) (γpi ι) := by
        simpa only [Pi.mul_def] using hn.integrable_mul hk
      rw [heq, integral_sub hip hin] at hi
      exact sub_eq_zero.mp hi
    rw [hh]
  have hae := (withDensity_eq_iff_of_sigmaFinite
    hp.aestronglyMeasurable.aemeasurable.ennreal_ofReal
    hn.aestronglyMeasurable.aemeasurable.ennreal_ofReal).mp hμν
  filter_upwards [hae] with x hx
  have heq := congrArg ENNReal.toReal hx
  rw [ENNReal.toReal_ofReal (hpn x), ENNReal.toReal_ofReal (hnn x)] at heq
  have hd : p x - n x = f x := by dsimp [p,n]; exact max_zero_sub_max_neg_zero_eq_self _
  change f x = 0
  linarith

def psi (a : ι → ℕ) (x : ι → ℝ) : ℝ := ∏ i, H (a i) (x i)

lemma continuous_H (n : ℕ) : Continuous (H n) := by
  change Continuous (fun x => he n x / Real.sqrt (n.factorial : ℝ))
  simpa only [hePoly_eval] using (hePoly n).continuous.div_const _

lemma memLp_psi (a : ι → ℕ) : MemLp (psi a) 2 (γpi ι) := by
  apply (memLp_two_iff_integrable_sq
    (continuous_finsetProd _ (fun i _ => (continuous_H (a i)).comp (continuous_apply i))).aestronglyMeasurable).mpr
  simpa only [psi, Function.comp_def, Finset.prod_pow] using Integrable.fintype_prod
    (fun i => (memLp_two_iff_integrable_sq (continuous_H (a i)).aestronglyMeasurable).mp (memLp_H (a i)))

lemma psi_product (a b : ι → ℕ) :
    (∫ x, psi a x * psi b x ∂γpi ι) = if a = b then 1 else 0 := by
  classical
  simp only [psi, ← Finset.prod_mul_distrib]
  rw [integral_fintype_prod_eq_prod (f := fun i (t : ℝ) => H (a i) t * H (b i) t)
    (μ := fun _ => γ)]
  simp only [H_product]
  by_cases hab : a = b
  · simp [hab]
  · rw [ite_eq_right hab]
    obtain ⟨i,hi⟩ := Function.ne_iff.mp hab
    exact Finset.prod_eq_zero (Finset.mem_univ i) (ite_eq_right hi)

lemma heProd_eq (a : ι → ℕ) (x : ι → ℝ) :
    (∏ i, he (a i) (x i)) = (∏ i, Real.sqrt ((a i).factorial : ℝ)) * psi a x := by
  rw [psi, ← Finset.prod_mul_distrib]
  apply Finset.prod_congr rfl
  intro i _
  rw [H, mul_div_cancel₀ _ (ne_of_gt (sqrt_factorial_pos _))]

lemma ae_zero_of_integral_psi_eq_zero {f : (ι → ℝ) → ℝ} (hf : MemLp f 2 (γpi ι))
    (horth : ∀ a, (∫ x, f x * psi a x ∂γpi ι) = 0) : f =ᵐ[γpi ι] 0 := by
  apply ae_zero_of_integral_mvpoly_eq_zero hf
  apply ortho_mvpoly_of_polyProd hf
  apply ortho_polyProd_of_heProd hf
  intro a
  simp only [heProd_eq]
  rw [show (fun x => f x * ((∏ i, Real.sqrt ((a i).factorial : ℝ)) * psi a x)) =
      fun x => (∏ i, Real.sqrt ((a i).factorial : ℝ)) * (f x * psi a x) by funext x; ring,
    integral_const_mul, horth a, mul_zero]

def psiVec (a : ι → ℕ) : Lp ℝ 2 (γpi ι) := (memLp_psi a).toLp (psi a)

lemma psiVec_orthonormal : Orthonormal ℝ (psiVec (ι := ι)) := by
  rw [orthonormal_iff_ite]
  intro a b
  simpa only [psiVec, integral_inner_toLp] using psi_product a b

lemma eq_zero_of_inner_psiVec_eq_zero (f : Lp ℝ 2 (γpi ι))
    (h : ∀ a, inner ℝ f (psiVec a) = 0) : f = 0 := by
  have hae : (f : (ι → ℝ) → ℝ) =ᵐ[γpi ι] 0 := by
    apply ae_zero_of_integral_psi_eq_zero (Lp.memLp f)
    intro a
    have hi := h a
    rw [L2.inner_def] at hi
    convert hi using 1
    apply integral_congr_ae
    filter_upwards [(memLp_psi a).coeFn_toLp] with x hx
    simp only [psiVec, hx, RCLike.inner_apply, conj_trivial, mul_comm]
  apply Lp.ext
  exact hae.trans (Lp.coeFn_zero ℝ 2 (γpi ι)).symm

def productHermiteBasis : HilbertBasis (ι → ℕ) ℝ (Lp ℝ 2 (γpi ι)) :=
  HilbertBasis.mkOfOrthogonalEqBot psiVec_orthonormal (by
    apply eq_bot_iff.mpr
    intro f hf
    change f = 0
    apply eq_zero_of_inner_psiVec_eq_zero f
    intro a
    exact (Submodule.mem_orthogonal' _ f).mp hf _
      (Submodule.subset_span (Set.mem_range_self a)))

end Product

def affinePoly (r s : ℝ) : ℝ[X] := C r + C s * X
@[simp] lemma eval_affinePoly (r s x : ℝ) : (affinePoly r s).eval x = r+s*x := by
  simp [affinePoly]
@[simp] lemma derivative_affinePoly (r s : ℝ) : (affinePoly r s).derivative = C s := by
  simp [affinePoly]

lemma integrable_he_affine (n : ℕ) (r s : ℝ) :
    Integrable (fun x => he n (r+s*x)) γ := by
  simpa only [eval_comp, eval_affinePoly, hePoly_eval] using
    integrable_poly ((hePoly n).comp (affinePoly r s))

lemma integrable_mul_he_affine (n : ℕ) (r s : ℝ) :
    Integrable (fun x => x * he n (r+s*x)) γ := by
  convert integrable_poly (X * (hePoly n).comp (affinePoly r s)) using 1
  funext x
  simp only [Polynomial.eval_mul, eval_X, eval_comp, eval_affinePoly, hePoly_eval]

lemma stein_he_affine (n : ℕ) (r s : ℝ) :
    (∫ x, x * he (n+1) (r+s*x) ∂γ) = ((n+1:ℝ)*s) * ∫ x, he n (r+s*x) ∂γ := by
  have h := stein_poly ((hePoly (n+1)).comp (affinePoly r s))
  simp only [derivative_comp, derivative_hePoly, derivative_affinePoly, eval_comp,
    eval_affinePoly, hePoly_eval, eval_mul, eval_C, eval_smul, smul_eq_mul] at h
  rw [h, show (fun x => s * ((n+1:ℝ) * he n (r+s*x))) =
    fun x => ((n+1:ℝ)*s) * he n (r+s*x) by funext x; ring, integral_const_mul]

@[simp] lemma he_one (x : ℝ) : he 1 x = x := by
  rw [← hePoly_eval, show hePoly 1 = X by simp [hePoly_succ]]
  simp

lemma he_recurrence (n : ℕ) (x : ℝ) :
    he (n+2) x = x * he (n+1) x - (n+1:ℝ) * he n x := by
  rw [← hePoly_eval, show n+2 = (n+1)+1 by omega, hePoly_succ, derivative_hePoly]
  simp

lemma he_noise (ρ s c : ℝ) (h : ρ^2+s^2=1) (n : ℕ) :
    (∫ g, he n (ρ*c+s*g) ∂γ) = ρ^n * he n c := by
  induction n using Nat.twoStepInduction with
  | zero => simp [γ]
  | one =>
    have hi : Integrable (fun x : ℝ => x) γ := by simpa using integrable_poly X
    simp only [he_one, pow_one]
    rw [integral_add (integrable_const _) (hi.const_mul s), integral_const_mul]
    rw [integral_const_mul s]
    simp [γ]
  | more n ih0 ih1 =>
    have hi0 := integrable_he_affine n (ρ*c) s
    have hi1 := integrable_he_affine (n+1) (ρ*c) s
    have hig := integrable_mul_he_affine (n+1) (ρ*c) s
    have heq : (fun g => he (n+2) (ρ*c+s*g)) = fun g =>
        (ρ*c) * he (n+1) (ρ*c+s*g) + s*(g * he (n+1) (ρ*c+s*g)) -
        (n+1:ℝ)*he n (ρ*c+s*g) := by
      funext g
      rw [he_recurrence]
      ring
    rw [heq, integral_sub ((hi1.const_mul (ρ*c)).fun_add (hig.const_mul s)) (hi0.const_mul (n+1:ℝ)),
      integral_add (hi1.const_mul _) (hig.const_mul _)]
    simp only [integral_const_mul, stein_he_affine, ih0, ih1, he_recurrence, pow_succ]
    have hh : s*s = 1-ρ*ρ := by nlinarith [h]
    calc
      _ = ρ^n*ρ*ρ*c*he (n+1) c + ((s*s)-1)*((n+1:ℝ)*ρ^n*he n c) := by ring
      _ = _ := by rw [hh]; ring

lemma H_noise (ρ s c : ℝ) (h : ρ^2+s^2=1) (n : ℕ) :
    (∫ g, H n (ρ*c+s*g) ∂γ) = ρ^n * H n c := by
  simp only [H, integral_div, he_noise ρ s c h, mul_div_assoc]

variable {ι : Type*} [Fintype ι]

lemma psi_noise (ρ s : ℝ) (h : ρ^2+s^2=1) (a : ι → ℕ) (c : ι → ℝ) :
    (∫ g, psi a (fun i => ρ*c i+s*g i) ∂γpi ι) = ρ^(∑ i, a i)*psi a c := by
  simp only [psi]
  rw [integral_fintype_prod_eq_prod (f := fun i (t : ℝ) => H (a i) (ρ*c i+s*t))]
  simp only [H_noise ρ s _ h, Finset.prod_mul_distrib, Finset.prod_pow_eq_pow_sum]

lemma charFunDual_gamma (L : ℝ →L[ℝ] ℝ) :
    charFunDual γ L = Complex.exp ((-(L 1)^2 / 2 : ℝ) : ℂ) := by
  rw [charFunDual_eq_charFun_map_one, γ, gaussianReal_map_continuousLinearMap,
    charFun_gaussianReal]
  simp [Real.coe_toNNReal _ (sq_nonneg _), neg_div]

lemma charFunDual_gammaPi [DecidableEq ι] (L : (ι → ℝ) →L[ℝ] ℝ) :
    charFunDual (γpi ι) L =
      Complex.exp ((-(∑ i, (L (Pi.single i 1))^2) / 2 : ℝ) : ℂ) := by
  classical
  rw [γpi, charFunDual_pi]
  simp only [charFunDual_gamma, ContinuousLinearMap.comp_apply, ContinuousLinearMap.single_apply]
  rw [← Complex.exp_sum]
  congr 1
  simp only [Complex.ofReal_div, Complex.ofReal_neg, Complex.ofReal_sum,
    Complex.ofReal_pow, Complex.ofReal_ofNat]
  rw [← Finset.sum_div, Finset.sum_neg_distrib]

def rotation (ρ s : ℝ) : ((ι → ℝ) × (ι → ℝ)) →L[ℝ] ((ι → ℝ) × (ι → ℝ)) :=
  (ρ • ContinuousLinearMap.fst ℝ (ι → ℝ) (ι → ℝ) +
    s • ContinuousLinearMap.snd ℝ (ι → ℝ) (ι → ℝ)).prod
  (s • ContinuousLinearMap.fst ℝ (ι → ℝ) (ι → ℝ) -
    ρ • ContinuousLinearMap.snd ℝ (ι → ℝ) (ι → ℝ))

omit [Fintype ι] in
@[simp] lemma rotation_apply (ρ s : ℝ) (x : (ι → ℝ) × (ι → ℝ)) :
    rotation ρ s x = (ρ • x.1 + s • x.2, s • x.1 - ρ • x.2) := rfl

omit [Fintype ι] in
lemma rotation_involutive (ρ s : ℝ) (h : ρ^2+s^2=1) :
    Function.Involutive (rotation (ι := ι) ρ s) := by
  intro x
  ext i <;> simp only [rotation_apply, Pi.add_apply, Pi.sub_apply, Pi.smul_apply, smul_eq_mul]
  · calc
      _ = (ρ^2+s^2)*x.1 i := by ring
      _ = x.1 i := by rw [h, one_mul]
  · calc
      _ = (ρ^2+s^2)*x.2 i := by ring
      _ = x.2 i := by rw [h, one_mul]

lemma rotation_preserves (ρ s : ℝ) (h : ρ^2+s^2=1) :
    MeasurePreserving (rotation (ι := ι) ρ s) ((γpi ι).prod (γpi ι))
      ((γpi ι).prod (γpi ι)) := by
  classical
  refine ⟨by fun_prop, ?_⟩
  apply Measure.ext_of_charFunDual
  funext L
  rw [charFunDual_map, charFunDual_prod, charFunDual_prod]
  simp only [charFunDual_gammaPi, ContinuousLinearMap.comp_apply,
    ContinuousLinearMap.inl_apply, ContinuousLinearMap.inr_apply]
  have h1 (i : ι) : L (rotation ρ s (Pi.single i 1, 0)) =
      ρ * L (Pi.single i 1, 0) + s * L (0, Pi.single i 1) := by
    rw [show rotation ρ s (Pi.single i 1, 0) =
        ρ • (Pi.single i 1, 0) + s • (0, Pi.single i 1) by
          ext j <;> simp [rotation_apply]]
    simp only [map_add, map_smul, smul_eq_mul]
  have h2 (i : ι) : L (rotation ρ s (0, Pi.single i 1)) =
      s * L (Pi.single i 1, 0) - ρ * L (0, Pi.single i 1) := by
    rw [show rotation ρ s (0, Pi.single i 1) =
        s • (Pi.single i 1, 0) - ρ • (0, Pi.single i 1) by
          ext j <;> simp [rotation_apply]]
    simp only [map_sub, map_smul, smul_eq_mul]
  simp only [h1, h2]
  rw [← Complex.exp_add, ← Complex.exp_add, ← Complex.ofReal_add, ← Complex.ofReal_add]
  congr 1
  apply congrArg Complex.ofReal
  have hsum : (∑ i, (ρ * L (Pi.single i 1, 0) + s * L (0, Pi.single i 1))^2) +
      (∑ i, (s * L (Pi.single i 1, 0) - ρ * L (0, Pi.single i 1))^2) =
      (∑ i, (L (Pi.single i 1, 0))^2) + (∑ i, (L (0, Pi.single i 1))^2) := by
    rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro i _
    calc
      _ = (ρ^2+s^2)*((L (Pi.single i 1, 0))^2+(L (0, Pi.single i 1))^2) := by ring
      _ = _ := by rw [h, one_mul]
  linarith

def noise (ρ s : ℝ) (Q : (ι → ℝ) → ℝ) (x : ι → ℝ) : ℝ :=
  ∫ y, Q (ρ • x + s • y) ∂γpi ι

lemma measurable_noise (ρ s : ℝ) {Q : (ι → ℝ) → ℝ} (hQ : Measurable Q) :
    Measurable (noise ρ s Q) := by
  apply StronglyMeasurable.measurable
  apply StronglyMeasurable.integral_prod_right
  exact (hQ.comp (by fun_prop : Measurable (fun z : (ι → ℝ) × (ι → ℝ) =>
    ρ • z.1+s • z.2))).stronglyMeasurable

lemma psi_integrable (a : ι → ℕ) : Integrable (psi a) (γpi ι) :=
  (memLp_psi a).integrable (by norm_num)

lemma continuous_psi (a : ι → ℕ) : Continuous (psi a) := by
  unfold psi H he
  fun_prop

lemma noise_bound (ρ s : ℝ) {Q : (ι → ℝ) → ℝ} (hQ : ∀ x, |Q x| ≤ 1) (x : ι → ℝ) :
    |noise ρ s Q x| ≤ 1 := by
  simpa [noise, ← Real.norm_eq_abs] using norm_integral_le_of_norm_le_const
    (μ := γpi ι) (f := fun y => Q (ρ • x+s • y)) (C := 1)
      (ae_of_all _ fun y => by simpa only [Real.norm_eq_abs] using hQ _)

lemma noise_coefficient (ρ s : ℝ) (h : ρ^2+s^2=1) {Q : (ι → ℝ) → ℝ}
    (hQ : Measurable Q) (hb : ∀ x, |Q x| ≤ 1) (a : ι → ℕ) :
    (∫ x, psi a x * noise ρ s Q x ∂γpi ι) =
      ρ^(∑ i, a i) * ∫ x, psi a x * Q x ∂γpi ι := by
  let μ := (γpi ι).prod (γpi ι)
  let f : ((ι → ℝ) × (ι → ℝ)) → ℝ := fun z => psi a z.1 * Q (ρ • z.1+s • z.2)
  have hqm : Measurable (fun z : (ι → ℝ) × (ι → ℝ) => Q (ρ • z.1+s • z.2)) :=
    hQ.comp (by fun_prop)
  have hfm : Measurable f := ((continuous_psi a).measurable.comp measurable_fst).mul hqm
  have hfi : Integrable f μ := ((psi_integrable a).comp_fst (γpi ι)).mul_bdd
    hqm.aestronglyMeasurable (ae_of_all _ fun x => by
      simpa only [Real.norm_eq_abs] using hb _)
  have hm := rotation_preserves (ι := ι) ρ s h
  have hfm' : Measurable (f ∘ rotation ρ s) := hfm.comp (by fun_prop)
  have hfi' : Integrable (f ∘ rotation ρ s) μ :=
    (hm.integrable_comp hfm.aestronglyMeasurable).mpr hfi
  have htrans (z : (ι → ℝ) × (ι → ℝ)) :
      f (rotation ρ s z) = Q z.1 * psi a (ρ • z.1+s • z.2) := by
    have hx := congrArg Prod.fst (rotation_involutive (ι := ι) ρ s h z)
    change ρ • (ρ • z.1+s • z.2)+s • (s • z.1-ρ • z.2) = z.1 at hx
    dsimp [f, rotation_apply]
    rw [hx, mul_comm]
  calc
    _ = ∫ z, f z ∂μ := by
      rw [integral_prod _ hfi]
      apply integral_congr_ae
      filter_upwards [] with x
      exact (integral_const_mul _ _).symm
    _ = ∫ z, f (rotation ρ s z) ∂μ := by
      simpa only [hm.map_eq] using
        (integral_map (μ := (γpi ι).prod (γpi ι)) hm.measurable.aemeasurable hfm.aestronglyMeasurable)
    _ = ∫ x, ∫ y, Q x * psi a (ρ • x+s • y) ∂γpi ι ∂γpi ι := by
      change (∫ z, (f ∘ rotation ρ s) z ∂(γpi ι).prod (γpi ι)) = _
      rw [integral_prod _ hfi']
      apply integral_congr_ae
      filter_upwards [] with x
      apply integral_congr_ae
      filter_upwards [] with y
      exact htrans (x,y)
    _ = _ := by
      simp only [integral_const_mul, show ∀ x y : ι → ℝ, ρ • x+s • y =
          fun i => ρ*x i+s*y i by intros; rfl, psi_noise ρ s h]
      rw [← integral_const_mul]
      apply integral_congr_ae
      filter_upwards [] with x
      ring

lemma he_rotation_moment (ρ s c : ℝ) (h : ρ^2+s^2=1) (n : ℕ) :
    (∫ g, (s*c-ρ*g) * he n (ρ*c+s*g) ∂γ) = s*ρ^n*he (n+1) c := by
  have hi := integrable_he_affine n (ρ*c) s
  have hig := integrable_mul_he_affine n (ρ*c) s
  rw [show (fun g => (s*c-ρ*g)*he n (ρ*c+s*g)) = fun g =>
      (s*c)*he n (ρ*c+s*g)-ρ*(g*he n (ρ*c+s*g)) by funext g; ring,
    integral_sub (hi.const_mul _) (hig.const_mul _), integral_const_mul,
    integral_const_mul, he_noise ρ s c h]
  cases n with
  | zero => simp [γ, integral_id_gaussianReal]
  | succ n =>
    rw [stein_he_affine, he_noise ρ s c h, he_recurrence]
    simp only [pow_succ]
    ring

lemma sqrt_factorial_succ (n : ℕ) :
    Real.sqrt ((n+1).factorial : ℝ) = Real.sqrt (n+1:ℝ)*Real.sqrt (n.factorial : ℝ) := by
  rw [Nat.factorial_succ, Nat.cast_mul, Nat.cast_add, Nat.cast_one,
    Real.sqrt_mul (by positivity)]

lemma H_rotation_moment (ρ s c : ℝ) (h : ρ^2+s^2=1) (n : ℕ) :
    (∫ g, (s*c-ρ*g) * H n (ρ*c+s*g) ∂γ) =
      s*Real.sqrt (n+1:ℝ)*ρ^n*H (n+1) c := by
  simp only [H, ← mul_div_assoc, integral_div, he_rotation_moment ρ s c h]
  rw [sqrt_factorial_succ]
  have h1 : Real.sqrt (n+1:ℝ) ≠ 0 := by positivity
  have h2 := ne_of_gt (sqrt_factorial_pos n)
  field_simp

lemma psi_rotation_moment [DecidableEq ι] (ρ s : ℝ) (h : ρ^2+s^2=1)
    (a : ι → ℕ) (c : ι → ℝ) (i : ι) :
    (∫ g, (s*c i-ρ*g i) * psi a (ρ • c+s • g) ∂γpi ι) =
      s*Real.sqrt (a i+1:ℝ)*ρ^(∑ j,a j) * psi (Function.update a i (a i+1)) c := by
  have heq (g : ι → ℝ) : (s*c i-ρ*g i)*psi a (ρ • c+s • g) =
      ∏ j, (if j=i then s*c j-ρ*g j else 1)*H (a j) (ρ*c j+s*g j) := by
    rw [Finset.prod_mul_distrib]
    simp [psi, Finset.prod_ite_eq', Pi.add_apply, Pi.smul_apply, smul_eq_mul]
  simp only [heq]
  rw [integral_fintype_prod_eq_prod (f := fun j (t : ℝ) =>
    (if j=i then s*c j-ρ*t else 1)*H (a j) (ρ*c j+s*t))]
  have hfactor (j : ι) :
      (∫ t, (if j=i then s*c j-ρ*t else 1)*H (a j) (ρ*c j+s*t) ∂γ) =
        (if j=i then s*Real.sqrt (a i+1:ℝ) else 1)*
          (ρ^(a j)*H ((Function.update a i (a i+1)) j) (c j)) := by
    by_cases hj : j=i
    · subst j
      simp only [ite_true, Function.update_self, H_rotation_moment ρ s _ h]
      ring
    · simp only [hj, ite_false, one_mul, Function.update_of_ne hj, H_noise ρ s _ h]
  simp only [hfactor, Finset.prod_mul_distrib, Finset.prod_pow_eq_pow_sum]
  simp [Finset.prod_ite_eq', psi, mul_assoc]

def score (ρ s : ℝ) (Q : (ι → ℝ) → ℝ) (i : ι) (x : ι → ℝ) : ℝ :=
  ∫ g, g i * Q (ρ • x+s • g) ∂γpi ι

lemma measurable_score (ρ s : ℝ) {Q : (ι → ℝ) → ℝ} (hQ : Measurable Q) (i : ι) :
    Measurable (score ρ s Q i) := by
  apply StronglyMeasurable.measurable
  apply StronglyMeasurable.integral_prod_right
  exact (by fun_prop : Measurable (fun z : (ι → ℝ) × (ι → ℝ) =>
    z.2 i * Q (ρ • z.1+s • z.2))).stronglyMeasurable

lemma coordinate_integrable (i : ι) : Integrable (fun g : ι → ℝ => g i) (γpi ι) :=
  integrable_eval ((memLp_id_gaussianReal (μ := 0) (v := 1) 1).integrable (by norm_num))

lemma score_bound (ρ s : ℝ) {Q : (ι → ℝ) → ℝ} (hQ : Measurable Q)
    (hb : ∀ x, |Q x| ≤ 1) (i : ι) (x : ι → ℝ) :
    |score ρ s Q i x| ≤ ∫ g, |g i| ∂γpi ι := by
  have hi : Integrable (fun g : ι → ℝ => g i * Q (ρ • x+s • g)) (γpi ι) :=
    (coordinate_integrable i).mul_bdd (hQ.comp (by fun_prop)).aestronglyMeasurable
      (ae_of_all _ fun g => by simpa only [Real.norm_eq_abs] using hb _)
  calc
    _ ≤ ∫ g, |g i * Q (ρ • x+s • g)| ∂γpi ι := by
      simpa only [score, Real.norm_eq_abs] using norm_integral_le_integral_norm
        (fun g : ι → ℝ => g i * Q (ρ • x+s • g))
    _ ≤ _ := integral_mono_ae hi.abs (coordinate_integrable i).abs <|
      ae_of_all _ fun g => by
        change |g i * Q (ρ • x+s • g)| ≤ |g i|
        rw [abs_mul]
        exact mul_le_of_le_one_right (abs_nonneg _) (hb _)

lemma memLp_score (ρ s : ℝ) {Q : (ι → ℝ) → ℝ} (hQ : Measurable Q)
    (hb : ∀ x, |Q x| ≤ 1) (i : ι) : MemLp (score ρ s Q i) 2 (γpi ι) :=
  MemLp.of_bound (measurable_score ρ s hQ i).aestronglyMeasurable _
    (ae_of_all _ fun x => by simpa only [Real.norm_eq_abs] using score_bound ρ s hQ hb i x)

lemma score_coefficient [DecidableEq ι] (ρ s : ℝ) (h : ρ^2+s^2=1)
    {Q : (ι → ℝ) → ℝ} (hQ : Measurable Q) (hb : ∀ x, |Q x| ≤ 1)
    (a : ι → ℕ) (i : ι) :
    (∫ x, psi a x * score ρ s Q i x ∂γpi ι) =
      s*Real.sqrt (a i+1:ℝ)*ρ^(∑ j, a j) *
        ∫ x, psi (Function.update a i (a i+1)) x * Q x ∂γpi ι := by
  let μ := (γpi ι).prod (γpi ι)
  let f : ((ι → ℝ) × (ι → ℝ)) → ℝ := fun z =>
    (psi a z.1 * z.2 i) * Q (ρ • z.1+s • z.2)
  have hqm : Measurable (fun z : (ι → ℝ) × (ι → ℝ) => Q (ρ • z.1+s • z.2)) :=
    hQ.comp (by fun_prop)
  have hfm : Measurable f := (((continuous_psi a).measurable.comp measurable_fst).mul
    (by fun_prop)).mul hqm
  have hfi : Integrable f μ := ((psi_integrable a).mul_prod (coordinate_integrable i)).mul_bdd
    hqm.aestronglyMeasurable (ae_of_all _ fun x => by
      simpa only [Real.norm_eq_abs] using hb _)
  have hm := rotation_preserves (ι := ι) ρ s h
  have hfi' : Integrable (f ∘ rotation ρ s) μ :=
    (hm.integrable_comp hfm.aestronglyMeasurable).mpr hfi
  have htrans (z : (ι → ℝ) × (ι → ℝ)) :
      f (rotation ρ s z) = Q z.1 * ((s*z.1 i-ρ*z.2 i)*psi a (ρ • z.1+s • z.2)) := by
    have hx := congrArg Prod.fst (rotation_involutive (ι := ι) ρ s h z)
    change ρ • (ρ • z.1+s • z.2)+s • (s • z.1-ρ • z.2) = z.1 at hx
    dsimp [f, rotation_apply]
    rw [hx]
    ring
  calc
    _ = ∫ z, f z ∂μ := by
      rw [integral_prod _ hfi]
      apply integral_congr_ae
      filter_upwards [] with x
      rw [score, ← integral_const_mul]
      apply integral_congr_ae
      filter_upwards [] with y
      dsimp [f]
      ring
    _ = ∫ z, f (rotation ρ s z) ∂μ := by
      simpa only [hm.map_eq] using
        (integral_map (μ := (γpi ι).prod (γpi ι)) hm.measurable.aemeasurable hfm.aestronglyMeasurable)
    _ = ∫ x, ∫ y, Q x * ((s*x i-ρ*y i)*psi a (ρ • x+s • y)) ∂γpi ι ∂γpi ι := by
      change (∫ z, (f ∘ rotation ρ s) z ∂(γpi ι).prod (γpi ι)) = _
      rw [integral_prod _ hfi']
      apply integral_congr_ae
      filter_upwards [] with x
      apply integral_congr_ae
      filter_upwards [] with y
      exact htrans (x,y)
    _ = _ := by
      simp only [integral_const_mul, psi_rotation_moment ρ s h]
      rw [← integral_const_mul]
      apply integral_congr_ae
      filter_upwards [] with x
      ring

def coeff (f : (ι → ℝ) → ℝ) (a : ι → ℕ) : ℝ := ∫ x, psi a x * f x ∂γpi ι

def degree (a : ι → ℕ) : ℕ := ∑ i, a i

def bump [DecidableEq ι] (i : ι) (a : ι → ℕ) : ι → ℕ := Function.update a i (a i+1)

lemma degree_bump [DecidableEq ι] (i : ι) (a : ι → ℕ) :
    degree (bump i a) = degree a+1 := by
  have heq (j : ι) : bump i a j = a j + if j=i then 1 else 0 := by
    by_cases hj : j=i <;> simp [bump, hj, Function.update_of_ne]
  simp only [degree, heq, Finset.sum_add_distrib]
  simp [Finset.sum_ite_eq']

omit [Fintype ι] in
lemma bump_injective [DecidableEq ι] (i : ι) : Function.Injective (bump i : (ι → ℕ) → _) := by
  intro a b h
  funext j
  by_cases hj : j=i
  · subst j
    have heq := congrFun h i
    simpa [bump] using heq
  · simpa [bump, Function.update_of_ne hj] using congrFun h j

end MinUncut.GaussianHermite
end

end OAI